深入理解Mybatis框架

Mybatis框架

1.mybatis环境搭建

	第一步：创建maven工程并导入坐标
	第二步：创建实体类和dao的接口
	第三步：创建mybatis的主配置文件
						SqlMapConfig.xml
	第四步：创建映射配置文件
						IUserDao.xml

1.1 环境搭建的注意事项：
①创建IUserDao.xml和IUserDao.java时，名称是为了与之前的一致。在mybatis中把持久层的操作接口名称和映射文件也叫Mapper。所以：IUserDao和IUserMapper是一样的。
②在idea中创建目录时，它和包是不一样的。包在创建时：com.ithema.dao是三级目录。目录在创建时：com.ithema.dao是一级目录。
③mybatis的映射配置文件位置必须和dao接口的包结构相同。
④映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名
⑤映射配置文件的操作配置（select），id属性的取值必须是dao接口的方法名。
当我们遵从了第三，四，五点之后，在开发中就无须再写dao的实现类。

1.2 mybatis的入门案例

第一步：读取配置文件
第二步：创建SqlSessionFactory工厂
第三步：创建SqlSession
第四步：创建Dao接口的代理对象
第五步：执行dao中的方法
第六步：释放资源

注意事项：
不要忘记在映射配置中告知mybatis要封装到哪个实体类中。
配置方式：指定实体类的全限定类名

1.3 mybatis基于注解的入门案例：
把IUserDao.xml删除，在dao接口的方法上使用@Select注解，并且指定SQL语句，同时需要在SqlMapConfig.xml中的mapper配置时，使用class属性指定dao接口的全限定类名。

1.4 主方法

1.读取配置文件

读取配置文件的方式：
①使用类加载器，它只能读取类路径的配置文件。
②使用ServletContext对象的getRealPath()。

InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");

2.创建SqlSessionFactory工厂
mybatis使用了构建者模式，构建者模式：把对象的创建细节隐藏，使用者直接调用方法即可拿到对象。

SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(in);

3.使用工厂生产SqlSession对象
生产SqlSession使用工厂模式，优势：解耦（降低类之间的依赖关系）。

SqlSession session = factory.openSession();

4.使用SqlSession创建Dao接口的代理对象
创建Dao接口实现类使用了代理模式，优势：不修改源码的基础上对已有方法增强。

IUserDao userDao = session.getMapper(IUserDao.class);

5.使用代理对象执行方法

List<User> users = userDao.findAll();
for(User user : users){
    System.out.println(user);
}

6.释放资源

session.close();
in.close();

1.5 整体结构图

1.6 第一个mybatis工程（xml配置）

1.创建maven工程，并导入相关坐标
文件目录：

pox.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>mybatisExercise</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
    </dependencies>

</project>

2.创建User实体类

package com.ithema.domin;

import java.io.Serializable;
import java.util.Date;

/**
 * @author busihang
 * @date 2020/5/15 - 21:39
 **/
public class User implements Serializable{
        private Integer id;
        private String username;
        private Date birthday;
        private String sex;
        private String address;

        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.创建IUserDao接口

package com.ithema.dao;

import com.ithema.domin.User;

import java.util.List;

/**
 * @author busihang
 * @date 2020/5/15 - 21:41
 * 用户的持久层接口
 **/
public interface IUserDao {

    /**
     * 查询所有操作
     * @return
     */
    List<User> findAll();
}

4.resources下创建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">
<!--mybatis的主配置文件-->
<configuration>
    <!-- 配置环境   -->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源 也叫连接池-->
            <dataSource type="POOLED">
            <!--配置连接数据库的4个基本信息-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/eesy_mybatis?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>

<!--指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件-->
    <mappers>
        <mapper resource="com/ithema/dao/IUserDao.xml"/>
    </mappers>

</configuration>

5.在resources下新建对应的目录路径创建持久层接口的映射文件IUserDao.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.ithema.dao.IUserDao">
    <!--配置查询所有-->
    <select id="findAll" resultType="com.ithema.domin.User">
        select * from user
    </select>
</mapper>

6.在test目录下新建对应的测试类

package com.ithema.test;

import com.ithema.dao.IUserDao;
import com.ithema.domin.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/**
 * @author busihang
 * @date 2020/5/27 - 19:55
 **/
public class MybatisTest {
    /**
     * 入门案例
     * @param args
     */
    public static void main(String[] args) throws Exception {
        //1.读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        SqlSession session = factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        IUserDao userDao = session.getMapper(IUserDao.class);
        //5.使用代理对象执行方法
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println(user);
        }
        //6.释放资源
        session.close();
        in.close();
    }
}

