Mybatis第二天（其他）

2023-08-08 11:04:28

Mybatis第二天

框架课程

课程计划

动态sql
1. If标签
2. Where标签
3. Sql片段
4. Foreach标签
关联查询
1. 一对一关联
2. 一对多关联
Mybatis整合spring
1. 如何整合spring
2. 使用原始的方式开发dao
3. 使用Mapper接口动态代理
Mybatis逆向工程
SpringMVC介绍
入门程序
SpringMVC架构讲解
1. 框架结构
2. 组件说明
SpringMVC整合MyBatis
1. 动态sql
通过mybatis提供的各种标签方法实现动态拼接sql。

需求：根据性别和名字查询用户

查询sql：

SELECT id, username, birthday, sex, address FROM `user` WHERE sex = 1 AND username LIKE '%张%'
1. If标签
  1. Mapper.xml文件
UserMapper.xml配置sql，如下：



<select id="queryUserByWhere" parameterType="user" resultType="user">

SELECT id, username, birthday, sex, address FROM `user`

WHERE sex = #{sex} AND username LIKE

'%${username}%'

</select>
1. Mapper接口
编写Mapper接口，如下图：
1. 测试方法
在UserMapperTest添加测试方法，如下：

@Test

public void testQueryUserByWhere() {

// mybatis和spring整合，整合之后，交给spring管理

SqlSession sqlSession = this.sqlSessionFactory.openSession();

// 创建Mapper接口的动态代理对象，整合之后，交给spring管理

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

// 使用userMapper执行根据条件查询用户

User user = new User();

user.setSex("1");

user.setUsername("张");

List<User> list = userMapper.queryUserByWhere(user);

for (User u : list) {

System.out.println(u);

}

// mybatis和spring整合，整合之后，交给spring管理

sqlSession.close();

}
1. 效果
测试效果如下图：

如果注释掉 user.setSex("1")，测试结果如下图：

测试结果二很显然不合理。

按照之前所学的，要解决这个问题，需要编写多个sql，查询条件越多，需要编写的sql就更多了，显然这样是不靠谱的。

解决方案，使用动态sql的if标签
1. 使用if标签
改造UserMapper.xml，如下：



<select id="queryUserByWhere" parameterType="user" resultType="user">

SELECT id, username, birthday, sex, address FROM `user`

WHERE 1=1

<if test="sex != null and sex != ''">

AND sex = #{sex}

</if>

<if test="username != null and username != ''">

AND username LIKE

'%${username}%'

</if>

</select>

注意字符串类型的数据需要要做不等于空字符串校验。
1. 效果
如上图所示，测试OK
1. Where标签
上面的sql还有where 1=1 这样的语句，很麻烦

可以使用where标签进行改造

改造UserMapper.xml，如下



<select id="queryUserByWhere" parameterType="user" resultType="user">

SELECT id, username, birthday, sex, address FROM `user`



<where>

<if test="sex != null">

AND sex = #{sex}

</if>

<if test="username != null and username != ''">

AND username LIKE

'%${username}%'

</if>

</where>

</select>
1. 效果
测试效果如下图：
1. Sql片段
Sql中可将重复的sql提取出来，使用时用include引用即可，最终达到sql重用的目的。

把上面例子中的id, username, birthday, sex, address提取出来，作为sql片段，如下：



<select id="queryUserByWhere" parameterType="user" resultType="user">





SELECT <include refid="userFields" /> FROM `user`



<where>

<if test="sex != null">

AND sex = #{sex}

</if>

<if test="username != null and username != ''">

AND username LIKE

'%${username}%'

</if>

</where>

</select>



<sql id="userFields">

id, username, birthday, sex, address

</sql>

如果要使用别的Mapper.xml配置的sql片段，可以在refid前面加上对应的Mapper.xml的namespace

例如下图
1. foreach标签
向sql传递数组或List，mybatis使用foreach解析，如下：

根据多个id查询用户信息

查询sql：

SELECT * FROM user WHERE id IN (1,10,24)
1. 改造QueryVo
如下图在pojo中定义list属性ids存储多个用户id，并添加getter/setter方法
1. Mapper.xml文件
UserMapper.xml添加sql，如下：



<select id="queryUserByIds" parameterType="queryVo" resultType="user">

SELECT * FROM `user`

<where>













<foreach collection="ids" item="item" open="id IN (" close=")"

separator=",">

#{item}

</foreach>

</where>

</select>

测试方法如下图：

@Test

public void testQueryUserByIds() {

// mybatis和spring整合，整合之后，交给spring管理

SqlSession sqlSession = this.sqlSessionFactory.openSession();

// 创建Mapper接口的动态代理对象，整合之后，交给spring管理

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

// 使用userMapper执行根据条件查询用户

QueryVo queryVo = new QueryVo();

List<Integer> ids = new ArrayList<>();

ids.add(1);

ids.add(10);

ids.add(24);

queryVo.setIds(ids);

List<User> list = userMapper.queryUserByIds(queryVo);

for (User u : list) {

System.out.println(u);

}

// mybatis和spring整合，整合之后，交给spring管理

sqlSession.close();

}
1. 效果
测试效果如下图：
1. 关联查询
1. 商品订单数据模型
1. 一对一查询
需求：查询所有订单信息，关联查询下单用户信息。

