(五)Mybatis的复杂查询

最新推荐文章于 2024-10-08 10:09:16 发布

lyj_010

最新推荐文章于 2024-10-08 10:09:16 发布

阅读量816

点赞数 1

分类专栏： MyBatis框架学习文章标签： mybatis 数据库多表查询

本文链接：https://blog.csdn.net/lyj_010/article/details/105621530

版权

MyBatis框架学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1、动态 SQL

　　动态 SQL 是 MyBatis 的强大特性之一，它极大地方便了我们根据不同条件拼接 SQL 语句。

1.1 if

　　当我们需要根据传入的实体类参数，判断哪些属性不为空，并以此作为查询条件，那么此时就可以使用 if 标签：

接口方法定义：

	// 根据传入的查询条件（某些属性可能为空）查询表
    public List<User> findByCondition(User user);

映射文件配置：

	<select id="findByCondition" resultType="user">
        SELECT * FROM user where 1 = 1
        <if test="username != null and username != ''">
            AND username LIKE CONCAT('%',#{username},'%')
        </if>
        <if test="sex != null and sex != ''">
            AND sex = #{sex}
        </if>
    </select>

WHERE 1 =1 是防止所有条件都为空时，拼接 SQL 语句出错。
if 标签中 test 属性是必须的，表示判断的条件，且参数名称需与实体类属性名一致。

测试方法：

	@Test
    public void testFindByCondition() {
        User u = new User();
        u.setUsername("王");
        u.setSex("男");

        List<User> users = mapper.findByCondition(u);

        for(User user : users){
            System.out.println(user);
        }
    }

1.2 choose、when、otherwise

　　当我们只想从多个条件中选择一个使用，与 Java 中的 switch 语句类似，此时就可以使用这些标签：

映射文件配置：

	<select id="findByChoose" resultType="user">
        SELECT * FROM user where 1 = 1
        <choose>
            <when test="username != null and username != ''">
                AND username LIKE CONCAT('%',#{username},'%')
            </when>
            <when test="sex != null and sex != ''">
                AND sex = #{sex}
            </when>
            <otherwise>
                AND id = 50
            </otherwise>
        </choose>
    </select>

1.3 where

　　where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句，此时我们不用在 SQL 语句中加入类似 where 1 = 1 的语句。

映射文件配置：

	<select id="findByConditionWhere" resultType="user">
        SELECT * FROM user
        <where>
            <if test="username != null and username != ''">
                AND username LIKE CONCAT('%',#{username},'%')
            </if>
            <if test="sex != null and sex != ''">
                AND sex = #{sex}
            </if>
        </where>
    </select>

1.4 foreach

　　动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）。

查询封装类：

public class QueryListVo implements Serializable {
    
    private List<Integer> ids;

    public List<Integer> getIds() {
        return ids;
    }

    public void setIds(List<Integer> ids) {
        this.ids = ids;
    }
}

接口方法定义：

	public List<User> findByIdList(QueryListVo vo);

映射文件配置：

	<select id="findByIdList" resultType="com.lyj.domain.User">
        SELECT * FROM user
        <where>
            <if test="ids != null and ids.size > 0">
                <foreach collection="ids" open="AND id IN (" close=")" item="id" separator=",">
                    #{id}
                </foreach>
            </if>
        </where>
    </select>

collection ：代表要遍历的集合或数组，这个属性是必须的。如果是遍历数组，那么该值只能为 array；
open ：代表语句的开始部份；
close ：代表语句的结束部份；
item ：代表遍历集合时的每个元素，相当于一个临时变量；
separator ：代表拼接每个元素之间的分隔符。

注意，“#{id}” 中的参数名称需与 item=“id” 的保持一致。

测试方法：

	@Test
    public void testFindByCondition() {
        User u = new User();
        u.setUsername("王");
        u.setSex("男");

        List<User> users = mapper.findByCondition(u);

        for(User user : users){
            System.out.println(user);
        }
    }

运行结果：

1.5 sql

　　可以把常用的语句定义为 SQL 片段，以供复用，减少工作量。

定义代码片段：

	<sql id="selectAll">
        SELECT * FROM user
    </sql>

引用代码片段：

	<select id="findMyAll" resultMap="userMap">
        <include refid="selectAll"/>
    </select>

2、多表查询

　　表之间的关系有以下几种：

一对多：用户和订单就是一对多的关系，一个用户可以对应多个订单；
多对一：订单与用户就是多对一的关系，多个订单对应的是同一个用户；
一对一：人和身份证就是一对一的关系，一个人只有一个身份证号，一个身份证号也只能属于一个人；
多对多：学生和老师就是多对多的关系，一个老师可以教多个学生，一个学生也可以上多个老师的课。

2.1 一对多（多对一）的查询

　　我们以用户表和账户表的查询作为例子，一个用户可以有多个账户，即多个账户可以对应的是同一个用户。

2.1.1 搭建环境

数据库表创建：

# 创建用户表
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(32) NOT NULL COMMENT '用户名称',
  `birthday` datetime default NULL COMMENT '生日',
  `sex` char(1) default NULL COMMENT '性别',
  `address` varchar(256) default NULL COMMENT '地址',
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

# 导入用户数据
insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (41,'老王','2018-02-27 17:47:08','男','北京'),(42,'小二王','2018-03-02 15:09:37','女','北京金燕龙'),(43,'小二王','2018-03-04 11:34:34','女','北京金燕龙'),(45,'传智播客','2018-03-04 12:04:06','男','北京金燕龙'),(46,'老王','2018-03-07 17:37:26','男','北京'),(47,'小马宝莉','2018-03-08 11:44:00','女','北京修正');

# 创建账户表，外键为uid，关联用户表的id
DROP TABLE IF EXISTS `account`;
CREATE TABLE `account` (
  `id` int(11) NOT NULL COMMENT '编号',
  `uid` int(11) default NULL COMMENT '用户编号',
  `money` double default NULL COMMENT '金额',
  PRIMARY KEY  (`id`),
  KEY `FK_Reference_8` (`uid`),
  CONSTRAINT `FK_Reference_8` FOREIGN KEY (`uid`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

# 导入账户数据
insert  into `account`(`id`,`uid`,`money`) values (1,46,1000),(2,45,1000),(3,46,2000);

创建的用户表和账户表：
工程搭建：
　　在 IDEA 创建一个 Maven 项目，并导入 MyBatis 的相关依赖，配置好 MyBatis 的主配置文件如下：

<?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>
    <properties>
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis_learn?useUnicode=true&amp;characterEncoding=utf8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </properties>
	
	<!-- 为实体类起别名 -->
    <typeAliases>
        <package name="com.lyj.domain"/>
    </typeAliases>

    <!--配置环境-->
    <environments default="development">
        <environment id="development">
            <!-- 配置事务类型 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源（连接池） -->
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 指定映射文件 -->
    <mappers>
        <mapper resource="UserMapper.xml" />
        <mapper resource="AccountMapper.xml" />
    </mappers>
</configuration>

2.1.2 实体类

Account：账户实体类，从表实体应该包含一个主表实体的对象引用。

public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
    // 账户对应的用户信息
    private 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;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + money + '\n' +
                ", user=" + user +
                '}';
    }
}

User：用户实体类，主表实体应该包含从表实体的集合引用。

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 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;
    }

    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' + '\n' +
                ", accounts=" + accounts +
                '}';
    }
}