7. resources路径下放入log4j.properties配置文件

**# Set root category priority to INFO and its only appender to CONSOLE.**
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

**# Set the enterprise logger category to FATAL and its only appender to CONSOLE.**
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

**# CONSOLE is set to be a ConsoleAppender using a PatternLayout.**
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

**# LOGFILE is set to be a File appender using a PatternLayout.**
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

8. 运行测试类即可

1.7 mybatis注解使用

1.移除持久层接口xml映射文件（IUserDao.xml）

2.修改IUserDao接口

package com.ithema.dao;

import com.ithema.domin.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * @author busihang
 * @date 2020/5/15 - 21:41
 * 用户的持久层接口
 **/
public interface IUserDao {

    /**
     * 查询所有操作
     * @return
     */
    @Select("select * from user")
    List<User> findAll();
}

3.修改SqlMapConfig.xml文件，基于注解使用的是class属性，并且类名之间使用.隔开。

<!--指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件
       如果是使用注解来配置的话，此处应该使用class属性指定被注解的Dao全限定类名-->
    <mappers>
        <mapper class="com.ithema.dao.IUserDao"/>
    </mappers>

二. mybatis CRUD

2.1 parameterType(输入类型)

2.1.1 传递pojo对象

	mybatis使用ognl表达式解析对象字段的值，#{}或者${}括号中的值为pojo属性名称。

OGNL表达式：

	Object Graphic   Navigation Language
	 对象     图        导航       语言

它是通过对象的取值方法来获取数据。在写法上把get给省略了。

比如：我们获取用户的名称

• 类中的写法：user.getUsername();

• OGNL表达式写法: user.username

• mybatis中为什么直接写username，而不是user. 呢？
  因为在parameterType中已经提供了属性所属的类，所以此时不需要写对象名。

2.2 properties标签以及url标签

• 配置properties：

     可以在标签内部配置连接数据库的信息，也可以通过属性引用外部配置文件信息
  

• resource 属性：properties文件必须放在类路径下，并且进行手动的编译。

     **用于指定配置文件的位置，是按照类路径的写法来写，并且必须存放于类路径下**
  

• url属性：要求按照url的写法来写地址

    URL:Uniform Resource Locator 统一资源定位符。它是可以唯一标识一个资源的位置，
    它的写法：
    http://localhost:8080/mybatisserver/demo1Servlet
    协议      主机     端口    URI
    URI: Uniform Resource Identifier 统一资源标识符，它是在应用中可以唯一定位一个资源的
  

方式一：


方式二：

2.3 typeAliases标签以及package标签

应用于主配置文件中，SqlMapConfig.xml中。

• typeAliases：

  使用typeAliases配置别名，它只能配置domain中类的别名

• typeAlias：

  typeAlias用于配置别名，type属性指定的是实体类全限定类名，alias属性指定别名，当指定了别名就再区分大小写

• package：

  用于指定要配置别名的包，当指定之后，该包下的实体类都会注册别名，并且类名就是别名，不再区分大小写
  
  

2.4 基于代理Dao实现CRUD操作

2.4.1 根据Id查询

①在持久层接口（IUserDao）中添加findById()方法。

/**
 1. 根据id查询用户信息
 2. @param userId
 3. @return
 */
User findById(Integer userId);

②在用户映射配置文件中配置

<!--    查询用户信息-->
    <select id="findById" parameterType="Integer" resultMap="userMap">
        select * from user where id = #{id};
    </select>

③测试类中测试

/**
 * 测试查询操作
 */
@Test
public void testFindOne(){
    User user = userDao.findById(50);
    System.out.println("user = " + user);
}

2.4.2 更新用户

①在持久层接口（IUserDao）中添加updateUser()方法。

/**
 * 更新用户
 * @param user
 */
void updateUser(User user);

②在用户映射配置文件中配置

<!--    更新用户-->
    <update id="updateUser" parameterType="com.ithema.domain.User">
        update user set username=#{userName},address=#{userAddress},sex=#{userSex},birthday=#{userBirthday} where id=#{userId};
    </update>

③测试类中测试

/**
 * 测试更新操作
 */
@Test
public void testUpdate(){
    User user = new User();
    user.setUserId(50);
    user.setUserName("七宝琉璃塔");
    user.setUserAddress("河南");
    user.setUserSex("女");
    user.getUserBirthday(new Date());
    userDao.updateUser(user);
}

2.4.3 插入用户