注意：因为一个订单信息只会是一个人下的订单，所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则为一对多查询，因为一个用户可以下多个订单。

sql语句：

SELECT

o.id,

o.user_id userId,

o.number,

o.createtime,

o.note,

u.username,

u.address

FROM

`order` o

LEFT JOIN `user` u ON o.user_id = u.id
1. 方法一：使用resultType
使用resultType，改造订单pojo类，此pojo类中包括了订单信息和用户信息

这样返回对象的时候，mybatis自动把用户信息也注入进来了
1. 改造pojo类
OrderUser类继承Order类后OrderUser类包括了Order类的所有字段，只需要定义用户的信息字段即可，如下图：
1. Mapper.xml
在UserMapper.xml添加sql，如下



<select id="queryOrderUser" resultType="orderUser">

SELECT

o.id,

o.user_id

userId,

o.number,

o.createtime,

o.note,

u.username,

u.address

FROM

`order` o

LEFT JOIN `user` u ON o.user_id = u.id

</select>
1. Mapper接口
在UserMapper接口添加方法，如下图：
1. 测试方法：
在UserMapperTest添加测试方法，如下：

@Test

public void testQueryOrderUser() {

// mybatis和spring整合，整合之后，交给spring管理

SqlSession sqlSession = this.sqlSessionFactory.openSession();

// 创建Mapper接口的动态代理对象，整合之后，交给spring管理

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

// 使用userMapper执行根据条件查询用户

List<OrderUser> list = userMapper.queryOrderUser();

for (OrderUser ou : list) {

System.out.println(ou);

}

// mybatis和spring整合，整合之后，交给spring管理

sqlSession.close();

}
1. 效果
测试结果如下图：
1. 小结
定义专门的pojo类作为输出类型，其中定义了sql查询结果集所有的字段。此方法较为简单，企业中使用普遍。
1. 方法二：使用resultMap
使用resultMap，定义专门的resultMap用于映射一对一查询结果。
1. 改造pojo类
在Order类中加入User属性，user属性中用于存储关联查询的用户信息，因为订单关联查询用户是一对一关系，所以这里使用单个User对象存储关联查询的用户信息。

改造Order如下图：
1. Mapper.xml
这里resultMap指定orderUserResultMap，如下：

<resultMap type="order" id="orderUserResultMap">

<id property="id" column="id" />

<result property="userId" column="user_id" />

<result property="number" column="number" />

<result property="createtime" column="createtime" />

<result property="note" column="note" />







<association property="user" javaType="user">



<id property="id" column="user_id" />

<result property="username" column="username" />

<result property="address" column="address" />

</association>

</resultMap>



<select id="queryOrderUserResultMap" resultMap="orderUserResultMap">

SELECT

o.id,

o.user_id,

o.number,

o.createtime,

o.note,

u.username,

u.address

FROM

`order` o

LEFT JOIN `user` u ON o.user_id = u.id

</select>
1. Mapper接口
编写UserMapper如下图：
1. 测试方法
在UserMapperTest增加测试方法，如下：

@Test

public void testQueryOrderUserResultMap() {

// mybatis和spring整合，整合之后，交给spring管理

SqlSession sqlSession = this.sqlSessionFactory.openSession();

// 创建Mapper接口的动态代理对象，整合之后，交给spring管理

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

// 使用userMapper执行根据条件查询用户

List<Order> list = userMapper.queryOrderUserResultMap();

for (Order o : list) {

System.out.println(o);

}

// mybatis和spring整合，整合之后，交给spring管理

sqlSession.close();

}
1. 效果
测试效果如下图：
1. 一对多查询
案例：查询所有用户信息及用户关联的订单信息。

用户信息和订单信息为一对多关系。

sql语句：

SELECT

u.id,

u.username,

u.birthday,

u.sex,

u.address,

o.id oid,

o.number,

o.createtime,

o.note

FROM

`user` u

LEFT JOIN `order` o ON u.id = o.user_id
1. 修改pojo类
在User类中加入List<Order> orders属性,如下图：
1. Mapper.xml
在UserMapper.xml添加sql，如下：

<resultMap type="user" id="userOrderResultMap">

<id property="id" column="id" />

<result property="username" column="username" />

<result property="birthday" column="birthday" />

<result property="sex" column="sex" />

<result property="address" column="address" />



<collection property="orders" javaType="list" ofType="order">



<id property="id" column="oid" />

<result property="number" column="number" />

<result property="createtime" column="createtime" />

<result property="note" column="note" />

</collection>

</resultMap>



<select id="queryUserOrder" resultMap="userOrderResultMap">

SELECT

u.id,

u.username,

u.birthday,

u.sex,

u.address,

o.id oid,

o.number,

o.createtime,

o.note

FROM

`user` u

LEFT JOIN `order` o ON u.id = o.user_id

