0. 学习目标

MyBatis连接池
MyBatis的事务控制
MyBatis一对一查询（一对多）
MyBatis多对多查询

1. Mybatis连接池

1.1 MyBatis连接池的分类

在mybatis中，我们将他的数据源datasource分为以下几类：
可以看出 Mybatis 将它自己的数据源分为三类：

UNPOOLED 不使用连接池的数据源

POOLED 使用连接池的数据源

JNDI 使用 JNDI 实现的数据源

具体结构如下：

在这三种数据源中，我们一般采用的是 POOLED 数据源（很多时候我们所说的数据源就是为了更好的管理数据库连接，也就是我们所说的连接池技术）。

1.1.2 MyBatis中配置数据源

我们在配置文件中的具体配置如下：

<dataSource type="POOLED">
    <property name="driver" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</dataSource>

MyBatis 在初始化时，根据的 type 属性来创建相应类型的的数据源 DataSource，即： type=”POOLED”：MyBatis 会创建 PooledDataSource 实例

type=”UNPOOLED” ： MyBatis 会创建 UnpooledDataSource 实例

type=”JNDI”：MyBatis 会从 JNDI 服务上查找 DataSource 实例，然后返回使用

1.1.3 MyBatis中DataSource的存取

MyBatis 是通过工厂模式来创建数据源 DataSource 对象的， MyBatis 定义了抽象的工厂接口:org.apache.ibatis.datasource.DataSourceFactory,通过其 getDataSource()方法返回数据源 DataSource。

下面是DataSourceFactory源码，具体如下：

package org.apache.ibatis.datasource;
import java.util.Properties;
import javax.sql.DataSource;
/** * @author Clinton Begin */
public interface DataSourceFactory {
   
 void setProperties(Properties props);
 DataSource getDataSource();
}

MyBatis 创建了 DataSource 实例后，会将其放到 Configuration 对象内的 Environment 对象中，供以后使用。具体分析过程如下：

先进入 XMLConfigBuilder 类中，可以找到如下代码：
分析 configuration 对象的 environment 属性，结果如下:

1.1.4 MyBatis中连接获取过程分析

当我们需要创建 SqlSession 对象并需要执行 SQL 语句时，这时候 MyBatis 才会去调用 dataSource 对象来创建java.sql.Connection对象。也就是说，java.sql.Connection对象的创建一直延迟到执行SQL语句的时候。

@Test
public void testSql() throws Exception {
   
    InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
    SqlSession sqlSession = factory.openSession();
    List<User> list = sqlSession.selectList("findUserById",41);
    System.out.println(list.size());
}

只有当第 4 句 sqlSession.selectList(“findUserById”)，才会触发 MyBatis 在底层执行下面这个方法来创建 java.sql.Connection 对象。如何证明它的加载过程呢？我们可以通过断点调试，在 PooledDataSource 中找到如下 popConnection()方法，如下所示：

分析源代码，得出 PooledDataSource 工作原理如下：

下面是连接获取的源代码：最后我们可以发现，真正连接打开的时间点，只是在我们执行SQL语句时，才会进行。其实这样做我们也可以进一步发现，数据库连接是我们最为宝贵的资源，只有在要用到的时候，才去获取并打开连接，当我们用完了就再立即将数据库连接归还到连接池中。

2. MyBatis的事务控制

2.1.1 JDBC中事务的回顾

在 JDBC 中我们可以通过手动方式将事务的提交改为手动方式，通过 setAutoCommit()方法就可以调整。通过 JDK 文档，我们找到该方法如下：

那么我们的 Mybatis 框架因为是对 JDBC 的封装，所以 Mybatis 框架的事务控制方式，本身也是用 JDBC 的 setAutoCommit()方法来设置事务提交方式的。

2.1.2 MyBatis中事务的提交方式

Mybatis 中事务的提交方式，本质上就是调用 JDBC 的 setAutoCommit()来实现事务控制。我们运行之前所写的代码：