①在持久层接口（IUserDao）中添加saveUser()方法。

/**
 * 保存用户
 * @param user
 */
void saveUser(User user);

②在用户映射配置文件中配置

<!--    保存用户-->
    <insert id="saveUser" parameterType="com.ithema.domain.User">
        <!-- 配置插入操作后，获取插入数据的id-->
        <selectKey keyProperty="userId" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        </selectKey>
        insert into user(username,address,sex,birthday)values(#{userName},#{userAddress},#{userSex},#{userBirthday});
    </insert>

③测试类中测试

/**
 * 测试保存操作
 */
@Test
public void testSave(){
    User user = new User();
    user.setUserName("龙弟弟");
    user.setUserAddress("河南");
    user.setUserSex("男");
    user.getUserBirthday(new Date());
    System.out.println("保存操作之前： " + user);
    userDao.saveUser(user);
    System.out.println("保存操作之后：" + user);
}

2.4.4 扩展：新增用户id的返回值

新增用户后，同时还要返回当前新增用户的id值，因为id是由数据库自增长来实现的，所以就相当于要获取新增后将自动增长auto_increment的值返回。

<!--    保存用户-->
    <insert id="saveUser" parameterType="com.ithema.domain.User">
        <!-- 配置插入操作后，获取插入数据的id-->
        <selectKey keyProperty="userId" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        </selectKey>
        insert into user(username,address,sex,birthday)values(#{userName},#{userAddress},#{userSex},#{userBirthday});
    </insert>

2.4.5 删除用户

①在持久层接口（IUserDao）中添加deleteUser()方法。

/**
 * 删除用户
 * @param userId
 */
void deleteUser(Integer userId);

②在用户映射配置文件中配置

<!--    删除用户-->
    <delete id="deleteUser" parameterType="Integer">
        delete from user where id=#{id};
    </delete>

③测试类中测试

/**
 * 测试删除操作
 */
@Test
public void testDelete(){
    userDao.deleteUser(50);
}

2.4.6 用户模糊查询

①在持久层接口（IUserDao）中添加findByName()方法。

/**
 * 根据名称模糊查询用户信息
 * @param username
 * @return
 */
List<User> findByName(String username);

②在用户映射配置文件中配置

<!--    根据名称模糊查询-->
    <select id="findByName" parameterType="String" resultMap="userMap">
         select  * from user where username like #{name};
--         select * from user where username like '%${value}%';
    </select>

③测试类中测试

/**
 * 测试查询操作
 */
@Test
public void testFindByName(){
    List<User> users = userDao.findByName("%王%");
    //List<User> users = userDao.findByName("王");
    for(User user : users){
        System.out.println("user = " + user);
    }
}

2.4.7 #{ } 和 ${ }的区别

#{}表示一个占位符号 :

通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。

${}表示拼接sql串 :

通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换， $可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，\ast \ast${}括号中只能是value。**

2.4.8 根据QueryVo的条件查询用户

①在持久层接口（IUserDao）中添加findUserByVo()方法。

/**
 * 根据queryVo中的条件查询用户
 * @param vo
 * @return
 */
List<User> findUserByVo(QueryVo vo);

②在domain下创建QueryVo类

package com.ithema.domain;

/**
 * @author busihang
 * @date 2020/5/30 - 22:26
 **/
public class QueryVo {

    private User user;

    public User getUser() {
        return user;
    }

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

③配置用户映射文件

<!--    根据QueryVo的条件查询用户-->
    <select id="findUserByVo" parameterType="com.ithema.domain.QueryVo" resultMap="userMap">
            <!-- 此处的#{user.username}由于user为一个对象不能直接作为参数，因此需要使用其属性作为参数传递 -->
         select  * from user where username like #{user.username};
    </select>

④测试

/**
 * 测试使用QueryVo作为查询条件
 */
@Test
public void testFindByVo(){
    QueryVo vo = new QueryVo();
    User user = new User();
    user.setUserName("%王%");
    vo.setUser(user);
    List<User> users = userDao.findUserByVo(vo);
    for(User u : users){
        System.out.println(u);
    }
}

三. mybatis中的连接池以及事务控制

连接池：用于存储连接的一个容器。容器就是一个集合对象，该集合必须是线程安全的，不能两个线程拿到统一连接，该集合必须实现队列的特性：先进先出。

3.1 mybatis中的连接池

在实际得开发中都会使用连接池。可以减少获取连接所消耗的时间。

①mybatis连接池提供了3种方式的配置：

配置的位置：
	主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式。
	
type属性的取值：

	POOLED   采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现。
	
	UNPOOLED   采用传统的获取连接的方式，虽然实现javax.sql.DataSource接口，但是没有使用池的思想。
	
	JNDI    采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器所能拿到的
				DataSource是不一样的。注意：如果不是web获取maven的war工程，是不能使用的。
			使用的tomcat服务器，采用连接池就是dbcp连接池。

3.1.1 Mybatis中的事务提交方式

在我们的主测试类中，分别使用**@Before和@After注解**，表示测试方法执行之前需要加载的内容和执行之后需要完成的操作。

private InputStream in ;
private SqlSession sqlSession;
private IUserDao userDao;

@Before //用于在测试方法执行之前执行
public void init() throws IOException {
    //1.读取配置文件，生成字节输入流
    in = Resources.getResourceAsStream("SqlMapConfig.xml");
    //2.获取SqlSessionFactory对象
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
    //3.获取SqlSession对象
    sqlSession = factory.openSession();
    //4.获取dao的代理对象
    userDao = sqlSession.getMapper(IUserDao.class);
}

sqlSession中的commit方法可以将参数设置为true，表示自动提交。

@After //用于在测试方法执行之后执行
public void destroy() throws IOException {
    //提交事务
    sqlSession.commit(true);
    //释放资源
    sqlSession.close();
    in.close();
}

源码：

它是通过sqlSession对象的commit方法和rollback方法实现事务的提交和回滚。

四. mybatis映射文件的SQL深入

前面的SQL都是比较简单的，有时业务逻辑复杂时，SQL是动态变化的，此时前面的SQL就不能满足要求了。

4.1 if 标签

我们根据实体类的不同取值，使用不同的SQL语句来进行查询。比如在id如果不为空时可以根据id查询，如果username不同空时还要加入用户名作为条件。这种情况在我们的多条件组合查询中经常会碰到。

<!--    根据条件查询
    <select id="findUserByCondition" resultMap="userMap" parameterType="user">
        select * from user where 1 = 1
        <if test="userName != null">
            and username = #{userName}
        </if>
        <if test="userSex != null">
            and sex = #{userSex};
        </if>
    </select>-->

标签test属性中写的是对象的属性名，如果是包装类的对象，要是用OGNL表达式。另外要注意where 1== 1的作用。

4.2 where 标签

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

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

4.3 foreach标签

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

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) 

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

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

package com.ithema.domain;

import java.util.List;

/**
 * @author busihang
 * @date 2020/5/30 - 22:26
 **/
public class QueryVo {

    private List<Integer> ids;

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

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

<!--    根据queryVo中的id集合查询用户列表-->
    <select id="findUserInIds" resultMap="userMap" parameterType="com.ithema.domain.QueryVo">
        <!-- select * from user where id in (1,2,3,4,5); -->
        <include refid="defaultUser"></include>
        <where>
            <if test="ids != null and ids.size()>0">
                <foreach collection="ids" open="and id in (" close=")" item="uid" separator=",">
                    #{uid}
                </foreach>
            </if>
        </where>
    </select>

SQL语句：

select 字段 from user where id in (?)

foreach标签用于遍历集合，它的属性：

collection:代表要遍历的集合元素，注意编写时不要写#{} 

open:代表语句的开始部分 

close:代表结束部分

item:代表遍历集合的每个元素，生成的变量名 ，要与下面的一致

sperator:代表分隔符

4.4 sql标签

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

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

<!--    根据queryVo中的id集合查询用户列表-->
    <select id="findUserInIds" resultMap="userMap" parameterType="com.ithema.domain.QueryVo">
        <!-- select * from user where id in (1,2,3,4,5); -->
        <include refid="defaultUser"></include>
        <where>
            <if test="ids != null and ids.size()>0">
                <foreach collection="ids" open="and id in (" close=")" item="uid" separator=",">
                    #{uid}
                </foreach>
            </if>
        </where>
    </select>

五. mybatis中的多表查询

表之间的关系有几种：

	   一对多          用户和订单
	   多对一          订单和用户
	   一对一          人和身份证号
	   多对多          老师和学生

特例：
如果拿出每一个订单，它都只能属于一个用户。所以mybatis就把多对一看成一对一。

5.1 mybatis中的多表查询之一对多：

示例：
用户和账户
			一个用户可以有多个账户
			一个账户只能属于一个用户（多个账户也可以属于同一用户）

步骤：

		1.建立两个表：一个用户表，账户表
					让用户表和账户表具备一对多的关系：需要使用外键在账户表中添加。
		2.建立两个实体类：用户实体类和账户实体类
					让用户和账户的实体类能体现出来一对多的关系。
		3.建立两个配置文件
					用户的配置文件
					账户配置文件
		4.实现配置：
					当查询用户时，可以同时得到用户下所包含的账户信息
					当查询账户时，可以同时得到账户的所属用户信息

5.1.1 一对一查询（多对一）

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

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

association
		部分定义了账户关联的用户信息，表示关联查询
property
		映射实体类的属性
column
		数据库的列名或者列标签别名
javaType
		完整java类名或别名

①使用resultMap，定义专门的resultMap用于映射一对一查询结果。
通过面向对象的(has a)关系可以得知，我们可以在Account类中加入一个User类的对象来代表这个账户是哪个用户的。

创建Account实体类，并加入User类的对象作为其一个属性

package com.ithema.domain;

import java.io.Serializable;

/**
 * @author busihang
 * @date 2020/6/1 - 18:10
 **/
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 +
                '}';
    }
}

②修改IAccountDao接口中的方法

/**
 * 查询所有账户,同时还要获取当前账户所属用户信息
 * @return
 */
List<Account> findAll();

③重新定义IAccountDao.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.ithema.dao.IAccountDao">

<!--    定义封装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 property="username" column="username"></result>
            <result property="address" column="address"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="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>
</mapper>

④测试

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

5.2 一对多查询

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

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

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

①User类中加入List

//一对多关系映射：主表实体应该包含从表实体的结合引用

private List<Account> accounts;

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

②持久层Dao接口中加入查询方法

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

③持久层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.ithema.dao.IUserDao">

<!--    定义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 property="id" column="aid"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
        </collection>
    </resultMap>

    <select id="findAll" resultMap="userAccountMap">
        select * from user u left outer join account a on u.id = a.uid;
    </select>

</mapper>

5.3 多对多查询

多对多关系其实我们看成是双向的一对多关系。

示例：
用户和角色
用户可以存在多个角色
一个角色也可以赋予多个用户

1.建立两个表：一个用户表，角色表
		让用户表和角色表具有多对多的关系，需要使用中间表，中间表包含各自的主键，
		在中间表中是外键。
		
2.建立两个实体类：用户实体类和角色实体类
		让用户和角色的实体类能体现出来多对多的关系。
		各自包含对方一个集合引用
					
3.建立两个配置文件
		用户的配置文件
		角色配置文件
					
4.实现配置：
		当查询用户时，可以同时得到用户下所包含的角色信息
		当查询角色时，可以同时得到角色的所属用户信息

实现Role到User多对多

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

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

①创建Role实体类

package com.ithema.domain;

import java.io.Serializable;
import java.util.List;

/**
 * @author busihang
 * @date 2020/6/1 - 21:04
 **/
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 + '\'' +
                '}';
    }
}