</select>
1. Mapper接口
编写UserMapper接口，如下图：
1. 测试方法
在UserMapperTest增加测试方法，如下

@Test

public void testQueryUserOrder() {

// mybatis和spring整合，整合之后，交给spring管理

SqlSession sqlSession = this.sqlSessionFactory.openSession();

// 创建Mapper接口的动态代理对象，整合之后，交给spring管理

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

// 使用userMapper执行根据条件查询用户

List<User> list = userMapper.queryUserOrder();

for (User u : list) {

System.out.println(u);

}

// mybatis和spring整合，整合之后，交给spring管理

sqlSession.close();

}
1. 效果
测试效果如下图：
1. Mybatis整合spring
1. 整合思路
SqlSessionFactory对象应该放到spring容器中作为单例存在。
传统dao的开发方式中，应该从spring容器中获得sqlsession对象。
Mapper代理形式中，应该从spring容器中直接获得mapper的代理对象。
数据库的连接以及数据库连接池事务管理都交给spring容器来完成。
1. 整合需要的jar包
spring的jar包
Mybatis的jar包
Spring+mybatis的整合包。
Mysql的数据库驱动jar包。
数据库连接池的jar包。

jar包位置如下所示：
1. 整合的步骤
  1. 创建工程
如下图创建一个java工程：
1. 导入jar包
前面提到的jar包需要导入，如下图：
1. 加入配置文件
mybatisSpring的配置文件
的配置文件sqlmapConfig.xml
1. 数据库连接及连接池
2. 事务管理（暂时可以不配置）
3. sqlsessionFactory对象，配置到spring容器中
4. mapeer代理对象或者是dao实现类配置到spring容器中。
创建资源文件夹config拷贝加入配置文件，如下图
1. SqlMapConfig.xml
配置文件是SqlMapConfig.xml，如下：

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE configuration

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>



<typeAliases>



<package name="cn.itcast.mybatis.pojo" />

</typeAliases>

</configuration>
1. applicationContext.xml
SqlSessionFactoryBean属于mybatis-spring这个jar包

对于spring来说，mybatis是另外一个架构，需要整合jar包。

在项目中加入mybatis-spring-1.2.2.jar的源码，如下图

效果，如下图所示，图标变化，表示源码加载成功：

整合Mybatis需要的是SqlSessionFactoryBean，位置如下图：

applicationContext.xml，配置内容如下

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">



<context:property-placeholder location="classpath:db.properties" />



<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close">

<property name="driverClassName" value="${jdbc.driver}" />

<property name="url" value="${jdbc.url}" />

<property name="username" value="${jdbc.username}" />

<property name="password" value="${jdbc.password}" />

<property name="maxActive" value="10" />

<property name="maxIdle" value="5" />

</bean>



<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">



<property name="configLocation" value="classpath:SqlMapConfig.xml" />



<property name="dataSource" ref="dataSource" />

</bean>

</beans>
1. db.properties
jdbc.driver=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8

jdbc.username=root

jdbc.password=root
1. log4j.properties
# Global logging configuration

log4j.rootLogger=DEBUG, stdout

# Console output...

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
1. 效果：
加入的配置文件最终效果如下：
1. Dao的开发
两种dao的实现方式：
原始dao的开发方式
使用Mapper代理形式开发方式
1. 直接配置Mapper代理
2. 使用扫描包配置Mapper代理
需求：
实现根据用户id查询
实现根据用户名模糊查询
添加用户
1. 创建pojo
public class User {

private int id;

private String username;// 用户姓名

private String sex;// 性别

private Date birthday;// 生日

private String address;// 地址

get/set。。。

}
1. 传统dao的开发方式
原始的DAO开发接口+实现类来完成。

需要dao实现类需要继承SqlsessionDaoSupport类
1. 实现Mapper.xml
编写User.xml配置文件，如下：

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE mapper

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="test">



<select id="queryUserById" parameterType="int" resultType="user">

select * from user where id = #{id}

</select>



<select id="queryUserByUsername" parameterType="string"

resultType="user">

select * from user where username like '%${value}%'

</select>



<insert id="saveUser" parameterType="user">

<selectKey keyProperty="id" keyColumn="id" order="AFTER"

resultType="int">

select last_insert_id()

</selectKey>

insert into user

(username,birthday,sex,address)

values