@Test
public void testSaveUser() throws Exception {
   
	User user = new User();
	user.setUsername("mybatis user09");
	//6.执行操作
	int res = userDao.saveUser(user);
	System.out.println(res);
	System.out.println(user.getId());
}
@Before//在测试方法执行之前执行
public void init()throws Exception {
   
	//1.读取配置文件
	in = Resources.getResourceAsStream("SqlMapConfig.xml");
	//2.创建构建者对象
	SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
	//3.创建 SqlSession 工厂对象
	factory = builder.build(in);
	//4.创建 SqlSession 对象
	session = factory.openSession();
	//5.创建 Dao 的代理对象
	userDao = session.getMapper(IUserDao.class);
}
@After//在测试方法执行完成之后执行
public void destroy() throws Exception{
   
//7.提交事务
    session.commit();
//8.释放资源
	session.close();
	in.close();
}

2.1.3MyBatis自动提交事务的设置

通过上面的研究和分析，现在我们一起思考，为什么 CUD 过程中必须使用 sqlSession.commit()提交事务？主要原因就是在连接池中取出的连接，都会将调用 connection.setAutoCommit(false)方法，这样我们就必须使用 sqlSession.commit()方法，相当于使用了 JDBC 中的 connection.commit()方法实现事务提交。

明白这一点后，我们现在一起尝试不进行手动提交，一样实现 CUD 操作。

@Before//在测试方法执行之前执行
public void init()throws Exception {
   
	//1.读取配置文件
	in = Resources.getResourceAsStream("SqlMapConfig.xml");
	//2.创建构建者对象
	SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
	//3.创建 SqlSession 工厂对象
	factory = builder.build(in);
	//4.创建 SqlSession 对象
	session = factory.openSession(true);
	//5.创建 Dao 的代理对象
	userDao = session.getMapper(IUserDao.class);
}
@After//在测试方法执行完成之后执行
public void destroy() throws Exception{
   
	//7.释放资源
    session.close();
	in.close();
}

所对应的 DefaultSqlSessionFactory 类的源代码：
我们发现，此时事务就设置为自动提交了，同样可以实现CUD操作时记录的保存。虽然这也是一种方式，但就编程而言，设置为自动提交方式为 false 再根据情况决定是否进行提交，这种方式更常用。因为我们可以根据业务情况来决定提交是否进行提交。

3.MyBatis一对一查询（多对一）

本次案例主要以最为简单的用户和账户的模型来分析 Mybatis 多表关系。用户为 User 表，账户为Account 表。一个用户（User）可以有多个账户（Account）。具体关系如下：

3.1 一对一查询

需求:

查询所有账户信息，关联查询下单用户信息。

注意：

因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户。

3.1.1 方式一

3.1.1.1定义账户信息的实体类

/** * * <p>Title: Account</p> * <p>Description: 账户的实体类</p> */
public class Account implements Serializable {
   
private Integer id;
private Integer uid;
private Double money;
    public Integer getId() {
   
    	return id;
    }
    public void setId(Integer id) {
   
    	this.id = id;
    }
    public Integer getUid() {
   
    	return uid;
    }
    public void setUid(Integer uid) {
   
    	this.uid = uid;
    }
    public Double getMoney() {
   
    	return money;
    }
    public void setMoney(Double money) {
   
    	this.money = money;
    }
    @Override
    public String toString() {
   
    	return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";
    }
}

3.1.1.2 编写Sql语句

实现查询账户信息时，也要查询账户所对应的用户信息。

SELECT account.*, user.username, user.address FROM account, user WHERE account.uid = user.id

3.1.1.3 定义AccountUser类

为了能够封装上面 SQL 语句的查询结果，定义 AccountCustomer 类中要包含账户信息同时还要包含用户信息，所以我们要在定义 AccountUser 类时可以继承 User 类。

/** * * <p>Title: AccountUser</p> * <p>Description: 它是 account 的子类</p> */
public class AccountUser extends Account implements Serializable {
   
    private String username;
    private String address;
    public String getUsername() {
   
    return username;
    }
    public void setUsername(String username) {
   
    this.username = username;
    }
    public String getAddress() {
   
    return address;
    }
    public void setAddress(String address) {
   
    this.address = address;
    }
    @Override
    public String toString() {
   
    return super.toString() + " AccountUser [username=" + username + ",
    address=" + address + "]";
    }
}