②编写IRoleDao持久层接口

/**
 * 查询所有角色
 * @return
 */
List<Role> findAll();

③编写映射文件

<?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.ithema.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 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>

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

④测试

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

六. 延迟加载，缓存，注解开发

6.1 Mybatis中的延迟加载

问题： 在一对多中，当我们有一个用户，它有100个账户。
在查询用户时，要不要把关联的账户查出来？

在查询用户时，用户下的账户信息应该是，什么时候使用，什么时候查询的。
在查询账户时，账户所属用户信息应该是随着账户查询时一起查询出来。

	什么是延迟加载：
	
			在真正使用数据时，才发起查询，不用时不查询，也叫按需查询（懒查询）。
			
	什么是立即加载：
	
			不管用不用，只要一调用方法，马上发起查询。
			
	在对应的四种表关系中：一对多，多对一，一对一，多对多
	
			一对多，多对多:通常情况下采用延迟加载。
			
			多对一，一对一:通常情况下都是采用立即加载。

6.1.1 使用assocation实现延迟加载

需求： 查询账户信息同时查询用户信息。

一对一的关系映射：配置封装user内容。

select： 填写我们要调用的 select 映射的 id 。

column ： 填写我们要传递给 select 映射的参数。

select属性指定的内容：查询用户的唯一标识,此处是通过id属性进行查询的，
在IUserDao.xml中，findById是通过id属性进行查询的。