2.1.3 映射接口

AccountMapper：账户映射接口

public interface AccountMapper {

    // 查询账户表和每个账户关联的用户信息
    public List<Account> findAll();
}

UserMapper ：用户映射接口

public interface UserMapper {

    // 查询User表和每个用户关联的账户信息
    public List<User> findAll();
}

2.1.4 映射文件配置

AccountMapper.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.lyj.mapper.AccountMapper">

    <resultMap id="accountWithUserMap" type="account">
        <id property="id" column="aid" />
        <result property="uid" column="uid"/>
        <result property="money" column="money"/>
        <!-- 关联 User 对象 -->
        <association property="user" javaType="user">
            <id property="id" column="id"/>
            <result property="username" column="username"/>
            <result property="sex" column="sex"/>
            <result property="birthday" column="birthday"/>
            <result property="address" column="address"/>
        </association>
    </resultMap>

    <!-- 配置查询所有账户，带有用户信息 -->
    <select id="findAll" resultMap="accountWithUserMap">
        SELECT a.id AS aid, a.uid, a.money, U.* from account a, user u WHERE a.uid = u.id
    </select>

</mapper>

association 标签：用于一对一的实体类映射；
property ：表示要关联的实体类属性名称；
column ：表示要关联的表列名（如表列名起别名时，需用别名）；
javaType ：表示待关联的实体类。

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.lyj.mapper.UserMapper">

    <resultMap id="userWithAccountsMap" type="user">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="sex" column="sex"/>
        <result property="birthday" column="birthday"/>
        <result property="address" column="address"/>
        <!-- 配置user对象中accounts集合的映射 -->
        <collection property="accounts" ofType="account">
            <id property="id" column="aid"/>
            <result property="uid" column="uid"/>
            <result property="money" column="money"/>
        </collection>
    </resultMap>
    
    <!-- 配置查询所有用户，并且带有账户信息 -->
    <select id="findAll" resultMap="userWithAccountsMap">
        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 标签：用于一对多的实体类映射；