3.1.1.4 定义账户的持久层Dao接口

/** * * <p>Title: IAccountDao</p> * <p>Description: 账户的持久层接口</p> */
public interface IAccountDao {
   
    /** * 查询所有账户，同时获取账户的所属用户名称以及它的地址信息 * @return */
    List<AccountUser> findAll();
}

3.1.1.5 定义AccoutDao.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.bianyi.dao.IAccountDao">
    <!-- 配置查询所有操作-->
    <select id="findAll" resultType="accountuser">
    	select a.*,u.username,u.address from account a,user u where a.uid =u.id;
    </select>
</mapper>

注意：因为上面查询的结果中包含了账户信息同时还包含了用户信息，所以我们的返回值类型 returnType 的值设置为 AccountUser 类型，这样就可以接收账户信息和用户信息了。

3.1.1.6 创建AccountTest测试类

/** * * <p>Title: MybastisCRUDTest</p> * <p>Description: 一对多账户的操作</p> */
public class AccountTest {
   
    private InputStream in ;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IAccountDao accountDao;
    @Test
    public void testFindAll() {
   
        //6.执行操作
        List<AccountUser> accountusers = accountDao.findAll();
        for(AccountUser au : accountusers) {
   
        System.out.println(au);
        }
    }
   @Before//在测试方法执行之前执行
    public void init()throws Exception {
   
        //1.读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建构建者对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //3.创建 SqlSession 工厂对象
        factory = builder.build(in);
        //4.创建 SqlSession 对象
        session = factory.openSession();
        //5.创建 Dao 的代理对象
        accountDao = session.getMapper(IAccountDao.class);
    }
    @After//在测试方法执行完成之后执行
    public void destroy() throws Exception{
   
        session.commit();
        //7.释放资源
        session.close();
        in.close();
    }
}

3.1.1.7 小结

定义专门的pojo类作为输出类型,其中定义了sql查询结果集所有字段.此方法较为简单,企业中使用普遍。

3.1.2方式二

使用resultMap,定义专门的resultMap用于映射一对一查询结果。

通过面向对象的(has a)关系可以得知，我们可以在 Account 类中加入一个 User 类的对象来代表这个账户是哪个用户的。

3.1.2.1修改Account类

在 Account 类中加入 User 类的对象作为 Account 类的一个属性。

/** * * <p>Title: Account</p> * <p>Description: 账户的实体类</p> */
public class Account implements Serializable {
   
    private Integer id;
    private Integer uid;
    private Double money;
    private User user;
    public User getUser() {
   
    return user;
    }
    public void setUser(User user) {
   
    this.user = user;
    }
    public Integer getId() {
   
    return id;
    }
    public void setId(Integer id) {
   
    this.id = id;
    }
    public Integer getUid() {
   
    return uid;
    }
    public void setUid(Integer uid) {
   
    this.uid = uid;
    }
    public Double getMoney() {
   
    return money;
    }
    public void setMoney(Double money) {
   
    this.money = money;
    }
    @Override
    public String toString() {
   
    return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";
	}
}

3.1.2.2 修改AccountDao接口中的方法

public interface IAccountDao {
   
/** * 查询所有账户，同时获取账户的所属用户名称以及它的地址信息 * @return */
List<Account> findAll();
}

注意：第二种方式，将返回值改为了 Account 类型。因为 Account 类中包含了一个 User 类的对象，它可以封装账户所对应的用户信息。

3.1.2.3重新定义AccountDao.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.bianyi.dao.IAccountDao">
    <!-- 建立对应关系 -->
    <resultMap type="account" id="accountMap">
        <id column="aid" property="id"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
        <!-- 它是用于指定从表方的引用实体属性的 -->
        <association property="user" javaType="user">
            <id column="id" property="id"/>
            <result column="username" property="username"/>
            <result column="sex" property="sex"/>
            <result column="birthday" property="birthday"/>
            <result column="address" property="address"/>
    	</association>
    </resultMap>
    
    <select id="findAll" resultMap="accountMap">
    select u.*,a.id as aid,a.uid,a.money from account a,user u where a.uid =u.id;
    </select>