colomn属性指定的内容：用户根据id查询时，所需要的参数的值,此处就是account中的uid属性。

①账户持久层dao接口

/**
 * 查询所有账户,同时还要获取当前账户所属用户信息
 * @return
 */
List<Account> findAll();

②持久层映射文件

<?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.ithema.dao.IAccountDao">

<!--    定义封装account和user的resultMap-->

    <resultMap id="accountUserMap" type="account">
        <id property="id" column="id"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
<!--一对一的关系映射：配置封装user内容，select属性指定的内容：查询用户的唯一标识,此处是通过id属性进行查询的，
        在IUserDao.xml中，findById是通过id属性进行查询的。
        colomn属性指定的内容：用户根据id查询时，所需要的参数的值,此处就是account中的uid属性-->
        <association property="user" column="uid" javaType="user" select="com.ithema.dao.IUserDao.findById"></association>
    </resultMap>

    <select id="findAll" resultMap="accountUserMap">
        select * from account;
    </select>

    <select id="findAccountByUid" resultType="account">
        select * from account where uid = #{uid};
    </select>

</mapper>

③用户持久层接口和映射文件

/**
 * 根据id查询用户信息
 * @param userId
 * @return
 */
User findById(Integer userId);

<?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.itheima.dao.IUserDao"> 
	<!-- 根据id查询 --> 
	<select id="findById" resultType="user" parameterType="int" > 
		select * from user where id = #{uid} 
	</select> 
