MyBatis(三)

2020-06-22

1. Mybatis 连接池与事务深入

1.1 Mybatis 的连接池技术

在 Mybatis 的 SqlMapConfig.xml 配置文件中，通过<dataSource type="pooled">来实现 Mybatis 中连接池的配置。

1.1.1 Mybatis 连接池的分类

在 Mybatis 中我们将它的数据源 dataSource 分为以下几类：

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 在初始化时，根据<dataSource>的 type 属性来创建相应类型的的数据源 DataSource。

1.1.3 Mybatis 中 DataSource 的存取

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

MyBatis 创建了 DataSource 实例后，会将其放到 Configuration 对象内的 Environment 对象中，供以后使用。

1.1.4 Mybatis 中连接的获取过程分析

当我们需要创建 SqlSession 对象并需要执行 SQL 语句时，这时候 MyBatis 才会去调用 dataSource 对象来创建java.sql.Connection对象。也就是说，java.sql.Connection对象的创建一直延迟到执行SQL语句的时候。当我们用完了就再立即将数据库连接归还到连接池中。

1.2 Mybatis 的事务控制

1.2.1 JDBC 中事务的回顾

在 JDBC 中我们可以将事务的提交改为自动方式，通过 setAutoCommit()方法就可以调整。

1.2.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();
}

控制台输出的结果：

Connection 的整个变化过程，通过分析我们能够发现之前的 CUD 操作过程中，我们都要手动进行事务的提交，原因是 setAutoCommit()方法，在执行时它的值被设置为 false 了，所以我们在 CUD 操作中，必须通过sqlSession.commit()方法来执行提交操作。

1.2.3 Mybatis 自动提交事务的设置

1 2	//4.创建 SqlSession 对象 session = factory.openSession(true);

所对应的 DefaultSqlSessionFactory 类的源代码：

2. Mybatis 的动态 SQL 语句

2.1 `<if>`标签

<!-- 根据条件查询 -->
<select id="findByUser" resultType="user" parameterType="user">
    select * 
    from user 
    where 1=1
    <if test="username!=null and username != '' ">
    	and username = #{username}
    </if>
    <if test="address != null">
    	and address like #{address}
    </if>
</select>

2.2 `<where>`标签

为了简化上面 where 1=1 的条件拼装，我们可以采用<where>标签来简化开发。

<select id="findUserByCondition" resultMap="userMap" parameterType="user">
    select *
    from user
    <where>
        <if test="userName != null">
            and username = #{userName}
        </if>
        <if test="userSex != null">
            and sex = #{userSex}
        </if>
    </where>
</select>

2.3 `<foreach>` 标签

2.3.1 需求

传入多个 id 查询用户信息，用下边两个 sql 实现：

1 2	SELECT * FROM USERS WHERE username LIKE '%张%' AND (id =10 OR id =89 OR id=16) SELECT * FROM USERS WHERE username LIKE '%张%' AND id IN (10,89,16)

这样我们在进行范围查询时，就要将一个集合中的值，作为参数动态添加进来。

2.3.2 在 QueryVo 中加入一个 List 集合用于封装参数

/**
 * @author wgy
 */
public class QueryVo {

    private User user;
    private List<Integer> ids;
	...
}

2.3.3 映射配置

<!-- 根据queryvo中的Id集合实现查询用户列表 -->
<select id="findUserInIds" resultMap="userMap" parameterType="queryvo">
    select *
    from user
    <where>
        <if test="ids != null and ids.size()>0">
            <foreach collection="ids" open="and id in (" close=")" separator="," item="uid">
                #{uid}
            </foreach>
        </if>
    </where>
</select>

SQL 语句：
select 字段 from user where id in (?)

<foreach>标签用于遍历集合，它的属性：
    collection:代表要遍历的集合元素，注意编写时不要写#{}
    open:代表语句的开始部分
    close:代表结束部分
    item:代表遍历集合的每个元素，生成的变量名
    sperator:代表分隔符

2.4 简化编写的 SQL 片段

Sql 中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的。

2.4.1 定义代码片段

<!-- 了解的内容：抽取重复的sql语句-->
<sql id="defaultUser">
    select *
    from user
</sql>

2.4.2 引用代码片段

<!--配置查询所有-->
<select id="findAll" resultMap="userMap">
    <include refid="defaultUser"></include>
</select>

3. Mybatis 多表查询之一对多

用户为User 表，账户为Account表。一个用户（User）可以有多个账户（Account）。

3.1 一对一查询( 多对一)

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

3.1.1 方式一

3.1.1.1 定义账户信息的实体类

public class Account implements Serializable {

    private Integer id;
    private Integer uid;
    private Double money;
    ...
}

3.1.1.2 编写 Sql 语句

select a.*, u.username, u.address
from account a,
	user u
where u.id = a.uid;

3.1.1.3 定义 AccountUser 类

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

/**
 * @author wgy
 */
public class AccountUser extends Account {

    private String username;
    private String address;
    ...
}

3.1.1.4 映射配置

<!--查询所有账户同时包含用户名和地址信息-->
<select id="findAllAccount" resultType="accountuser">
    select a.*, u.username, u.address
    from account a,
    user u
    where u.id = a.uid;
</select>

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

3.1.2 方式二

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

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

3.1.2.1 修改 Account 类

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

/**
 * 账户实体类
 *
 * @author wgy
 */
public class Account implements Serializable {

    private Integer id;
    private Integer uid;
    private Double money;

    //从表实体应该包含一个主表实体的对象引用
    private User user;
    ...
}

3.1.2.2 映射配置