</mapper>

3.1.2.4 在AccountTest类中加入测试方法

@Test
public void testFindAll() {
   
    List<Account> accounts = accountDao.findAll();
    for(Account au : accounts) {
   
    System.out.println(au);
    System.out.println(au.getUser());
    }
}

3.2 一对多查询

需求：

查询所有用户信息及用户关联的账户信息。

分析：

用户信息和他的账户信息为一对多关系，并且查询过程中如果用户没有账户信息，此时也要将用户信息查询出来，我们想到了左外连接查询比较合适。

3.2.1 编写sql语句

SELECT
u.*, acc.id id,
acc.uid,
 acc.money
FROM
user u
LEFT JOIN account acc ON u.id = acc.uid

3.2.2 User类加入List<Account>

/** * * <p>Title: User</p> * <p>Description: 用户的实体类</p> */
public class User implements Serializable {
   
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
private List<Account> accounts;
public List<Account> getAccounts() {
   
return accounts;
}
public void setAccounts(List<Account> accounts) {
   
this.accounts = accounts;
}
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 Date getBirthday() {
   
return birthday;
}
public void setBirthday(Date birthday) {
   
this.birthday = birthday;
}
public String getSex() {
   
return sex;
}
public void setSex(String sex) {
   
this.sex = sex;
}
    public String getAddress() {
   
return address;
}
public void setAddress(String address) {
   
this.address = address;
}
@Override
public String toString() {
   
return "User [id=" + id + ", username=" + username + ", birthday=" + birthday
+ ", sex=" + sex + ", address="
+ address + "]";
}
}

3.2.3 用户持久层Dao接口中加入方法

/** * 查询所有用户，同时获取出每个用户下的所有账户信息 * @return */
List<User> findAll();

3.2.4 用户持久层Dao映射文件配置

<?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.bianyi.dao.IUserDao">
<resultMap type="user" id="userMap">
<id column="id" property="id"></id>
<result column="username" property="username"/>
<result column="address" property="address"/>
<result column="sex" property="sex"/>
<result column="birthday" property="birthday"/>
<!-- collection 是用于建立一对多中集合属性的对应关系 ofType 用于指定集合元素的数据类型 -->
<collection property="accounts" ofType="account">
<id column="aid" property="id"/>
<result column="uid" property="uid"/>
<result column="money" property="money"/>
    </collection>
</resultMap>
<!-- 配置查询所有操作 -->
<select id="findAll" resultMap="userMap">
select u.*,a.id as aid ,a.uid,a.money from user u left outer join account
a on u.id =a.uid
</select>
</mapper>

collection

部分定义了用户关联的账户信息。表示关联查询结果集

property=“accList”：关联查询的结果集存储在 User 对象的上哪个属性。

ofType=“account”：指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。

3.2.5 测试方法

/** * * <p>Title: MybastisCRUDTest</p> * <p>Description: 一对多的操作</p> */
public class UserTest {
   
private InputStream in ;
private SqlSessionFactory factory;
private SqlSession session;
private IUserDao userDao;
@Test
public void testFindAll() {
   
//6.执行操作
List<User> users = userDao.findAll();
for(User user : users) {
   
System.out.println("-------每个用户的内容---------");
System.out.println(user);
System.out.println(user.getAccounts());
}
}
@Before//在测试方法执行之前执行
public void init()throws Exception {
   
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.创建构建者对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//3.创建 SqlSession 工厂对象
factory = builder.build(in);
//4.创建 SqlSession 对象
session = factory.openSession();
//5.创建 Dao 的代理对象
userDao = session.getMapper(IUserDao.class);
}
@After//在测试方法执行完成之后执行
public void destroy() throws Exception{
   
session.commit();
//7.释放资源
session.close();
in.close();
}
}

4. 多对多查询

4.1 实现Role到User多对多

通过前面的学习，我们使用 Mybatis 实现一对多关系的维护。多对多关系其实我们看成是双向的一对多关系。

4.1.1 用户与角色的关系模型

用户与角色的多对多关系模型如下：