(#{username},#{birthday},#{sex},#{address})

</insert>

</mapper>
1. 加载Mapper.xml
在SqlMapConfig如下图进行配置:
1. 实现UserDao接口
public interface UserDao {

/**

* 根据id查询用户

*

* @param id

* @return

*/

User queryUserById(int id);

/**

* 根据用户名模糊查询用户列表

*

* @param username

* @return

*/

List<User> queryUserByUsername(String username);

/**

* 保存

*

* @param user

*/

void saveUser(User user);

}
1. 实现UserDaoImpl实现类
编写DAO实现类，实现类必须集成SqlSessionDaoSupport

SqlSessionDaoSupport提供getSqlSession()方法来获取SqlSession

public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {

@Override

public User queryUserById(int id) {

// 获取SqlSession

SqlSession sqlSession = super.getSqlSession();

// 使用SqlSession执行操作

User user = sqlSession.selectOne("queryUserById", id);

// 不要关闭sqlSession

return user;

}

@Override

public List<User> queryUserByUsername(String username) {

// 获取SqlSession

SqlSession sqlSession = super.getSqlSession();

// 使用SqlSession执行操作

List<User> list = sqlSession.selectList("queryUserByUsername", username);

// 不要关闭sqlSession

return list;

}

@Override

public void saveUser(User user) {

// 获取SqlSession

SqlSession sqlSession = super.getSqlSession();

// 使用SqlSession执行操作

sqlSession.insert("saveUser", user);

// 不用提交,事务由spring进行管理

// 不要关闭sqlSession

}

}
1. 配置dao
把dao实现类配置到spring容器中，如下图
1. 测试方法
创建测试方法，可以直接创建测试Junit用例。

如下图所示进行创建。

编写测试方法如下：

public class UserDaoTest {

private ApplicationContext context;

@Before

public void setUp() throws Exception {

this.context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");

}

@Test

public void testQueryUserById() {

// 获取userDao

UserDao userDao = this.context.getBean(UserDao.class);

User user = userDao.queryUserById(1);

System.out.println(user);

}

@Test

public void testQueryUserByUsername() {

// 获取userDao

UserDao userDao = this.context.getBean(UserDao.class);

List<User> list = userDao.queryUserByUsername("张");

for (User user : list) {

System.out.println(user);

}

}

@Test

public void testSaveUser() {

// 获取userDao

UserDao userDao = this.context.getBean(UserDao.class);

User user = new User();

user.setUsername("曹操");

user.setSex("1");

user.setBirthday(new Date());

user.setAddress("三国");

userDao.saveUser(user);

System.out.println(user);

}

}
1. Mapper代理形式开发dao
  1. 实现Mapper.xml
编写UserMapper.xml配置文件，如下：

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE mapper

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="cn.itcast.mybatis.mapper.UserMapper">



<select id="queryUserById" parameterType="int" resultType="user">

select * from user where id = #{id}

</select>



<select id="queryUserByUsername" parameterType="string"

resultType="user">

select * from user where username like '%${value}%'

</select>



<insert id="saveUser" parameterType="user">

<selectKey keyProperty="id" keyColumn="id" order="AFTER"

resultType="int">

select last_insert_id()

</selectKey>

insert into user

(username,birthday,sex,address) values

(#{username},#{birthday},#{sex},#{address})

</insert>

</mapper>
1. 实现UserMapper接口
public interface UserMapper {

/**

* 根据用户id查询

*

* @param id

* @return

*/

User queryUserById(int id);

/**

* 根据用户名模糊查询用户

*

* @param username

* @return

*/

List<User> queryUserByUsername(String username);

/**

* 添加用户

*

* @param user

*/

void saveUser(User user);

}
1. 方式一：配置mapper代理
在applicationContext.xml添加配置

MapperFactoryBean也是属于mybatis-spring整合包



<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">



<property name="mapperInterface" value="cn.itcast.mybatis.mapper.UserMapper" />



<property name="sqlSessionFactory" ref="sqlSessionFactory" />

</bean>
1. 测试方法
public class UserMapperTest {

private ApplicationContext context;

@Before

public void setUp() throws Exception {

this.context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");

}

@Test

public void testQueryUserById() {

// 获取Mapper

UserMapper userMapper = this.context.getBean(UserMapper.class);

User user = userMapper.queryUserById(1);

System.out.println(user);

}

@Test

public void testQueryUserByUsername() {

// 获取Mapper

UserMapper userMapper = this.context.getBean(UserMapper.class);

List<User> list = userMapper.queryUserByUsername("张");

for (User user : list) {

System.out.println(user);

}

}

@Test

public void testSaveUser() {

// 获取Mapper

UserMapper userMapper = this.context.getBean(UserMapper.class);

User user = new User();

user.setUsername("曹操");

user.setSex("1");

user.setBirthday(new Date());

user.setAddress("三国");

userMapper.saveUser(user);

System.out.println(user);

}

}
1. 方式二：扫描包形式配置mapper


<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">



<property name="basePackage" value="cn.itcast.mybatis.mapper" />

</bean>

每个mapper代理对象的id就是类名，首字母小写
1. Mybatis逆向工程
使用官方网站的Mapper自动生成工具mybatis-generator-core-1.3.2来生成po类和Mapper映射文件
1. 导入逆向工程
使用课前资料已有逆向工程，如下图：
1. 复制逆向工程到工作空间中
复制的效果如下图：
1. 导入逆向工程到eclipse中
如下图方式进行导入：
1. 修改配置文件
在generatorConfig.xml中配置Mapper生成的详细信息，如下图：

注意修改以下几点:
1. 修改要生成的数据库表
2. pojo文件所在包路径
3. Mapper所在的包路径
配置文件如下:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE generatorConfiguration

PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"

"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>

<context id="testTables" targetRuntime="MyBatis3">

<commentGenerator>



<property name="suppressAllComments" value="true" />

</commentGenerator>



<jdbcConnection driverClass="com.mysql.jdbc.Driver"

connectionURL="jdbc:mysql://localhost:3306/mybatis" userId="root" password="root">

</jdbcConnection>





<javaTypeResolver>

<property name="forceBigDecimals" value="false" />

</javaTypeResolver>



<javaModelGenerator targetPackage="cn.itcast.ssm.po"

targetProject=".\src">



<property name="enableSubPackages" value="false" />



<property name="trimStrings" value="true" />

</javaModelGenerator>



<sqlMapGenerator targetPackage="cn.itcast.ssm.mapper"

targetProject=".\src">



<property name="enableSubPackages" value="false" />

</sqlMapGenerator>



<javaClientGenerator type="XMLMAPPER"

targetPackage="cn.itcast.ssm.mapper" targetProject=".\src">



<property name="enableSubPackages" value="false" />

</javaClientGenerator>



<table schema="" tableName="user"></table>

<table schema="" tableName="order"></table>

</context>

</generatorConfiguration>
1. 生成逆向工程代码
找到下图所示的java文件，执行工程main主函数,

刷新工程，发现代码生成，如下图：
1. 测试逆向工程代码
1. 复制生成的代码到mybatis-spring工程，如下图

2. 修改spring配置文件

在applicationContext.xml修改



<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">





<property name="basePackage" value="cn.itcast.ssm.mapper" />

</bean>

3. 编写测试方法：

public class UserMapperTest {

private ApplicationContext context;

@Before

public void setUp() throws Exception {

this.context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");

}

@Test

public void testInsert() {

// 获取Mapper

UserMapper userMapper = this.context.getBean(UserMapper.class);

User user = new User();

user.setUsername("曹操");

user.setSex("1");

user.setBirthday(new Date());

user.setAddress("三国");

userMapper.insert(user);

}

@Test

public void testSelectByExample() {

// 获取Mapper

UserMapper userMapper = this.context.getBean(UserMapper.class);

// 创建User对象扩展类，用户设置查询条件

UserExample example = new UserExample();

example.createCriteria().andUsernameLike("%张%");

// 查询数据

List<User> list = userMapper.selectByExample(example);

System.out.println(list.size());

}

@Test

public void testSelectByPrimaryKey() {

// 获取Mapper

UserMapper userMapper = this.context.getBean(UserMapper.class);

User user = userMapper.selectByPrimaryKey(1);

System.out.println(user);

}

}

注意：
逆向工程生成的代码只能做单表查询
不能在生成的代码上进行扩展，因为如果数据库变更，需要重新使用逆向工程生成代码，原来编写的代码就被覆盖了。
个文件
1. Spring入门
1. Springmvc是什么
Spring web mvc和Struts2都属于表现层的框架,它是Spring框架的一部分,我们可以从Spring的整体结构中看得出来,如下图：
1. Springmvc处理流程
如下图所示：
1. 入门程序
需求：使用浏览器显示商品列表
1. 创建web工程
springMVC是表现层框架，需要搭建web工程开发。

如下图创建动态web工程：

输入工程名，选择配置Tomcat（如果已有，则直接使用），如下图：

配置Tomcat，如下图：

选择准备好的Tomcat，这里用的是Tomcat7，如下图：

选择成功，点击Finish，如下图：

选择刚刚设置成功的Tomcat，如下图：

如下图选择web的版本是2.5，可以自动生成web.xml配置文件，

创建效果如下图：
1. 导入jar包
从课前资料中导入springMVC的jar包，位置如下图：

复制jar到lib目录，工程直接加载jar包，如下图：
1. 加入配置文件
创建config资源文件夹，存放配置文件，如下图：
1. 创建springmvc.xml
创建SpringMVC的核心配置文件

SpringMVC本身就是Spring的子项目，对Spring兼容性很好，不需要做很多配置。

这里只配置一个Controller扫描就可以了，让Spring对页面控制层Controller进行管理。

创建springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:mvc="http://www.springframework.org/schema/mvc"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">



<context:component-scan base-package="cn.itcast.springmvc.controller" />

</beans>

配置文件需要的约束文件，位置如下图：

创建包cn.itcast.springmvc.controller

效果如下图：
1. 配置前端控制器
配置SpringMVC的前端控制器DispatcherServlet

在web.xml中

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://java.sun.com/xml/ns/javaee"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

id="WebApp_ID" version="2.5">

<display-name>springmvc-first</display-name>

<welcome-file-list>

<welcome-file>index.html</welcome-file>

<welcome-file>index.htm</welcome-file>

<welcome-file>index.jsp</welcome-file>

<welcome-file>default.html</welcome-file>

<welcome-file>default.htm</welcome-file>

<welcome-file>default.jsp</welcome-file>

</welcome-file-list>



<servlet>

<servlet-name>springmvc-first</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>





<init-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:springmvc.xml</param-value>

</init-param>

</servlet>

<servlet-mapping>

<servlet-name>springmvc-first</servlet-name>



<url-pattern>*.action</url-pattern>

</servlet-mapping>

</web-app>
1. 加入jsp页面
把参考资料中的itemList.jsp复制到工程的/WEB-INF/jsp目录下，如下图：
1. 实现显示商品列表页
  1. 创建pojo
分析页面，查看页面需要的数据，如下图：

创建商品pojo

public class Item {

// 商品id

private int id;

// 商品名称

private String name;

// 商品价格

private double price;

// 商品创建时间

private Date createtime;

// 商品描述

private String detail;

创建带参数的构造器

set/get。。。

}
1. 创建ItemController
ItemController是一个普通的java类，不需要实现任何接口。

需要在类上添加@Controller注解，把Controller交由Spring管理

在方法上面添加@RequestMapping注解，里面指定请求的url。其中".action"可以加也可以不加。

@Controller

public class ItemController {

// @RequestMapping：里面放的是请求的url，和用户请求的url进行匹配

// action可以写也可以不写

@RequestMapping("/itemList.action")

public ModelAndView queryItemList() {

// 创建页面需要显示的商品数据

List<Item> list = new ArrayList<>();

list.add(new Item(1, "1华为荣耀8", 2399, new Date(), "质量好！1"));

list.add(new Item(2, "2华为荣耀8", 2399, new Date(), "质量好！2"));

list.add(new Item(3, "3华为荣耀8", 2399, new Date(), "质量好！3"));

list.add(new Item(4, "4华为荣耀8", 2399, new Date(), "质量好！4"));

list.add(new Item(5, "5华为荣耀8", 2399, new Date(), "质量好！5"));

list.add(new Item(6, "6华为荣耀8", 2399, new Date(), "质量好！6"));

// 创建ModelAndView，用来存放数据和视图

ModelAndView modelAndView = new ModelAndView();

// 设置数据到模型中

modelAndView.addObject("list", list);

// 设置视图jsp，需要设置视图的物理地址

modelAndView.setViewName("/WEB-INF/jsp/itemList.jsp");

return modelAndView;

}

}
1. 启动项目测试
启动项目，浏览器访问地址

http://127.0.0.1:8080/springmvc-first/itemList.action

效果如下图：

为什么可以用呢？我们需要分析一下springMVC的架构图。
1. Springmvc架构
1. 框架结构
框架结构如下图：
1. 架构流程
  1. 用户发送请求至前端控制器DispatcherServlet
  2. DispatcherServlet收到请求调用HandlerMapping处理器映射器。
  3. 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
  4. DispatcherServlet通过HandlerAdapter处理器适配器调用处理器
  5. 执行处理器(Controller，也叫后端控制器)。
  6. Controller执行完成返回ModelAndView
  7. HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet
  8. DispatcherServlet将ModelAndView传给ViewReslover视图解析器
  9. ViewReslover解析后返回具体View
  10. DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。
  11. DispatcherServlet响应用户
2. 组件说明
以下组件通常使用框架提供实现：

DispatcherServlet：前端控制器

用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。

HandlerMapping：处理器映射器

HandlerMapping负责根据用户请求url找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

Handler：处理器

Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。

由于Handler涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。

HandlAdapter：处理器适配器

通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

下图是许多不同的适配器，最终都可以使用usb接口连接

ViewResolver：视图解析器

View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。

View：视图

springmvc框架提供了很多的View视图类型的支持，包括：jstlView、freemarkerView、pdfView等。我们最常用的视图就是jsp。

一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

说明：在springmvc的各个组件中，处理器映射器、处理器适配器、视图解析器称为springmvc的三大组件。

需要用户开发的组件有handler、view

默认加载的组件

我们没有做任何配置，就可以使用这些组件

因为框架已经默认加载这些组件了，配置文件位置如下图：

# Default implementation classes for DispatcherServlet's strategy interfaces.

# Used as fallback when no matching beans are found in the DispatcherServlet context.

# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\

org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\

org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\

org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter

org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver,\

org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\

org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

组件扫描器

使用组件扫描器省去在spring容器配置每个Controller类的繁琐。

使用<context:component-scan>自动扫描标记@Controller的控制器类，

在springmvc.xml配置文件中配置如下：

<context:component-scan base-package="cn.itcast.springmvc.controller" />

注解映射器和适配器
1. 配置处理器映射器

注解式处理器映射器，对类中标记了@ResquestMapping的方法进行映射。根据@ResquestMapping定义的url匹配@ResquestMapping标记的方法，匹配成功返回HandlerMethod对象给前端控制器。

HandlerMethod对象中封装url对应的方法Method。

从spring3.1版本开始，废除了DefaultAnnotationHandlerMapping的使用，推荐使用RequestMappingHandlerMapping完成注解式处理器映射。

在springmvc.xml配置文件中配置如下：

<bean

class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping" />

注解描述：

@RequestMapping：定义请求url到处理器功能方法的映射

配置处理器适配器

注解式处理器适配器，对标记@ResquestMapping的方法进行适配。

从spring3.1版本开始，废除了AnnotationMethodHandlerAdapter的使用，推荐使用RequestMappingHandlerAdapter完成注解式处理器适配。

在springmvc.xml配置文件中配置如下：

<bean

class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter" />

注解驱动

直接配置处理器映射器和处理器适配器比较麻烦，可以使用注解驱动来加载。

SpringMVC使用<mvc:annotation-driven>自动加载RequestMappingHandlerMapping和RequestMappingHandlerAdapter

可以在springmvc.xml配置文件中使用<mvc:annotation-driven>替代注解处理器和适配器的配置。

<mvc:annotation-driven />

视图解析器

视图解析器使用SpringMVC框架默认的InternalResourceViewResolver，这个视图解析器支持JSP视图解析

在springmvc.xml配置文件中配置如下：

<!-- Example: prefix="/WEB-INF/jsp/", suffix=".jsp", viewname="test" ->

"/WEB-INF/jsp/test.jsp" -->

<bean

class="org.springframework.web.servlet.view.InternalResourceViewResolver">

</bean>

逻辑视图名需要在controller中返回ModelAndView指定，比如逻辑视图名为ItemList，则最终返回的jsp视图地址:

"WEB-INF/jsp/itemList.jsp"

最终jsp物理地址：前缀+逻辑视图名+后缀

修改ItemController

修改ItemController中设置视图的代码

// @RequestMapping：里面放的是请求的url，和用户请求的url进行匹配

// action可以写也可以不写

@RequestMapping("/itemList.action")

public ModelAndView queryItemList() {

// 创建页面需要显示的商品数据

List<Item> list = new ArrayList<>();

list.add(new Item(1, "1华为荣耀8", 2399, new Date(), "质量好！1"));

list.add(new Item(2, "2华为荣耀8", 2399, new Date(), "质量好！2"));

list.add(new Item(3, "3华为荣耀8", 2399, new Date(), "质量好！3"));

list.add(new Item(4, "4华为荣耀8", 2399, new Date(), "质量好！4"));

list.add(new Item(5, "5华为荣耀8", 2399, new Date(), "质量好！5"));

list.add(new Item(6, "6华为荣耀8", 2399, new Date(), "质量好！6"));

// 创建ModelAndView，用来存放数据和视图

ModelAndView modelAndView = new ModelAndView();

// 设置数据到模型中

modelAndView.addObject("itemList", list);

// 设置视图jsp，需要设置视图的物理地址

// modelAndView.setViewName("/WEB-INF/jsp/itemList.jsp");

// 配置好视图解析器前缀和后缀，这里只需要设置逻辑视图就可以了。

// 视图解析器根据前缀+逻辑视图名+后缀拼接出来物理路径

modelAndView.setViewName("itemList");

return modelAndView;

}

效果

效果和之前一样，如下图：

整合mybatis

为了更好的学习 springmvc和mybatis整合开发的方法，需要将springmvc和mybatis进行整合。

整合目标：控制层采用springmvc、持久层使用mybatis实现。

创建数据库表

sql脚本，位置如下图：

创建数据库表springmvc，导入到数据库中，如下图：

需要的jar包
1. spring（包括springmvc）
2. mybatis
3. mybatis-spring整合包
4. 数据库驱动
5. 第三方连接池。

jar包位置如下图：

整合思路

Dao层：

SqlMapConfig.xml，空文件即可，但是需要文件头。
applicationContext-dao.xml
1. 数据库连接池
2. SqlSessionFactory对象，需要spring和mybatis整合包下的。
3. 配置mapper文件扫描器。
Service层：
applicationContext-service.xml包扫描器，扫描@service注解的类。
applicationContext-trans.xml配置事务。

Controller层：
Springmvc.xml
1. 包扫描器，扫描@Controller注解的类。
2. 配置注解驱动
3. 配置视图解析器
Web.xml文件：
配置spring
配置前端控制器。
1. 创建工程
创建动态web工程springmvc-web，如下图：
1. 加入jar包
复制jar包到/WEB-INF/lib中

工程自动加载jar包
1. 加入配置文件
创建资源文件夹config

在其下创建mybatis和spring文件夹，用来存放配置文件，如下图：
1. sqlMapConfig.xml
使用逆向工程来生成Mapper相关代码，不需要配置别名。

在config/mybatis下创建SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE configuration

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

</configuration>
1. applicationContext-dao.xml
配置数据源、配置SqlSessionFactory、mapper扫描器。

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">



<context:property-placeholder location="classpath:db.properties" />



<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close">

<property name="driverClassName" value="${jdbc.driver}" />

<property name="url" value="${jdbc.url}" />

<property name="username" value="${jdbc.username}" />

<property name="password" value="${jdbc.password}" />

<property name="maxActive" value="10" />

<property name="maxIdle" value="5" />

</bean>



<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">



<property name="dataSource" ref="dataSource" />



<property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml" />

</bean>



<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">



<property name="basePackage" value="cn.itcast.ssm.mapper" />

</bean>

</beans>
1. db.properties
配置数据库相关信息

jdbc.driver=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/springmvc?characterEncoding=utf-8

jdbc.username=root

jdbc.password=root
1. applicationContext-service.xml
<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">



<context:component-scan base-package="cn.itcast.ssm.service" />

</beans>
1. applicationContext-trans.xml
<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">



<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">



<property name="dataSource" ref="dataSource" />

</bean>



<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>



<tx:method name="save*" propagation="REQUIRED" />

<tx:method name="insert*" propagation="REQUIRED" />

<tx:method name="delete*" propagation="REQUIRED" />

<tx:method name="update*" propagation="REQUIRED" />

<tx:method name="find*" propagation="SUPPORTS" read-only="true" />

<tx:method name="get*" propagation="SUPPORTS" read-only="true" />

<tx:method name="query*" propagation="SUPPORTS" read-only="true" />

</tx:attributes>

</tx:advice>



<aop:config>

<aop:advisor advice-ref="txAdvice"

pointcut="execution(* cn.itcast.ssm.service.*.*(..))" />

</aop:config>

</beans>
1. springmvc.xml
<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:mvc="http://www.springframework.org/schema/mvc"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">



<context:component-scan base-package="cn.itcast.ssm.controller" />



<mvc:annotation-driven />





<bean

class="org.springframework.web.servlet.view.InternalResourceViewResolver">



<property name="prefix" value="/WEB-INF/jsp/" />



<property name="suffix" value=".jsp" />

</bean>

</beans>
1. web.xml
<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://java.sun.com/xml/ns/javaee"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

id="WebApp_ID" version="2.5">

<display-name>springmvc-web</display-name>

<welcome-file-list>

<welcome-file>index.html</welcome-file>

<welcome-file>index.htm</welcome-file>

<welcome-file>index.jsp</welcome-file>

<welcome-file>default.html</welcome-file>

<welcome-file>default.htm</welcome-file>

<welcome-file>default.jsp</welcome-file>

</welcome-file-list>



<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:spring/applicationContext*.xml</param-value>

</context-param>



<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>



<servlet>

<servlet-name>springmvc-web</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<init-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:spring/springmvc.xml</param-value>

</init-param>

</servlet>

<servlet-mapping>

<servlet-name>springmvc-web</servlet-name>



<url-pattern>*.action</url-pattern>

</servlet-mapping>

</web-app>
1. 加入jsp页面
复制课前资料的itemList.jsp和itemEdit.jsp到工程中
1. 效果
配置完效果如下图：
1. 实现商品列表显示
1. 需求
实现商品查询列表，从mysql数据库查询商品信息。
1. DAO开发
使用逆向工程，生成代码

注意修改逆向工程的配置文件，参考MyBatis第二天

逆向工程生成代码如下图：
1. ItemService接口
public interface ItemService {

/**

* 查询商品列表

*

* @return

*/

List<Item> queryItemList();

}
1. ItemServiceImpl实现类
@Service

public class ItemServiceImpl implements ItemService {

@Autowired

private ItemMapper itemMapper;

@Override

public List<Item> queryItemList() {

// 从数据库查询商品数据

List<Item> list = this.itemMapper.selectByExample(null);

return list;

}

}
1. ItemController
@Controller

public class ItemController {

@Autowired

private ItemService itemService;

/**

* 显示商品列表

*

* @return

*/

@RequestMapping("/itemList")

public ModelAndView queryItemList() {

// 获取商品数据

List<Item> list = this.itemService.queryItemList();

ModelAndView modelAndView = new ModelAndView();

// 把商品数据放到模型中

modelAndView.addObject("itemList", list);

// 设置逻辑视图

modelAndView.setViewName("itemList");

return modelAndView;

}

}
1. 测试
访问url：

http://127.0.0.1:8080/springmvc-web/itemList.action

效果如下图：

码农公寓

课程计划

动态sql

If标签

Mapper.xml文件

Mapper接口

测试方法

效果

使用if标签

效果

Where标签

效果

Sql片段

foreach标签

改造QueryVo

Mapper.xml文件

效果

关联查询

商品订单数据模型

一对一查询

方法一：使用resultType

改造pojo类

Mapper.xml

Mapper接口

测试方法：

效果

小结

方法二：使用resultMap

改造pojo类

Mapper.xml

Mapper接口

测试方法

效果

一对多查询

修改pojo类

Mapper.xml

Mapper接口

测试方法

效果

Mybatis整合spring

整合思路

整合需要的jar包

整合的步骤

创建工程

导入jar包

加入配置文件

SqlMapConfig.xml

applicationContext.xml

db.properties

log4j.properties

效果：

Dao的开发

创建pojo

传统dao的开发方式

实现Mapper.xml

加载Mapper.xml

实现UserDao接口

实现UserDaoImpl实现类

配置dao

测试方法

Mapper代理形式开发dao

实现Mapper.xml

实现UserMapper接口

方式一：配置mapper代理

测试方法

方式二：扫描包形式配置mapper

Mybatis逆向工程

导入逆向工程

复制逆向工程到工作空间中

导入逆向工程到eclipse中

修改配置文件

生成逆向工程代码

测试逆向工程代码

Spring入门

Springmvc是什么

Springmvc处理流程

入门程序

创建web工程

导入jar包

加入配置文件