一、输入映射和输出映射
1.1 parameterType(输入类型)
【传递简单类型】
详情参考Mybatis学习笔记之一（环境搭建和入门案例介绍）
使用#{}占位符，或者${}进行sql拼接。
【传递pojo对象】
详情参考Mybatis学习笔记之一（环境搭建和入门案例介绍）
Mybatis使用ognl表达式解析对象字段的值，#{}或者${}括号中的值为pojo属性名称。
1.2 传递pojo包装对象
开发中通过可以使用pojo传递查询条件。查询条件可能是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如查询用户信息的时候，将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。
包装对象：Pojo类中的一个属性是另外一个pojo。
需求：根据用户名模糊查询用户信息，查询条件放到QueryVo的user属性中。
【编写QueryVo类】
package com.kevin.entity; import java.io.Serializable;
import java.util.List; import com.kevin.entity.User; public class QueryVo implements Serializable { /**
*
*/
private static final long serialVersionUID = 1L; private User user; public void setUser(User user) {
this.user = user;
}
}
【Mapper.xml文件】
在UserMapper.xml中配置sql，如下：
<!-- 根据QueryVo查询 -->
<select id="findUserByQueryVo" parameterType="QueryVo" resultType="User">
select * from User where username like "%"#{user.username}"%"
</select>
【Mapper接口】
在UserMapper接口中添加方法，如下：
/*
* 使用QueryVo根据用户名称模糊查询
*/
public List<User> findUserByQueryVo(QueryVo vo);
【测试方法】
在UserMapeprTest增加测试方法，如下：
/*
* 使用QueryVo根据用户名称模糊查询
*/
@Test
public void findUserByQueryVo() throws Exception{
String resource = "SqlMapConfig.xml";
InputStream in = Resources.getResourceAsStream(resource);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
SqlSession sqlSession = factory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class); QueryVo vo = new QueryVo();
User user = new User();
user.setUsername("王");
vo.setUser(user); List<User> list = userMapper.findUserByQueryVo(vo);
for (User user2 : list) {
System.out.println(user2);
}
}
1.3 resultType(输出类型)
1.3.1 输出简单类型
需求:查询用户表数据条数
【Mapper.xml文件】
在UserMapper.xml中配置sql，如下：
<!-- 查询数据条数 -->
<select id="countUser" resultType="Integer">
select count(*) from User
</select>
【Mapper接口】
在UserMapper添加方法，如下：
/*
* 查询数据条数
*/
public Integer countUser();
【 测试方法】
/*
* 查询数据条数
*/
@Test
public void countUser() throws Exception{
String resource = "SqlMapConfig.xml";
InputStream in = Resources.getResourceAsStream(resource);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
SqlSession sqlSession = factory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class); Integer count = userMapper.countUser();
System.out.println(count); }
Tips：输出简单类型必须查询出来的结果集有一条记录，最终将第一个字段的值转换为输出类型。
1.3.2 输出pojo对象
详情参考Mybatis学习笔记之一（环境搭建和入门案例介绍）
1.3.3 输出pojo列表
详情参考Mybatis学习笔记之一（环境搭建和入门案例介绍）
1.4 resultMap
resultType可以指定将查询结果映射为pojo，但需要pojo的属性名和sql查询的列名一致方可映射成功。如果sql查询字段名和pojo的属性名不一致，可以通过resultMap将字段名和属性名作一个对应关系 ，resultMap实质上还需要将查询结果映射到pojo对象中。resultMap可以实现将查询结果映射为复杂类型的pojo，比如在查询结果映射对象中包括pojo和list实现一对一查询和一对多查询。
需求：查询订单表order的所有数据
【声明pojo对象】
package com.kevin.entity; import java.io.Serializable;
import java.util.Date; public class Orders implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L; private Integer id; private Integer userId; private String number; private Date createtime; private String note; public Integer getId() {
return id;
} public void setId(Integer id) {
this.id = id;
} public Integer getUserId() {
return userId;
} public void setUserId(Integer userId) {
this.userId = userId;
} public String getNumber() {
return number;
} public void setNumber(String number) {
this.number = number == null ? null : number.trim();
} public Date getCreatetime() {
return createtime;
} public void setCreatetime(Date createtime) {
this.createtime = createtime;
} public String getNote() {
return note;
} public void setNote(String note) {
this.note = note == null ? null : note.trim();
} @Override
public String toString() {
return "Orders [id=" + id + ", userId=" + userId + ", number=" + number + ", createtime=" + createtime
+ ", note=" + note + "]";
} }
【Mapper.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="com.kevin.mapper.OrdersMapper">
<!-- 查询所有数据 -->
<select id="findAll" resultType="Orders">
select * from Orders
</select> </mapper>
【Mapper接口】
package com.kevin.mapper;
import java.util.List;
import com.kevin.entity.Orders;
public interface OrdersMapper {
/*
* 查询所有数据（类属性与数据库字段不一致）
*/
public List<Orders> findAll();
}
【测试方法】
/*
*查询所有数据（属性名称与数据库字段名称不一致）
*/
@Test
public void findAll() throws Exception{
String resource = "SqlMapConfig.xml";
InputStream in = Resources.getResourceAsStream(resource);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
SqlSession sqlSession = factory.openSession();
OrdersMapper mapper = sqlSession.getMapper(OrdersMapper.class); List<Orders> list = mapper.findAll();
for (Orders order : list) {
System.out.println(order);
} }
1.4.1 使用resultMap
由于上边的mapper.xml中sql查询列(user_id)和Order类属性(userId)不一致，所以查询结果不能映射到pojo中。需要定义resultMap，把orderResultMap将sql查询列(user_id)和Order类属性(userId)对应起来
改造OrderMapper.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="com.kevin.mapper.OrdersMapper">
<resultMap type="Orders" id="orders">
<result column="user_id" property="userId"/>
</resultMap>
<!-- 查询所有数据 -->
<!-- <select id="findAll" resultType="Orders"> -->
<select id="findAll" resultMap="orders">
select * from Orders
</select> </mapper>
二、动态sql拼接
通过mybatis提供的各种标签方法实现动态拼接sql。
需求：根据性别和名字查询用户
2.1 使用If标签和WHERE标签
【Mapper.xml文件】
<!-- 多条件查询 where标签可以去掉前面第一个and -->
<select id="findUserBySexAndUsername" parameterType="User" resultType="User">
select * from User
<where>
<if test="sex != null and sex != ''">
sex = #{sex}
</if>
<if test="username != null">
and username = #{username}
</if>
</where>
</select>
【Mapper接口】
编写Mapper接口，如下：
/*
* 多条件查询
*/
public List<User> findUserBySexAndUsername(User user);
【测试方法】
在UserMapperTest添加测试方法，如下：
/*
* 多条件查询
*/
@Test
public void findUserBySexAndUsername() throws Exception{
String resource = "SqlMapConfig.xml";
InputStream in = Resources.getResourceAsStream(resource);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
SqlSession sqlSession = factory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class); User user = new User();
user.setUsername("Kevin");
user.setSex("Male"); List<User> list = mapper.findUserBySexAndUsername(user);
for (User u: list) {
System.out.println(u);
} }
2.2 Sql片段
Sql中可将重复的sql提取出来，使用时用include引用即可，最终达到sql重用的目的。
把上面例子中的select * from User 提取出来，作为sql片段，如下：
<!-- 提取SQL语句中重复片段 -->
<sql id="selector">
select * from User
</sql> <!-- 多条件查询 where标签可以去掉前面第一个and -->
<select id="findUserBySexAndUsername" parameterType="User" resultType="User">
<include refid="selector"></include>
<where>
<if test="sex != null and sex != ''">
sex = #{sex}
</if>
<if test="username != null">
and username = #{username}
</if>
</where>
</select>
2.3 foreach标签
需求：根据多个id查询用户信息
【改造QueryVo】
如下面在pojo中定义list属性ids存储多个用户id，并添加setter方法
package com.kevin.entity; import java.io.Serializable;
import java.util.List; import com.kevin.entity.User; public class QueryVo implements Serializable { /**
*
*/
private static final long serialVersionUID = 1L; private User user; private List<Integer> list; public void setList(List<Integer> list) {
this.list = list;
} public void setUser(User user) {
this.user = user;
} }
【Mapper.xml文件】
UserMapper.xml添加sql，如下：
<!-- 根据多个id查询 -->
<select id="findUserByIds" parameterType="QueryVo" resultType="User">
<include refid="selector"></include>
where id in
<foreach collection="list" item="id" separator="," open="(" close=")">
#{id}
</foreach>
</select>
【测试方法】
/*
*根据多个id查询
*/
@Test
public void findUserByIds() throws Exception{
String resource = "SqlMapConfig.xml";
InputStream in = Resources.getResourceAsStream(resource);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
SqlSession sqlSession = factory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
/*
* 使用QueryVo中的List列表
*/
List<Integer> lists = new ArrayList<Integer>();
lists.add(28);
lists.add(29);
lists.add(25);
lists.add(30);
QueryVo vo = new QueryVo();
vo.setList(lists); List<User> list = mapper.findUserByIds(lists);
for (User u: list) {
System.out.println(u);
}
}
三、关联查询
3.1 一对一查询
需求：查询所有订单信息，关联查询下单用户信息。
注意：因为一个订单信息只会是一个人下的订单，所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则为一对多查询，因为一个用户可以下多个订单。
方法一：使用resultType
使用resultType，改造订单pojo类，此pojo类中包括了订单信息和用户信息，这样返回对象的时候，mybatis自动把用户信息也注入进来了。
【改造pojo类】
OrderUser类继承Order类后OrderUser类包括了Order类的所有字段，只需要定义用户的信息字段即可，如下图：
【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>
【Mapper接口】
在UserMapper接口添加方法，如下图：
【测试方法】
在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();
}
【小结】
定义专门的pojo类作为输出类型，其中定义了sql查询结果集所有的字段。此方法较为简单，企业中使用普遍。
方法二：使用resultMap
使用resultMap，定义专门的resultMap用于映射一对一查询结果。
【改造pojo类】
在Order类中加入User属性，user属性中用于存储关联查询的用户信息，因为订单关联查询用户是一对一关系，所以这里使用单个User对象存储关联查询的用户信息。
改造Order如下：
package com.kevin.entity; import java.io.Serializable;
import java.util.Date; public class Orders implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
private Integer id;
private Integer userId;
private String number;
private Date createtime;
private String note;
private User user;
public void setUser(User user) {
this.user = user;
} public Integer getId() {
return id;
} public void setId(Integer id) {
this.id = id;
} public Integer getUserId() {
return userId;
} public void setUserId(Integer userId) {
this.userId = userId;
} public String getNumber() {
return number;
} public void setNumber(String number) {
this.number = number == null ? null : number.trim();
} public Date getCreatetime() {
return createtime;
} public void setCreatetime(Date createtime) {
this.createtime = createtime;
} public String getNote() {
return note;
} public void setNote(String note) {
this.note = note == null ? null : note.trim();
} @Override
public String toString() {
return "Orders [id=" + id + ", userId=" + userId + ", number=" + number + ", createtime=" + createtime
+ ", note=" + note + "]";
} }
【Mapper.xml】
<!-- 一对一关联查询 -->
<resultMap type="Orders" id="order">
<result column="id" property="id"/>
<result column="user_id" property="userId"/>
<result column="number" property="number"/>
<result column="createtime" property="createtime"/>
<!-- 一对一 -->
<association property="user" javaType="User">
<id column="user_id" property="id"/>
<result column="username" property="username"/>
</association>
</resultMap>
<select id="selectOrders" resultMap="order">
select
o.id,
o.user_id,
o.number,
o.createtime,
u.username
from orders o
left join user u
on o.user_id = u.id
</select>
【Mapper接口】
/*
* 一对一关联查询，以订单为中心关联用户
*/
public List<Orders> selectOrders();
【测试方法】
在UserMapperTest增加测试方法，如下：
/*
* 一对一查询
*/
@Test
public void selectOrders() throws Exception{
String resource = "SqlMapConfig.xml";
InputStream in = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
SqlSession sqlSession = sqlSessionFactory.openSession();
OrdersMapper mapper = sqlSession.getMapper(OrdersMapper.class);
List<Orders> selectOrders = mapper.selectOrders();
for (Orders orders : selectOrders) {
System.out.println(orders);
}
}
3.2 一对多查询
案例：查询所有用户信息及用户关联的订单信息。用户信息和订单信息为一对多关系。
【修改pojo类】
在User类中加入List<Orders> ordersList属性,如下：
package com.kevin.entity; import java.util.Date;
import java.util.List; public class User {
/**
* 创建一个简单的bean
*/
private static final long serialVersionUID = 1L;
private Integer id;
private String username;// 用户姓名
private String sex;// 性别
private Date birthday;// 生日
private String address;// 地址 private List<Orders> ordersList; public List<Orders> getOrdersList() {
return ordersList;
}
public void setOrdersList(List<Orders> ordersList) {
this.ordersList = ordersList;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "User [id=" + id + ", username=" + username + ", sex=" + sex
+ ", birthday=" + birthday + ", address=" + address + "]";
} }
【Mapper.xml】
<!-- /*
* 一对多关联
*/
public List<User> selectUsersList(); -->
<resultMap type="User" id="user">
<id column="user_id" property="id"/>
<result column="username" property="username"/>
<!-- 一对多 -->
<collection property="ordersList" ofType="Orders">
<id column="id" property="id"/>
<result column="number" property="number"/>
</collection>
</resultMap>
<select id="selectUserList" resultMap="user">
select
o.id,
o.user_id,
o.number,
o.createtime,
u.username
from user u
left join orders o
on o.user_id = u.id
</select>
【Mapper接口】
编写UserMapper接口，如下：
/*
* 一对多关联
*/
public List<User> selectUserList();
【测试方法】
/*
* 一对多关联
*/
@Test
public void selectUsersList() throws Exception{
String resource = "SqlMapConfig.xml";
InputStream in = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
SqlSession sqlSession = sqlSessionFactory.openSession();
OrdersMapper mapper = sqlSession.getMapper(OrdersMapper.class); List<User> selectUsersList = mapper.selectUserList();
for (User user : selectUsersList) {
System.out.println(user);
}
}
四、Mybatis整合spring
4.1 整合思路
● SqlSessionFactory对象应该放到spring容器中作为单例存在。
● 传统dao的开发方式中，应该从spring容器中获得sqlsession对象。
● Mapper代理形式中，应该从spring容器中直接获得mapper的代理对象。
● 数据库的连接以及数据库连接池事务管理都交给spring容器来完成。
4.2 整合需要的jar包
● spring的jar包
● Mybatis的jar包
● Spring+mybatis的整合包。
● Mysql的数据库驱动jar包。
● 数据库连接池的jar包。
4.3 整合的步骤
【创建工程】
创建一个java工程
【导入jar包】
前面提到的jar包需要导入，如下图：
【加入配置文件】
● SqlMapConfig.xml.xml配置文件
● applicationContext.xml配置文件：
a) 数据库连接及连接池
b) 事务管理（暂时可以不配置）
c) sqlsessionFactory对象，配置到spring容器中
d) mapeer代理对象或者是dao实现类配置到spring容器中。
【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>
<!-- 2. 指定扫描包，会把包内所有的类都设置别名，别名的名称就是类名，大小写不敏感 -->
<package name="com.kevin.entity" />
</typeAliases> <mappers>
<package name="com.kevin.mapper"/>
</mappers> </configuration>
【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> <!-- mybatis工厂 -->
<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 配置数据源 -->
<property name="dataSource" ref="dataSource"></property>
<!-- 配置mybatis核心配置文件 -->
<property name="configLocation" value="classpath:SqlMapConfig.xml"></property>
</bean> </beans>
【db.properties】
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=admin
【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
4.4 Dao的开发
两种dao的实现方式：
● 原始dao的开发方式
● 使用Mapper代理形式开发方式
a) 直接配置Mapper代理
b) 使用扫描包配置Mapper代理
需求：
实现根据用户id查询
实现根据用户名模糊查询
添加用户
传统方式Dao开发可参考Mybatis学习笔记之一（环境搭建和入门案例介绍），下面主要介绍Mapper动态代理形式开发。
4.5 Mapper代理形式开发
【实现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="com.kevin.mapper.UserMapper"> <select id="findUserById" parameterType="Integer" resultType="User">
select * from User where id = #{id}
</select> </mapper>
【实现UserMapper接口】
package com.kevin.mapper;
import java.util.List;
import com.kevin.entity.User;
public interface UserMapper {
public User findUserById(Integer id);
}
方式一：配置mapper代理
在applicationContext.xml添加配置
<!-- mapper动态代理开发 -->
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
<property name="sqlSessionFactory" ref="sqlSessionFactoryBean"></property>
<property name="mapperInterface" value="com.kevin.mapper.UserMapper"></property>
</bean>
【测试方法】
/*
* mapper动态代理开发
*/
@Test
public void findUserById(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
// context.getBean(UserMapper.class);
UserMapper userMapper = (UserMapper) context.getBean("userMapper");
User user = userMapper.findUserById(1);
System.out.println(user); }
方式二：扫描包形式配置mapper
在applicationContext.xml添加配置
<!-- mapper动态代理开发，扫描 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 基本包 -->
<property name="basePackage" value="com.kevin.mapper"></property>
</bean>
【测试方法】
/*
* 增强mapper动态代理开发
*/
@Test
public void findUserById2(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper mapper = context.getBean(UserMapper.class);
User user = mapper.findUserById(30);
System.out.println(user); }