<!-- 定义封装account和user的resultMap -->
<resultMap id="accountUserMap" type="account">
    <id property="id" column="aid"></id>
    <result property="uid" column="uid"></result>
    <result property="money" column="money"></result>
    <!-- 一对一的关系映射：配置封装user的内容-->
    <association property="user" column="uid" javaType="user">
        <id property="id" column="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>
    </association>
</resultMap>

<!-- 查询所有 -->
<select id="findAll" resultMap="accountUserMap">
    select u.*, a.id as aid, a.uid, a.money
    from account a,
    user u
    where u.id = a.uid;
</select>

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>`

/**
 * 用户实体类
 *
 * @author wgy
 */
public class User implements Serializable {

    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;
    //一对多关系映射：主表实体应该包含从表实体的集合引用
    private List<Account> accounts;
    ...
}

3.2.3 映射配置

<!-- 定义User的resultMap-->
<resultMap id="userAccountMap" type="user">
    <id property="id" column="id"></id>
    <result property="username" column="username"></result>
    <result property="address" column="address"></result>
    <result property="sex" column="sex"></result>
    <result property="birthday" column="birthday"></result>
    <!-- 配置user对象中accounts集合的映射 -->
    <collection property="accounts" ofType="account">
        <id column="aid" property="id"></id>
        <result column="uid" property="uid"></result>
        <result column="money" property="money"></result>
    </collection>
</resultMap>

<!--配置查询所有-->
<select id="findAll" resultMap="userAccountMap">
    select *
    from user u
    	left outer join account a on u.id = a.uid
</select>

collection
    部分定义了用户关联的账户信息。表示关联查询结果集
property="accounts" ：
    关联查询的结果集存储在 User 对象的上哪个属性。
ofType="account" ：
    指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。

4. Mybatis 多表查询之多对多

多对多关系其实是双向的一对多关系。一个用户可以有多个角色，一个角色可以赋予多个用户。

4.1 实现 Role 到 User 多对多

实现查询所有角色并且加载它所分配的用户信息。

4.1.1 编写 SQL 语句

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

4.1.2 编写角色实体类

/**
 * 角色实体类
 *
 * @author wgy
 */
public class Role implements Serializable {

    private Integer roleId;
    private String roleName;
    private String roleDesc;
    //多对多的关系映射：一个角色可以赋予多个用户
    private List<User> users;
    ...
}

4.1.3 映射配置

<!--定义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>

4.2 实现 User 到 Role 的多对多

4.2.1 编写 SQL 语句

select u.*, r.id as rid, r.role_name, r.role_desc
from user u
    left outer join user_role ur on u.id = ur.uid
    left outer join role r on r.id = ur.rid

4.2.2 编写用户实体类

/**
 * 用户实体类
 *
 * @author wgy
 */
public class User implements Serializable {

    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;
    //多对多的关系映射：一个用户可以具备多个角色
    private List<Role> roles;
    ...
}

4.2.3 映射配置

<!-- 定义User的resultMap-->
<resultMap id="userMap" type="user">
    <id property="id" column="id"></id>
    <result property="username" column="username"></result>
    <result property="address" column="address"></result>
    <result property="sex" column="sex"></result>
    <result property="birthday" column="birthday"></result>
    <!-- 配置角色集合的映射 -->
    <collection property="roles" ofType="role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
    </collection>
</resultMap>

<!--配置查询所有-->
<select id="findAll" resultMap="userMap">
    select u.*, r.id as rid, r.role_name, r.role_desc
    from user u
    	left outer join user_role ur on u.id = ur.uid
    	left outer join role r on r.id = ur.rid
</select>

5. JNDI数据源

JNDI：Java Naming and Directory Interface。是SUN公司推出的一套规范，属于JavaEE技术之一。目的是模仿windows系统中的注册表。在服务器中注册数据源

5.1 创建Maven的war工程并导入坐标

<groupId>com.wgy</groupId>
<artifactId>MyBatis10_JNDI</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.5</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.10</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.0</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

5.2 在webapp文件下创建META-INF目录

5.3 在META-INF目录中建立一个名为context.xml的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<Context>
    <!--
    <Resource
        name="jdbc/mybatis"                             数据源的名称
        type="javax.sql.DataSource"                     数据源类型
        auth="Container"                                数据源提供者
        maxActive="20"                                  最大活动数
        maxWait="10000"                                 最大等待时间
        maxIdle="5"                                     最大空闲数
        username="root"                                 用户名
        password="root"                                 密码
        driverClassName="com.mysql.jdbc.Driver"         驱动类
        url="jdbc:mysql://localhost:3306/mybatis"       连接url字符串
    />
     -->
    <Resource
        name="jdbc/mybatis"
        type="javax.sql.DataSource"
        auth="Container"
        maxActive="20"
        maxWait="10000"
        maxIdle="5"
        username="root"
        password="root"
        driverClassName="com.mysql.jdbc.Driver"
        url="jdbc:mysql://localhost:3306/mybatis"
    />
</Context>

5.4 修改SqlMapConfig.xml中的配置

<!--配置环境-->
<environments default="dev">
    <!-- 配置dev的环境-->
    <environment id="dev">
        <!-- 配置事务控制的方式 -->
        <transactionManager type="JDBC"/>
        <!-- 配置连接数据库的必备信息  type属性表示是否使用数据源（连接池）-->
        <dataSource type="JNDI">
            <property name="data_source" value="java:comp/env/jdbc/mybatis"/>
        </dataSource>
    </environment>
</environments>

java:comp/env/为固定写法，后面为context.xml中设置的数据源的名称jdbc/mybatis

-------------本文结束感谢您的阅读-------------

本文作者： Wgy
本文标题： MyBatis(三)
本文链接： https://wgy1993.gitee.io/archives/f1b11122.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 进行许可。转载请注明出处！