</mapper>

④开启Mybatis的延迟加载策略
进入mybatis的官方文档，找到settings的说明信息：

在SqlMapConfig.xml文件中添加延迟加载的配置

<!--    配置参数-->
    <settings>
<!--        开启mybatis支持延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

⑤测试

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

⑥结果

我们发现，因为本次只是将Account对象查询出来放入List集合中，并没有涉及到User对象，所以就没有发出SQL语句查询账户所关联的User对象的查询。

5.1.2 使用Collection实现延迟加载

同样我们也可以在一对多关系配置的结点中配置延迟加载策略。
结点中也有select属性，column属性。
需求： 完成加载用户对象时，查询该用户所拥有的账户信息。

①编写User实体类并写入Account类作为其属性

同上。。。

②编写用户和账户持久层接口方法

public interface IUserDao {

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

    /**
     * 根据id查询用户信息
     * @param userId
     * @return
     */
    User findById(Integer userId);

}

③编写持久层映射配置

<?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.ithema.dao.IUserDao">

<!--    定义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" select="com.ithema.dao.IAccountDao.findAccountByUid" column="id"></collection>
    </resultMap>

    <select id="findAll" resultMap="userAccountMap">
        select * from user;
    </select>

    <select id="findById" parameterType="Integer" resultType="user">
        select * from user where id = #{id};
    </select>

</mapper>

<collection>标签： 
		主要用于加载关联的集合对象 。
select属性： 
		用于指定查询account列表的sql语句，所以填写的是该sql映射的id 。
column属性： 
		用于指定select属性的sql语句的参数来源，上面的参数来自于user的id列，
		所以就写成id这一个字段名了。

④账户持久层映射配置

<select id="findAccountByUid" resultType="account">
    select * from account where uid = #{uid};
</select>

⑤测试

    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
//        for(User user : users){
//            System.out.println("=========每个用户的账户信息===========");
//            System.out.println(user);
//            System.out.println(user.getAccounts());
//        }
    }

⑥结果

我们发现并没有加载Account账户信息。

6.2 Mybatis中的缓存

	什么是缓存：
	
			存在于内存中的临时数据。Mybatis中缓存分为一级缓存，二级缓存。

为什么使用缓存：

		减少和数据库的交互次数，提高执行效率。

什么样的数据能使用缓存，什么样的数据不能使用：

		适用于缓存：
				经常查询的数据，并且不经常改变的。
				数据的正确与否对最终结果影响不大的。
									
		不适用于缓存：
				经常改变的数据
				数据的正确与否对最终结果影响很大的。
				例如：商品的库存，银行的汇率，股市的牌价。
							
	Mybatis中的一级缓存和二级缓存：
	
		一级缓存：
				它指Mybatis中SqlSession对象的缓存
				当我们执行查询之后，查询的结果会同时存入到SqlSession为我们提供一块区域中。
				该区域的结构是一个Map，当我们再次查询同样的数据，
				mybatis会先去sqlSession中查询是否有，有的话直接拿来使用
				当SqlSession对象消失时，mybatis的一级缓存也就消失了。

6.2.1 一级缓存

重要：

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

6.2.1.1 证明一级缓存的存在

①编写用户持久层Dao接口

/**
 * 根据id查询用户信息
 * @param userId
 * @return
 */
User findById(Integer userId);

②编写用户持久层映射文件