ofType ：表示集合中的实体类的全限定类名。

2.1.5 测试查询用户表

测试代码：

public class MyTest {
    private InputStream is;
    private SqlSession sqlSession;
    private UserMapper mapper;

    /**
     * 测试之前执行，用于初始化
     */
    @Before
    public void init() throws Exception {
        // 1. 读取配置文件
        is = Resources.getResourceAsStream("mybatis-config.xml");
        // 2. 创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(is);
        // 3. 获取SqlSession对象
        sqlSession = factory.openSession(true);
        // 4. 使用SqlSession创建Mapper的代理对象
        mapper = sqlSession.getMapper(UserMapper.class);
    }

    /**
     * 测试结束执行，用于提交事务和释放资源
     */
    @After
    public void destroy() throws Exception {
        // 提交事务，提交后数据库才能更新，否则会回滚
        sqlSession.commit();
        // 释放资源
        sqlSession.close();
        is.close();
    }

    /**
     * 测试查询全部用户信息
     */
    @Test
    public void testFindAll() {
        List<User> users = mapper.findAll();
        for(User user : users){
            System.out.println(user);
        }
    }
}

输出结果
sql 执行结果：

可以发现，MyBatis 会将一对多（用户和账户）查询出来的多条记录信息放入同一个集合中，即会合并查询到的相同 id （主键）的用户信息。

2.1.6 测试查询账户表

测试代码：

public class MyAccountTest{
    ...
    
   @Test
    public void testFindAll() {
        List<Account> accounts = mapper.findAll();
        for(Account account : accounts){
            System.out.println(account);
        }
    }
}

输出结果
sql 执行结果：

2.2 多对多的查询

　　多对多关系可以看成是双向的一对多关系，以用户和角色为例子，一个用户可以有多个角色，一个角色也可以赋予多个用户。

2.2.1 环境搭建

创建数据库表，由于是多对多关系，所以还需要借助中间表来存储用户表和角色表之间的对应关系。

# 创建角色表
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
  `id` int(11) NOT NULL COMMENT '编号',
  `role_name` varchar(30) default NULL COMMENT '角色名称',
  `role_desc` varchar(60) default NULL COMMENT '角色描述',
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