4.1.2 业务要求及实现SQL

需求：实现查询所有对象并且加载它所分配的用户信息。

分析：查询角色我们需要用到Role表，但角色分配的用户的信息我们并不能直接找到用户信息，而是要通过中间表(USER_ROLE 表)才能关联到用户信息。

下面是实现的 SQL 语句：

SELECT
 r.*,u.id uid,
 u.username username,
 u.birthday birthday,
 u.sex sex,
 u.address address
FROM
 ROLE r
INNER JOIN
 USER_ROLE ur
ON ( r.id = ur.rid)
INNER JOIN
 USER u
ON (ur.uid = u.id);

4.1.3 编写角色实体类

public class Role implements Serializable {
   
 private Integer roleId;
 private String roleName;
 private String roleDesc;
 //多对多的关系映射：一个角色可以赋予多个用户
 private List<User> users;
 public List<User> getUsers() {
   
 return users;
 }
 public void setUsers(List<User> users) {
   
 this.users = users;
 }
 public Integer getRoleId() {
   
 return roleId;
 }
 public void setRoleId(Integer roleId) {
   
 this.roleId = roleId;
 }
 public String getRoleName() {
   
 return roleName;
 }
 public void setRoleName(String roleName) {
   
 this.roleName = roleName;
 }
 public String getRoleDesc() {
   
 return roleDesc;
 }
 public void setRoleDesc(String roleDesc) {
   
 this.roleDesc = roleDesc;
 }
 @Override
 public String toString() {
   
 return "Role{" +
 "roleId=" + roleId +
 ", roleName='" + roleName + '\'' +
 ", roleDesc='" + roleDesc + '\'' +
 '}';
 }
}

4.1.4 编写Role持久层接口

public interface IRoleDao {
   
 /** * 查询所有角色 * @return */
 List<Role> findAll();
}

4.1.5 编写映射文件

<?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.bianyi.dao.IRoleDao">
 <!--定义 role 表的 ResultMap-->
 <resultMap id="roleMap" type="role">
 <id property="roleId" column="rid"></id>
 <result property="roleName" column="role_name"></result>
 <result property="roleDesc" column="role_desc"></result>
 <collection property="users" ofType="user">
 <id column="id" property="id"></id>
 <result column="username" property="username"></result>
 <result column="address" property="address"></result>
 <result column="sex" property="sex"></result>
 <result column="birthday" property="birthday"></result>
 </collection>
 </resultMap>
 <!--查询所有-->
 <select id="findAll" resultMap="roleMap">
 select u.*,r.id as rid,r.role_name,r.role_desc from role r
     left outer join user_role ur on r.id = ur.rid
 left outer join user u on u.id = ur.uid
 </select>
</mapper>

4.1.6 编写测试类

public class RoleTest {
 private InputStream in;
 private SqlSession sqlSession;
 private IRoleDao roleDao;
 @Before//用于在测试方法执行之前执行
 public void init()throws Exception{
 //1.读取配置文件，生成字节输入流
 in = Resources.getResourceAsStream("SqlMapConfig.xml");
 //2.获取 SqlSessionFactory
 SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
 //3.获取 SqlSession 对象
 sqlSession = factory.openSession(true);
 //4.获取 dao 的代理对象
 roleDao = sqlSession.getMapper(IRoleDao.class);
 }
 @After//用于在测试方法执行之后执行
 public void destroy()throws Exception{
 //提交事务
 // sqlSession.commit();
 //6.释放资源
 sqlSession.close();
 in.close();
 }
 /**
 * 测试查询所有
 */
 @Test
 public void testFindAll(){
 List<Role> roles = roleDao.findAll();
     for(Role role : roles){
 System.out.println("---每个角色的信息----");
 System.out.println(role);
 System.out.println(role.getUsers());
 }
 }
}

4.2 实现User到Role的多对多

4.2.1 User到Role的多对多

从 User 出发，我们也可以发现一个用户可以具有多个角色，这样用户到角色的关系也还是一对多关系。这样我们就可以认为 User 与 Role 的多对多关系，可以被拆解成两个一对多关系来实现。

MyBatis入门(三)