<select id="findById" parameterType="Integer" resultType="user" useCache="true">
    select * from user where id = #{id};
</select>

③测试

/**
 * 测试一级缓存
 */
@Test
public void testFirstLevelCache(){
    User user1 = userDao.findById(50);
    System.out.println(user1);
    //sqlSession.close();
    //再次获取sqlsession对象
    //sqlSession = factory.openSession(true);
    User user2 = userDao.findById(50);
    System.out.println(user2);
    System.out.println(user1 == user2);
}

④结果

我们可以发现，虽然在上面的代码中我们查询了两次，但最后只执行了一次数据库操作，这就是Mybatis提供给我们的一级缓存在起作用了。因为一级缓存的存在，导致第二次查询id为41的记录时，并没有发出sql语句从数据库中查询数据，而是从一级缓存中查询。

6.2.1.2 分析

第一次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，如果没有，从数据库查询用户信息。

得到用户信息，将用户信息存储到一级缓存中。

如果sqlSession去执行commit操作（执行插入、更新、删除），清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。

第二次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，缓存中有，直接从缓存中获取用户信息。

6.2.2 二级缓存：

二级缓存是mapper映射级别的缓存，多个SqlSession去操作同一个Mapper映射的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。

重要：

二级缓存存放的内容是数据，而不是对象。例：{“id” : 1,"address" : "上海"},如果需要新的查询操作，就将此创建新的对象把数据封装。

	它指Mybatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。
	
	二级缓存的使用步骤：
	
		第一步：让mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）
		第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置）
		第三步：让当前的操作支持二级缓存（在select标签中配置）

首先开启mybatis的二级缓存。

sqlSession1去查询用户信息，查询到用户信息会将查询数据存储到二级缓存中。

如果SqlSession3去执行相同 mapper映射下sql，执行commit提交，将会清空该 mapper映射下的二级缓存区域的数据。

sqlSession2去查询与sqlSession1相同的用户信息，首先会去缓存中找是否存在数据，如果存在直接从缓存中取出数据。

6.2.2.1 二级缓存的开启和关闭

①在SqlMapConfig.xml文件中开启二级缓存

因为cacheEnabled的取值默认就为true，所以这一步可以省略不配置。为true代表开启二级缓存；为false代表不开启二级缓存。

<settings>
    <setting name="cacheEnabled" value="true"/>
</settings>

②配置相关的Mapper映射文件并配置statement上面的useCache属性

标签表示当前这个mapper映射将使用二级缓存，区分的标准就看mapper的namespace值。

将UserDao.xml映射文件中的标签中设置useCache=”true”代表当前这个statement要使用二级缓存，如果不使用二级缓存可以设置为false。

注意：针对每次查询都需要最新的数据sql，要设置成useCache=false，禁用二级缓存。

<?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.ithema.dao.IUserDao">

<!--    开启user支持二级缓存-->
    <cache/>

    <select id="findAll" resultType="user">
        select * from user;
    </select>

    <select id="findById" parameterType="Integer" resultType="user" useCache="true">
        select * from user where id = #{id};
    </select>
</mapper>

6.3 Mybatis中的注解开发

6.3.1mybatis常用注解说明

@Insert:实现新增 
@Update:实现更新 
@Delete:实现删除 
@Select:实现查询 
@Result:实现结果集封装 
@Results:可以与@Result一起使用，封装多个结果集 
@ResultMap:实现引用
@Results定义的封装 
@One:实现一对一结果集封装 
@Many:实现一对多结果集封装 
@SelectProvider: 实现动态SQL映射 
@CacheNamespace:实现注解二级缓存的使用

6.3.2 注解实现基本CRUD

①编写实体类

public class User implements Serializable {

    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserAddress() {
        return userAddress;
    }

    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }

    public String getUserSex() {
        return userSex;
    }

    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }

    public Date getUserBirthday() {
        return userBirthday;
    }

    public void setUserBirthday(Date userBirthday) {
        this.userBirthday = userBirthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userAddress='" + userAddress + '\'' +
                ", userSex='" + userSex + '\'' +
                ", userBirthday=" + userBirthday +
                '}';
    }
}

②使用注解方式开发持久层接口

public interface IUserDao {
    /**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    @Results(id = "userMap", value = {
            @Result(id = true, column = "id",property = "userId"),
            @Result(column = "username",property = "userName"),
            @Result(column = "address",property = "userAddress"),
            @Result(column = "sex",property = "userSex"),
            @Result(column = "birthday",property = "userBirthday"),
    })
    List<User> findAll();

	/**
     * 保存用户
     * @param user
     */
    @Insert("insert into user(username,address,sex,birthday)values(#{username},#{address},#{sex},#{birthday})")
    void saveUser(User user);