# 添加角色数据
insert  into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values (1,'院长','管理整个学院'),(2,'总裁','管理整个公司'),(3,'校长','管理整个学校');

# 创建中间表,uid 和 rid是复合主键，同时也是外键
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role` (
  `uid` int(11) NOT NULL COMMENT '用户编号',
  `rid` int(11) NOT NULL COMMENT '角色编号',
  PRIMARY KEY  (`uid`,`rid`),
  KEY `FK_Reference_10` (`rid`),
  CONSTRAINT `FK_Reference_10` FOREIGN KEY (`rid`) REFERENCES `role` (`id`),
  CONSTRAINT `FK_Reference_9` FOREIGN KEY (`uid`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

# 添加用户角色数据
insert  into `user_role`(`uid`,`rid`) values (41,1),(45,1),(41,2);

MyBatis 主配置文件中加入 RoleMapper.xml 映射文件的引用：

	<mappers>
        ...
        <mapper resource="RoleMapper.xml" />
    </mappers>

2.2.2 创建实体类

MyUser：

public class MyUser implements Serializable {
    ...
    private List<Role> roles;

    ...

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    ...
}

Role：

public class Role implements Serializable {
    private Integer roleId;
    private String roleName;
    private String roleDesc;
    private List<MyUser> 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;
    }

    public List<MyUser> getUsers() {
        return users;
    }

    public void setUsers(List<MyUser> users) {
        this.users = users;
    }

    @Override
    public String toString() {
        return "Role{" +
                "roleId=" + roleId +
                ", roleName='" + roleName + '\'' +
                ", roleDesc='" + roleDesc + '\'' +
                ", users=" + users +
                '}';
    }
}

2.2.3 映射接口方法

UserMapper：

public interface UserMapper {

	...

    // 查询user表和用户关联的角色信息
    public List<MyUser> findAllWithRoles();
}

RoleMapper:

public interface RoleMapper {
    // 查询role表全部信息和关联的用户信息
    public List<Role> findAllWithUsers();
}

2.2.4 映射文件

UserMapper.xml

	<resultMap id="userWithRolesMap" type="myuser">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="sex" column="sex"/>
        <result property="birthday" column="birthday"/>
        <result property="address" column="address"/>
        <!-- 配置user对象中roles集合的映射 -->
        <collection property="roles" ofType="role">
            <id property="roleId" column="rid"/>
            <result property="roleName" column="role_name"/>
            <result property="roleDesc" column="role_desc"/>
        </collection>
    </resultMap>
    
    <!-- 查询所有用户，并且带有角色信息 -->
    <select id="findAllWithRoles" resultMap="userWithRolesMap">
        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 ur.rid = r.id
    </select>

RoleMapper.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.lyj.mapper.RoleMapper">
    <resultMap id="roleWithUsersMap" type="role">
        <id property="roleId" column="rid"/>
        <result property="roleName" column="role_name"/>
        <result property="roleDesc" column="role_desc"/>
        <!-- 配置role对象中users集合的映射 -->
        <collection property="users" ofType="myuser">
            <id property="id" column="id"/>
            <result property="username" column="username"/>
            <result property="sex" column="sex"/>
            <result property="birthday" column="birthday"/>
            <result property="address" column="address"/>
        </collection>
    </resultMap>

    <!-- 查询所有角色，并且带有用户信息 -->
    <select id="findAllWithUsers" resultMap="roleWithUsersMap">
        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 ur.uid = u.id
    </select>
       
</mapper>

2.2.5 测试查询用户表

测试方法：

	@Test
    public void testFindAllWithRoles() {
        List<MyUser> users = mapper.findAllWithRoles();
        for(MyUser user : users){
            System.out.println(user);
        }
    }

运行结果：
sql 执行结果：

2.2.6 测试查询角色表

测试方法：

	@Test
    public void testFindAll() {
        List<Role> roles = mapper.findAllWithUsers();
        for(Role role : roles ){
            System.out.println(role);
        }
    }

运行结果：
sql 执行结果：

3、延迟加载

延迟加载：延迟加载就是在需要使用到数据时才进行加载，不需要用到数据时就不加载数据，也称懒加载，适用于一对多或多对多的表关系中。
立即加载：立即加载就是不管是否需要数据，只要一进行查询，就会把相关联的数据一并查询出来，适用于多对一或一对一的表关系中。

　　MyBatis 主配置文件中的 <settings> 标签，是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为，我们可以在其中控制延迟加载的。

MyBatis 主配置文件中开启延迟加载：

	<!-- 开启延迟加载 -->
	<settings>
	    <setting name="lazyLoadingEnabled" value="true"/>
	    <setting name="aggressiveLazyLoading" value="false"/>
	</settings>

lazyLoadingEnabled ：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。默认值为 false。
aggressiveLazyLoading ：开启时，任一方法的调用都会加载该对象的所有延迟加载属性。否则，每个延迟加载属性会按需加载。默认值为 false （在 3.4.1 及之前的版本中默认为 true）。

　　注意：在 MyBatis 中进行主配置时，必须严格按照官方配置文档的结构来进行（即 settings 必须写在 properties 下）：
在这里插入图片描述

3.1 一对一实现延迟加载

　　在查询账户信息时使用延迟加载，只有当我们使用到账户关联的用户信息时，才执行关联查询。

在 UserMapper 接口增加一个根据 id 查询 user 表的方法：

public interface UserMapper {
	...
    public User findUserById(Integer uid);
}

在映射文件 UserMapper.xml 增加对应配置：

<mapper namespace="com.lyj.mapper.UserMapper">
	...
    <select id="findUserById" parameterType="Integer" resultType="user">
        select * FROM user WHERE id = #{uid}
    </select>
</mapper>

修改 AccountMapper.xml 的关联查询映射配置：

<mapper namespace="com.lyj.mapper.AccountMapper">
    <resultMap id="accountWithUserMap" type="account">
        <id property="id" column="aid" />
        <result property="uid" column="uid"/>
        <result property="money" column="money"/>
        <!-- 关联 User 对象 -->
        <association property="user" javaType="user" column="uid" select="com.lyj.mapper.UserMapper.findUserById"/>
    </resultMap>

    <!-- 配置查询所有账户，延迟加载用户信息 -->
    <select id="findAll" resultMap="accountWithUserMap">
        SELECT * FROM account
    </select>

</mapper>

<association> 标签的 column 属性：指定传递给要调用的映射语句的表列参数。
<association> 标签的 select 属性：表示我们要调用的映射语句的 ID。
它会从 column 属性指定的列中检索数据，并作为参数传递给目标 select 语句。

3.1.1 测试未使用关联用户信息：

测试方法：

	@Test
    public void testFindAll() {
        List<Account> accounts = mapper.findAll();
    }

测试结果：只执行了一条 SQL 语句

3.1.2 测试使用关联用户信息：

测试方法：

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

测试结果：只在使用到 account 对应的 user 时，才执行对应的 sql 语句。

3.2 一对多实现延迟加载

　　在查询用户信息时使用延迟加载，只有当我们使用到用户关联的帐户信息时，才执行关联查询。

在 AccountMapper 接口增加一个根据 id 查询 account 表的方法：

public interface AccountMapper {
	...
    // 根据uid查询账户信息
    public List<Account> findAccountsByUid(Integer uid);
}

在映射文件 AccountMapper .xml 增加对应配置：

	<select id="findAccountsByUid" parameterType="Integer" resultType="account">
        SELECT * FROM account where uid = #{uid}
    </select>

修改 UserMapper.xml 的关联查询映射配置：

	<resultMap id="userWithAccountsMap" type="user">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="sex" column="sex"/>
        <result property="birthday" column="birthday"/>
        <result property="address" column="address"/>
        <!-- 配置user对象关联的accounts -->
        <collection property="accounts" column="id" select="com.lyj.mapper.AccountMapper.findAccountsByUid"/>
    </resultMap>

    <!-- 配置查询所有用户，并且带有账户信息 -->
    <select id="findAll" resultMap="userWithAccountsMap">
        SELECT * from user
    </select>

3.2.1 测试未使用关联账户信息：

测试方法：

	@Test
    public void testFindAll() {
        List<User> users = mapper.findAll();
    }

测试结果：只执行了一条 SQL 语句

3.2.2 测试使用关联账户信息：

测试方法：

	@Test
    public void testFindAll() {
        List<User> users = mapper.findAll();
        for(User user : users){
            System.out.println(user);
            System.out.println(user.getAccounts());
        }
    }

测试结果：只在使用到 user 对应的 account 时，才执行对应的 sql 语句。

4、Mybatis 中的缓存

什么是缓存？缓存就是存在于内存中的临时数据。
为什么要使用缓存？为了减少和数据库交互的次数，提高运行效率。

适用于缓存的数据：经常查询并且不经常改变的数据，数据的正确性要求不高的数据。
不适用于缓存的数据：经常改变的数据，数据的正确性影响较大的数据。

4.1 Mybatis 的一级缓存

　　一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就会存在。当调用 SqlSession 的修改、添加、删除、commit()、close()、clearCache() 等方法时，就会清空一级缓存。

例如，当我们第一次查询 id 为 41 的用户时，Mybatis 发现缓存中没有 id 为 41 的用户信息，此时从数据库查询用户信息；
当我们第二次查询 id 为 41 的用户时，Mybatis 发现缓存中已经有 id 为 41 的用户信息，此时直接从缓存中取出该用户信息；
当我们清空 SqlSession 的缓存后，此时再查询 id 为 41 的用户，Mybatis 发现缓存已经被清空，则又需要去数据库查询。

注意：

Mybatis 默认就是使用一次缓存的，不需要配置。
一级缓存使用的是 Map 结构来缓存的，存放的是对象。

4.1.1 测试未清空的一级缓存

测试方法：

	@Test
    public void testFirstLevelCache() {
        User user1 = mapper.findUserById(41);
        User user2 = mapper.findUserById(41);
        System.out.println(user1);
        System.out.println(user2);
        System.out.println(user1 == user2);
    }

测试结果：

4.1.2 测试清空的一级缓存

测试方法：

	@Test
    public void testFirstLevelCache2() {
        User user1 = mapper.findUserById(41);
        sqlSession.clearCache();
        User user2 = mapper.findUserById(41);
        System.out.println(user1);
        System.out.println(user2);
        System.out.println(user1 == user2);
    }

测试结果：

4.2 Mybatis 的二级缓存

　　二级缓存是 Mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 SQL 语句，多个SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的。可以看到，二级缓存是针对映射器配置文件中的 SQL 语句进行缓存的。

当我们使用二级缓存的时候，所缓存的类一定要实现 java.io.Serializable 接口，这样才可以使用序列化的方式来保存对象。
由于是序列化保存对象，所以二级缓存中存放的是数据，而不是整个对象。

4.2.1 二级缓存配置

MyBatis 主配置文件：

	<settings>
	    <!-- 开启二级缓存 -->
	    <setting name="cacheEnabled" value="true"/>
	</settings>

cacheEnabled ：全局性地开启或关闭所有映射器配置文件中已配置的任何缓存，默认值为 true。

在映射文件中配置：

<mapper namespace="com.lyj.mapper.UserMapper">
   	...
   	<!-- 使用缓存 -->
    <cache />
</mapper>

在映射文件中的操作上配置：

	<select id="findUserById" parameterType="Integer" resultType="user" useCache="true">
        select * FROM user WHERE id = #{uid}
    </select>

参考链接：

lyj_010

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录