    /**
     * 更新用户
     * @param user
     */
    @Update("update user set username = #{username},sex = #{sex},address=#{address},birthday=#{birthday} where id = #{id}")
    void updateUser(User user);

    /**
     * 删除用户
     * @param id
     */
    @Delete("delete from user where id = #{id}")
    void deleteUser(Integer id);


    /**
     * 根据id查询用户
     * @param id
     * @return
     */
    @Select("select * from user where id = #{id}")
    User findById(Integer id);

    /**
     * 根据用户名称迷糊查询
     * @param username
     * @return
     */
    //@Select("select * from user where username like #{username}")
    @Select("select * from user where username like '%${value}%' ")
    List<User> findUserByName(String username);

    /**
     * 查询总用户数量
     * @return
     */
    @Select("select count(*) from user")
    int findTotalUser();
}

③编写SqlMapConfig配置文件

<!--    指定带有注解的dao接口所在位置-->
    <mappers>
        <package name="com.ithema.dao"/>
    </mappers>

④测试

同上。。。

6.3.3 注解实现复杂关系映射开发

实现复杂关系映射之前我们可以在映射文件中通过配置来实现，在使用注解开发时我们需要借助@Results注解，@Result注解，@One注解，@Many注解。

6.3.3.1 复杂关系映射的注解说明

@Results注解

代替的是标签<resultMap> 该注解中可以使用单个@Result注解，也可以使用@Result集合 

@Results（{@Result（），@Result（）}）或@Results（@Result（）） 

@Resutl注解

代替了 <id>标签和<result>标签 

@Result 中 属性介绍：

id 是否是主键字段 
column 数据库的列名 
property需要装配的属性名 
one 需要使用的@One注解（@Result（one=@One）（）））
many 需要使用的@Many注解（@Result（many=@many）（）））

@One注解（一对一）

代替了<assocation>标签，是多表查询的关键，在注解中用来指定子查询返回单一对象。 

@One注解属性介绍：

select 指定用来多表查询的sqlmapper 

fetchType会覆盖全局的配置参数lazyLoadingEnabled。。 

使用格式： @Result(column=" ",property="",one=@One(select="")) 

@Many注解（多对一）

代替了<Collection>标签,是是多表查询的关键，在注解中用来指定子查询返回对象集合。
 
注意：聚集元素用来处理“一对多”的关系。需要指定映射的Java实体类的属性，
属性的javaType（一般为ArrayList）但是注解中可以不定义； 

使用格式： @Result(property="",column="",many=@Many(select=""))

6.3.3.4 实现一对多复杂关系映射及延迟加载

需求： 加载账户信息时并且加载该账户的用户信息，根据情况可实现延迟加载

①实现User实现类和Account实现类

public class User implements Serializable {

    private Integer userId;
    private String userName;
    private String userAddress;
    private String userSex;
    private Date userBirthday;

    //一对多关系映射：一个用户对应多个账户

    private List<Account> accounts;

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

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

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserAddress() {
        return userAddress;
    }

    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }

    public String getUserSex() {
        return userSex;
    }

    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }

    public Date getUserBirthday() {
        return userBirthday;
    }

    public void setUserBirthday(Date userBirthday) {
        this.userBirthday = userBirthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userAddress='" + userAddress + '\'' +
                ", userSex='" + userSex + '\'' +
                ", userBirthday=" + userBirthday +
                '}';
    }
}

public class Account implements Serializable {

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

    //多对一（mybatis中称之为一对一的映射：一个账户只能属于一个用户）

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

②添加持久层接口并使用注解配置

public interface IUserDao {

    /**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    @Results(id = "userMap", value = {
            @Result(id = true, column = "id",property = "userId"),
            @Result(column = "username",property = "userName"),
            @Result(column = "address",property = "userAddress"),
            @Result(column = "sex",property = "userSex"),
            @Result(column = "birthday",property = "userBirthday"),
            @Result(property = "accounts", column = "id",
                    many = @Many(select = "com.ithema.dao.IAccountDao.findAccountByUid",fetchType = FetchType.LAZY))
    })
    List<User> findAll();
}

6.3.4 基于注解的二级缓存

①在SqlMapConfig中开启二级缓存

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

②持久层接口中配置二级缓存

@CacheNamespace(blocking = true)
public interface IUserDao {  }