Mybatis总结

一.框架简介

1.三层架构

软件开发常用的架构是三层架构，之所以流行是因为有着清晰的任务划分。一般包括以下三层：

• 持久层：主要完成与数据库相关的操作，即对数据库的增删改查。
  因为数据库访问的对象一般称为Data Access Object（简称DAO），所以有人把持久层叫做DAO层。
• 业务层：主要根据功能需求完成业务逻辑的定义和实现。
  因为它主要是为上层提供服务的，所以有人把业务层叫做Service层或Business层。
• 表现层：主要完成与最终软件使用用户的交互，需要有交互界面（UI）。
  因此，有人把表现层称之为web层或View层。

三层架构之间调用关系为:表现层调用业务层，业务层调用持久层。
各层之间必然要进行数据交互，我们一般使用java实体对象来传递数据。

2.框架

①什么是框架

框架就是一套规范，既然是规范，你使用这个框架就要遵守这个框架所规定的约束。
框架可以理解为半成品软件，框架做好以后，接下来在它基础上进行开发。

②为什么使用框架

框架为我们封装好了一些冗余，且重用率低的代码。并且使用反射与动态代理机制，将代码实现了通用性，让 开发人员把精力专注在核心的业务代码实现上。
　　比如在使用servlet进行开发时，需要在servlet获取表单的参数，每次都要获取很麻烦，而框架底层
就使用反射机制和拦截器机制帮助我们获取表单的值，使用jdbc每次做专一些简单的crud的时候都必须
写sql，但使用框架就不需要这么麻烦了，直接调用方法就可以。当然，既然是使用框架，那么还是要
遵循其一些规范进行配置

③常见的框架

Java世界中的框架非常的多，每一个框架都是为了解决某一部分或某些问题而存在的。下面列出在目前企业中
流行的几种框架（一定要注意他们是用来解决哪一层问题的）：

• 持久层框架：专注于解决数据持久化的框架。常用的有mybatis、hibernate、spring jdbc等等。
• 表现层框架：专注于解决与用户交互的框架。常见的有struts2、spring mvc等等。
• 全栈框架: 能在各层都给出解决方案的框架。比较著名的就是spring。
  

二、Mybatis简介

1.原始jdbc操作（查询数据）

2.原始jdbc操作的分析

• 原始jdbc开发存在的问题如下：
  ① 数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能
  ② sql 语句在代码中硬编码，造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变java代码。
  ③ 查询操作时，需要手动将结果集中的数据手动封装到实体中。
• 应对上述问题给出的解决方案：
  ① 使用数据库连接池初始化连接资源
  ② 将sql语句抽取到xml配置文件中
  ③ 使用反射、内省等底层技术，自动将实体与表进行属性与字段的自动映射
  

3.Mybatis简介

MyBatis是一个优秀的基于ORM的半自动轻量级持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码

mybatis 历史
MyBatis 本是apache的一个开源项目iBatis, 2010年6月这个项目由apache software foundation 迁移到了google code，随着开发团队转投到Google Code旗下，iBatis正式改名为MyBatis ，代码于2013年11月迁移到Github
Github地址： 点击此处进入
https://github.com/mybatis/mybatis-3/

4.ORM思想

ORM（Object Relational Mapping）对象关系映射

• O（对象模型）：
  实体对象，即我们在程序中根据数据库表结构建立的一个个实体javaBean
• R（关系型数据库的数据结构）：
  关系数据库领域的Relational（建立的数据库表）
• M（映射）：
  从R（数据库）到O（对象模型）的映射，可通过XML文件映射

实现：
①让实体类和数据库表进行一一对应关系
　 先让实体类和数据库表对应
　 再让实体类属性和表里面字段对应
②不需要直接操作数据库表，直接操作表对应的实体类对象

ORM作为是一种思想

• 帮助我们跟踪实体的变化,并将实体的变化翻译成sql脚本,执行到数据库中去,也就是将实体的变化映射到了表的变化。
• mybatis采用ORM思想解决了实体和数据库映射的问题，对jdbc 进行了封装，屏蔽了jdbc api 底层访问细节，使我们不用与jdbc api 打交道，就可以完成对数据库的持久化操作

三、Mybatis快速入门

1.MyBatis开发步骤

MyBatis官网地址：点击此处进入
http://www.mybatis.org/mybatis-3/

案例需求：通过mybatis查询数据库user表的所有记录，封装到User对象中，打印到控制台上
步骤分析：

1.创建数据库及user表
2.创建maven工程，导入依赖（MySQL驱动、mybatis、junit）
3.编写User实体类
4.编写UserMapper.xml映射配置文件（ORM思想）
5.编写SqlMapConfig.xml核心配置文件
数据库环境配置
映射关系配置的引入(引入映射配置文件的路径)
6.编写测试代码
// 1.加载核心配置文件
// 2.获取sqlSessionFactory工厂对象
// 3.获取sqlSession会话对象
// 4.执行sql
// 5.打印结果
// 6.释放资源

2.代码实现

①创建user数据表

CREATE DATABASE `mybatis_db`;
USE `mybatis_db`;
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....
INSERT INTO `user`(`id`,`username`,`birthday`,`sex`,`address`) VALUES (1,'Tom','2020-11-11 00:00:00','男','北京海淀'),(2,'Jack','2020-12-12 00:00:00','男','北京海淀');

②导入MyBatis的坐标和其他相关坐标

<?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>com.lagou</groupId>
    <artifactId>mybatis_quickstart</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--指定编码和版本-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <java.version>1.11</java.version>
        <maven.compiler.source>1.11</maven.compiler.source>
        <maven.compiler.target>1.11</maven.compiler.target>
    </properties>

    <!--引入相关依赖-->
    <dependencies>
        <!--引入mybatis依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.4</version>
        </dependency>

        <!--引入mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <!--引入junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

    </dependencies>

</project>

③编写User实体

public class User {
	private Integer id;
	private String username;
	private Date birthday;
	private String sex;
	private String address;
	// getter/setter方法
}

④编写UserMapper映射文件

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

<!--namespace 命名空间：与id属性共同构成唯一标识 namespace.id: user.findAll-->
<mapper namespace="user">
    <!--resultType:返回结果类型(自动映射封装)：要封装的实体类的全路径-->
    <select id="findAll" resultType="com.mybatis.domain.User">
        select * from user
    </select>
</mapper>

⑤编写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>
    <!--environments 运行环境-->
    <environments default="development">
        <environment id="development">
            <!--当前的事务管理器是JDBC-->
            <transactionManager type="JDBC"></transactionManager>
            <!--数据源信息 POOLED表示使用mybatis的连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///mybatis_db"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!--引入映射配置文件-->
    <mappers>
        <mapper resource="UserMapper.xml"></mapper>
    </mappers>
</configuration>

⑥编写测试类

public class MybatisTest {

    //快速入门测试方法
    @Test
    public void mybatisQuickStart() throws IOException {
        //1.加载配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        //2.获取sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        //3.获取sqlSession会话对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //4.执行sql  参数：namespace.id
        List<User> users = sqlSession.selectList("user.findAll");
        //5.遍历打印结果
        for (User user : users) {
            System.out.println(user);
        }
        //6.关闭资源
        sqlSession.close();
    }
}

3.知识小结

1.创建mybatis_db数据库和user表
2.创建项目，导入依赖
3.创建User实体类
4.编写映射文件UserMapper.xml
5.编写核心文件SqlMapConfig.xml
6.编写测试类

四、Mybatis映射文件概述

五、Mybatis增删改查

1.新增

①编写映射文件UserMapper.xml

<!--新增-->
    <!-- #{} 表示mybatis中的占位符 等同于JDBC中的?   parameterType表示指定接收到的参数类型 -->
    <insert id="saveUser" parameterType="com.lagou.domain.User">
        insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
    </insert>

②编写测试类

//测试新增用户
    @Test
    public void testSaveUser() throws IOException {
        // 加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        // 获取SqlSessionFactory工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        // 获取SqlSession会话对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 执行sql
        User user = new User();
        user.setUsername("jack");
        user.setBirthday(new Date());
        user.setSex("男");
        user.setAddress("北京海淀");
        int i = sqlSession.insert("UserMapper.saveUser", user);
        System.out.println(i);
        // DML语句，手动提交事务
        sqlSession.commit();
        // 释放资源
        sqlSession.close();
    }

③新增注意事项

1.插入语句使用insert标签
2.在映射文件中使用parameterType属性指定要插入的数据类型
3.Sql语句中使用#{实体属性名}方式引用实体中的属性值
4.插入操作使用的API是sqlSession.insert(“命名空间.id”,实体对象);
5.插入操作涉及数据库数据变化，所以要使用sqlSession对象显示的提交事务，即sqlSession.commit()

2.修改

①编写映射文件UserMapper.xml

<!--更新-->
    <update id="updateUser" parameterType="com.lagou.domain.User">
        update user set username = #{username},birthday = #{birthday},sex = #{sex},address = #{address} where id = #{id}
    </update>

②编写测试类

//测试更新用户
    @Test
    public void testUpdateUser() throws IOException {
        // 加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        // 获取SqlSessionFactory工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        // 获取SqlSession会话对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 执行sql
        User user = new User();
        user.setId(7);
        user.setUsername("luck");
        user.setBirthday(new Date());
        user.setSex("女");
        user.setAddress("北京朝阳");
        int i = sqlSession.update("UserMapper.updateUser", user);
        System.out.println(i);
        // DML语句，手动提交事务
        sqlSession.commit();
        // 释放资源
        sqlSession.close();
    }

③修改注意事项

1.修改语句使用update标签
2.修改操作使用的API是sqlSession.update(“命名空间.id”,实体对象);

3.删除

①编写映射文件UserMapper.xml

<!--删除-->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id = #{id}
    </delete>

②编写测试类

//测试删除
    @Test
    public void testDeleteUser() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        int i = sqlSession.delete("UserMapper.deleteUser", 4);
        sqlSession.commit();
        sqlSession.close();
    }

③删除注意事项

1.删除语句使用delete标签
2.Sql语句中使用#{任意字符串}方式引用传递的单个参数
3.删除操作使用的API是sqlSession.delete(“命名空间.id”,Object);

六、Mybatis核心文件概述

1.MyBatis核心配置文件层级关系

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。
配置文档的顶层结构如下：

注意以上标签的顺序

2.MyBatis常用配置解析

①environments标签

数据库环境的配置，支持多环境配置

1. 其中，事务管理器（transactionManager）类型有两种：
   ● JDBC：
   这个配置就是直接使用了JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。
   ● MANAGED：
   这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期。
   例如：mybatis与spring整合后，事务交给spring容器管理。
   2.其中，数据源（dataSource）常用类型有三种：
   ● UNPOOLED：
   这个数据源的实现只是每次被请求时打开和关闭连接。
   ● POOLED：
   这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来。
   ● JNDI :
   这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用

②properties标签

实际开发中，习惯将数据源的配置信息单独抽取成一个properties文件，该标签可以加载额外配置的properties：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///mybatis_db
jdbc.username=root
jdbc.password=123456

③typeAliases标签

类型别名是为 Java 类型设置一个短的名字。
为了简化映射文件 Java 类型设置，mybatis框架为我们设置好的一些常用的类型的别名：


配置typeAliases，为com.mybatis.domain.User定义别名为user：

④mappers标签

该标签的作用是加载映射的，加载方式有如下几种：

1.使用相对于类路径的资源引用，例如：
　< mapper resource=“org/mybatis/builder/userMapper.xml”/>
2.使用完全限定资源定位符（URL），例如：
　< mapper url=“file:///var/mappers/userMapper.xml”/>
3.使用映射器接口实现类的完全限定类名，例如：
　< mapper class=“org.mybatis.builder.userMapper”/>
4.将包内的映射器接口实现全部注册为映射器，例如：
　< package name=“org.mybatis.builder”/>

3.知识小结

核心配置文件常用配置：
properties标签：该标签可以加载外部的properties文件

<properties resource="jdbc.properties"></properties>

typeAliases标签：设置类型别名

<typeAlias type="com.mybatis.domain.User" alias="user"></typeAlias>

mappers标签：加载映射配置

<mapper resource="com/mybatis/mapper/UserMapping.xml"></mapper>

environments标签：数据源环境配置

<environments default="development">
	<environment id="development">
		<transactionManager type="JDBC"/>
		<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>
	</environment>
</environments>

七、Mybatis的API概述

1.API介绍

①SqlSession工厂构建器SqlSessionFactoryBuilder

常用API：SqlSessionFactory build(InputStream inputStream)
通过加载mybatis的核心文件的输入流的形式构建一个SqlSessionFactory对象

String resource = "org/mybatis/builder/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(inputStream);

其中， Resources 工具类，这个类在 org.apache.ibatis.io 包中。Resources 类帮助你从类路径下、文
件系统或一个 web URL 中加载资源文件。

②SqlSession工厂对象SqlSessionFactory

SqlSessionFactory 有多个个方法创建SqlSession 实例。常用的有如下两个：

③SqlSession会话对象

SqlSession 实例在 MyBatis 中是非常强大的一个类。在这里你会看到所有执行语句、提交或回滚事务和获取映射器实例的方法。
执行语句的方法主要有：

<T> T selectOne(String statement, Object parameter)
<E> List<E> selectList(String statement, Object parameter)
int insert(String statement, Object parameter)
int update(String statement, Object parameter)
int delete(String statement, Object parameter)

操作事务的方法主要有：

void commit()
void rollback()

2.Mybatis基本原理介绍

八、Mybatis的dao层开发使用

1.传统开发方式

①编写UserMapper接口

public interface IUserDao {
    //查询所有
    public List<User> findAll() throws IOException;
}

② 编写UserMapper实现

public class UserDaoImpl implements IUserDao {
    @Override
    public List<User> findAll() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        List<User> users = sqlSession.selectList("userMapper.findAll");
        sqlSession.close();
        return users;
    }
}

③编写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="userMapper">
    <select id="findAll" resultType="user">
        select * from user
    </select>
</mapper>

④测试

public class MybatisTest {
    //mybatis的dao传统方法 测试
    @Test
    public void test1() throws IOException {
        IUserDao userDao = new UserDaoImpl();
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
}

⑤知识小结

传统开发方式

1.编写UserMapper接口
2.编写实现类
3.编写UserMapper.xml

传统方式问题：
1.实现类中，存在mybatis模板代码重复
2.实现类调用方法时，xml中的sql statement 硬编码到java代码中
思考：能否只写接口，不写实现类。只编写接口和Mapper.xml即可？
因为在dao(mapper)的实现类中对sqlsession的使用方式很类似。因此mybatis提供了接口的动态代理。

2.代理开发方式

①介绍

采用 Mybatis 的基于接口代理方式实现 持久层 的开发，这种方式是我们后面进入企业的主流。
基于接口代理方式的开发只需要程序员编写Mapper接口,Mybatis 框架会为我们动态生成实现类的对象。
这种开发方式要求我们遵循一定的规范：

• Mapper.xml映射文件中的namespace与mapper接口的全限定名相同
• Mapper接口方法名和Mapper.xml映射文件中定义的每个statement的id相同
• Mapper接口方法的输入参数类型和mapper.xml映射文件中定义的每个sql的parameterType的类型相同
• Mapper接口方法的输出参数类型和mapper.xml映射文件中定义的每个sql的resultType的类型相同

Mapper 接口开发方法只需要程序员编写Mapper 接口（相当于Dao 接口），由Mybatis 框架根据接口
定义创建接口的动态代理对象，代理对象的方法体同上边Dao接口实现类方法。

②编写UserMapper接口

public interface UserMapper {
	public List<User> findAll() throws Exception;
}

③编写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.lagou.mapper.UserMapper">
	<!--查询所有-->
	<select id="findAll" resultType="user">
		select * from user
	</select>
</mapper>

④测试

@Test
public void testFindAll() throws Exception {
	// 加载核心配置文件
	InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
	// 获得SqlSessionFactory工厂对象
	SqlSessionFactory sqlSessionFactory = new
	SqlSessionFactoryBuilder().build(is);
	// 获得SqlSession会话对象
	SqlSession sqlSession = sqlSessionFactory.openSession();
	// 获得Mapper代理对象
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	// 执行查询
	List<User> list = userMapper.findAll();
	for (User user : list) {
		System.out.println(user);
	}
	// 释放资源
	sqlSession.close();
}

⑤Mybatis基于接口代理方式的内部执行原理

我们的持久层现在只有一个接口，而接口是不实际干活的，那么是谁在做查询的实际工作呢？
下面通过追踪源码看一下：
1、通过追踪源码我们会发现，我们使用的mapper实际上是一个代理对象,是由MapperProxy代理产生
的。2、追踪MapperProxy的invoke方法会发现，其最终调用了mapperMethod.execute(sqlSession, args)
3、进入execute方法会发现，最终工作的还是sqlSession

九、Mybatis 高级查询

1.ResutlMap 属性

建立对象关系映射

• resultType
  如果实体的属性名与表中字段名一致，将查询结果自动封装到实体类中
• ResutlMap
  如果实体的属性名与表中字段名不一致，可以使用ResutlMap 实现手动封装到实体类中

①编写UserMapper 接口

public interface UserMapper {
	public List<User> findAllResultMap();
}

②编写UserMapper.xml

<!--
	实现手动映射封装
	resultMap
		id="userResultMap" 此标签唯一标识
		type="user" 封装后的实体类型
	<id column="uid" property="id"></id> 表中主键字段封装
		column="uid" 表中的字段名
		property="id" user 实体的属性名
	<result column="NAME" property="username"></result> 表中普通字段封装
		column="NAME" 表中的字段名
		property="username" user 实体的属性名
	补充：如果有查询结果有 字段与属性是对应的，可以省略手动封装
-->
<resultMap id="userResultMap" type="user">
	<id column="uid" property="id"></id>
	<result column="NAME" property="username"></result>
	<result column="PASSWORD" property="username"></result>
</resultMap>
<select id="findAllResultMap" resultMap="userResultMap">
	SELECT id AS uid,username AS NAME,password AS PASSWORD FROM USER
</select>

③代码测试

@Test
public void testFindAllResultMap() throws Exception {
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	List<User> list = userMapper.findAllResultMap();
	for (User user : list) {
		System.out.println(user); 
	}
}

2.多条件查询（三种）

需求
根据id 和username 查询 user 表

①方式一

使用 #{arg0}-#{argn} 或者 #{param1}-#{paramn} 获取参数
UserMapper 接口

public interface UserMapper {
	public List<User> findByIdAndUsername1(Integer id, String username);
}

UserMapper.xml

<mapper namespace="com.mybatis.mapper.UserMapper">
	<select id="findByIdAndUsername1" resultType="user">
		<!-- select * from user where id = #{arg0} and username = #{arg1} -->
		select * from user where id = #{param1} and username = #{param2}
	</select>
</mapper>

测试

@Test
    public void test1() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = userMapper.findByIdAndUsername1(1, "子慕");
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

②方式二

使用注解，引入 @Param() 注解获取参数
UserMapper 接口

public interface UserMapper {
	public List<User> findByIdAndUsername2(@Param("id") Integerid,@Param("username") String username);
}

UserMapper.xml

<mapper namespace="com.mybatis.mapper.UserMapper">
	<select id="findByIdAndUsername2" resultType="user">
		select * from user where id = #{id} and username = #{username}
	</select>
</mapper>

测试

@Test
    public void test2() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = userMapper.findByIdAndUsername2(1, "子慕");
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

③方式三（推荐）

使用pojo 对象传递参数
UserMapper 接口

public interface UserMapper {
	public List<User> findByIdAndUsername3(User user);
}

UserMapper.xml

<mapper namespace="com.mybatis.mapper.UserMapper">
	<select id="findByIdAndUsername3" parameterType="com.mybatis.domain.User" resultType="com.mybatis.domain.User">
		select * from user where id = #{id} and username = #{username}
	</select>
</mapper>

测试

@Test
    public void test3() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user1 = new User();
        user1.setId(1);
        user1.setUsernameabc("子慕");
        List<User> users = userMapper.findByIdAndUsername3(user1);
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

3.模糊查询(两种)

需求
根据username 模糊查询user 表

①方式一

UserMapper 接口

public interface UserMapper {
	public List<User> findByUsername1(String username);
}

UserMapper.xml

<mapper namespace="com.mybatis.mapper.UserMapper">
	<!--#{}在mybatis中是占位符，引用参数值时会自动添加单引号-->
	<select id="findByUsername1" parameterType="string" resultType="user">
		select * from user where username like #{username}
	</select>
</mapper>

测试

@Test
    public void test4() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = userMapper.findByUsername1("%子慕%");
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

②方式二

UserMapper 接口

public interface UserMapper {
	public List<User> findByUsername2(String username);
}

UserMapper.xm

<select id="findByUsername2" resultMap="userResultMap" parameterType="string">
     <!--parameterType是基本数据类型或者String时, ${}里面的值只能写value  ${} sql原样拼接-->
     select * from user where username like '${value}'
</select>

测试

@Test
    public void test5() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = userMapper.findByUsername2("%子慕%");
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

③${} 与 #{} 区别

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

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

${ } :表示拼接sql 串

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

可以查看TextSqlNode.java源码证明

十、Mybatis 映射文件深入

1.返回主键

应用场景
我们很多时候有这种需求，向数据库插入一条记录后，希望能立即拿到这条记录在数据库中的主键值。

①useGeneratedKeys

public interface UserMapper {
	// 返回主键
	public void saveUser(User user);
}

<!--
useGeneratedKeys="true" 声明返回主键
keyProperty="id" 把返回主键的值，封装到实体的id 属性中
注意：只适用于主键自增的数据库，mysql 和 sqlserver 支持，oracle 不支持
-->
<insert id="save" parameterType="user" useGeneratedKeys="true" keyProperty="id">
	INSERT INTO `user`(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
</insert>

@Test
    public void test6() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setUsername("Java");
        user.setAddress("北京");
        user.setBirthday(new Date());
        user.setSex("男");
        System.out.println(user);
        userMapper.saveUser(user);
        System.out.println(user);
        sqlSession.commit();
        sqlSession.close();
    }

注意：只适用于主键自增的数据库,mysql和sqlserver支持,oracle不行。

②selectKey

public interface UserMapper {
	// 返回主键
	public void saveUser2(User user);
}

<!--    selectKey 适用范围广，支持所有类型数据库
            keyColumn="id" 指定主键列名
            keyProperty="id" 指定主键封装到实体的 id 属性中
            resultType="int" 指定主键类型
            order="AFTER" 设置在 sql 语句执行前（后），执行此语句  -->
    <insert id="saveUser2" parameterType="user">
        <selectKey keyColumn="id" keyProperty="id" resultType="int" order="AFTER">
            SELECT LAST_INSERT_ID();
        </selectKey>
        INSERT INTO `user`(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
    </insert>

@Test
    public void test7() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setUsername("Python");
        user.setAddress("北京");
        user.setBirthday(new Date());
        user.setSex("男");
        System.out.println(user);
        userMapper.saveUser2(user);
        System.out.println(user);
        sqlSession.commit();
        sqlSession.close();
    }

2.动态 SQL

应用场景
当我们要根据不同的条件,来执行不同的sql语句的时候,需要用到动态sql。

①动态 SQL 之< if >

需求
根据id 和username 查询，但是不确定两个都有值。

a.UserMapper 接口

public List<User> findByIdAndUsernameIf(User user);

b.UserMapper.xml 映射

<!--
where 标签相当于 where 1=1，但是如果没有条件，就不会拼接where 关键字
-->
	<select id="findByIdAndUsernameIf" parameterType="user" resultType="user">
	SELECT * FROM user
	<where>
		<if test="id != null">
			AND id = #{id}
		</if>
		<if test="username != null">
			AND username = #{username}
		</if>
	</where>
</select>

c.测试代码

// if 标签 where 标签
@Test
public void testFindByIdAndUsernameIf() throws Exception {
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	User param = new User();
	// param.setId(42);
	// param.setUsername("王小二");
	List<User> list = userMapper.findByIdAndUsernameIf(param);
	System.out.println(list);
}

② 动态 SQL 之< choose >

需求
如果有id 只使用id 做查询，没有 id 的话看是否有username，有username 就根据username 做查询，如果都没有，就不带条件。

a.UserMapper 接口

public List<User> findByIdAndUsernameChoose(User user);

b.UserMapper.xml 映射

<!--
	choose 标签相当于swtich 语句
	when 标签相当于case 语句
	otherwise 标签相当于default 语句
-->
	<select id="findByIdAndUsernameChoose" parameterType="user" resultType="user">
	SELECT * FROM user
	<where>
		<choose>
			<when test="id != null">
				AND id = #{id}
			</when>
			<when test="username != null">
				AND username = #{username}
			</when>
			<otherwise>
				AND 1=1
			</otherwise>
		</choose>
	</where>
</select>

c.测试代码

// choose 标签
@Test
public void testFindByIdAndUsernameChoose() throws Exception {
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	User param = new User();
	// param.setId(42);
	// param.setUsername("王小二");
	List<User> list = userMapper.findByIdAndUsernameChoose(param);
	System.out.println(list);
}

③动态 SQL 之< set >

需求
动态更新user 表数据，如果该属性有值就更新，没有值不做处理。

a.UserMapper 接口

public void updateIf(User user);

b.UserMapper.xml 映射

<!--
set 标签在更新的时候，自动加上set 关键字，然后去掉最后一个条件的逗号
-->
<update id="updateIf" parameterType="user">
	UPDATE user
	<set>
		<if test="username != null">
			username = #{username},
		</if>
		<if test="birthday != null">
			birthday = #{birthday},
		</if>
		<if test="sex !=null">
			sex = #{sex},
		</if>
		<if test="address !=null">
			address = #{address},
		</if>
	</set>
	WHERE id = #{id}
</update>

c.测试代码

// set 标签
@Test
public void testUpdateIf()throws Exception{
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	User user = new User();
	user.setId(51);
	user.setUsername("小二王");
	user.setSex("女");
	userMapper.updateIf(user);
}

④动态 SQL 之< foreach >

foreach 主要是用来做数据的循环遍历
例如：select * from user where id in (1,2,3) 在这样的语句中，传入的参数部分必须依靠foreach 遍历才能实现。

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

a.集合

UserMapper 接口

public List<User> findByList(List<Integer> ids);

UserMaper.xml 映射

<!--
	如果查询条件为普通类型 List 集合，collection 属性值为：collection 或者 list
-->
<select id="findByList" parameterType="list" resultType="user" >
	SELECT * FROM `user`
	<where>
		<foreach collection="collection" open="id in(" close=")" item="id" separator=",">
			#{id}
		</foreach>
	</where>
</select>

测试代码

// foreach 标签 list
@Test
public void testFindByList() throws Exception {
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	List<Integer> ids = new ArrayList<>();
	ids.add(46);
	ids.add(48);
	ids.add(51);
	List<User> list = userMapper.findByList(ids);
	System.out.println(list);
}

b.数组

UserMapper 接口

public List<User> findByArray(Integer[] ids);

UserMaper.xml 映射

<!--
	如果查询条件为普通类型 Array 数组，collection 属性值为：array
-->
<select id="findByArray" parameterType="int" resultType="user">
	SELECT * FROM `user`
	<where>
		<foreach collection="array" open="id in(" close=")" item="id" separator=",">
			#{id}
		</foreach>
	</where>
</select>

测试代码

// foreach 标签 array
@Test
public void testFindByArray() throws Exception {
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	Integer[] ids = {46, 48, 51};
	List<User> list = userMapper.findByArray(ids);
	System.out.println(list);
}

c.pojo

QueryVo

public class QueryVo {
	private List<Integer> ids;
}

核心配置文件

<!--设置实体别名-->
<typeAliases>
	<typeAlias type="com.lagou.domain.User" alias="user"></typeAlias>
	<typeAlias type="com.lagou.domain.QueryVo" alias="queryVo"></typeAlias>
</typeAliases>

UserMapper 接口

public List<User> findByPojo(QueryVo queryVo);

UserMaper.xml 映射

<!--
	如果查询条件为复杂类型pojo 对象，collection 属性值为：集合或数组的属性名
-->
<select id="findByPojo" parameterType="queryVo" resultType="user">
	SELECT * FROM `user`
	<where>
		<foreach collection="ids" open="id in(" close=")" item="id" separator=",">
			#{id}
		</foreach>
	</where>
</select>

测试代码

// foreach 标签 pojo
@Test
public void testFindByPojo() throws Exception {
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	List<Integer> ids = new ArrayList<>();
	ids.add(46);
	ids.add(48);
	ids.add(51);
	QueryVo queryVo = new QueryVo();
	queryVo.setIds(ids);
	List<User> list = userMapper.findByPojo(queryVo);
	System.out.println(list);
}

3.SQL 片段

应用场景
映射文件中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的

<!--抽取的sql 片段-->
<sql id="selectUser">
	SELECT * FROM `user`
</sql>
<select id="findByList" parameterType="list" resultType="user" >
	<!--引入 sql 片段-->
	<include refid="selectUser"></include>
	<where>
		<foreach collection="collection" open="id in(" close=")" item="id" separator=",">
			#{id}
		</foreach>
	</where>
</select>
	<select id="findByArray" parameterType="integer[]" resultType="user">
	<!--引入 sql 片段-->
	<include refid="selectUser"></include>
	<where>
		<foreach collection="array" open="id in(" close=")" item="id" separator=",">
			#{id}
		</foreach>
	</where>
</select>

4.知识小结

MyBatis 映射文件配置

< select >：查询
< insert >：插入
< update >：修改
< delete >：删除
< selectKey >：返回主键
< where >：where 条件
< if >：if 判断
< foreach >：for 循环
< set >：set 设置
< sql >：sql 片段抽取

十一、Mybatis 核心配置文件深入

1.plugins 标签

MyBatis 可以使用第三方的插件来对功能进行扩展，分页助手PageHelper 是将分页的复杂操作进行封装，使用简单的方式即可获得分页的相关数据
开发步骤：
①导入通用PageHelper 的坐标
②在mybatis 核心配置文件中配置PageHelper 插件
③测试分页数据获取

①导入通用 PageHelper 坐标

<!-- 分页助手 -->
<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>3.7.5</version>
</dependency>
<dependency>
	<groupId>com.github.jsqlparser</groupId>
	<artifactId>jsqlparser</artifactId>
	<version>0.9.1</version>
</dependency>

②在 mybatis 核心配置文件中配置PageHelper 插件

<!-- 注意：分页助手的插件 配置在通用馆mapper 之前 -->
<plugin interceptor="com.github.pagehelper.PageHelper">
	<!-- 指定方言 -->
	<property name="dialect" value="mysql"/>
</plugin>

③测试分页代码实现

@Test
public void testPageHelper(){
	//设置分页参数
	PageHelper.startPage(1,2);
	List<User> select = userMapper2.select(null);
	for(User user : select){
		System.out.println(user);
	}
}

获得分页相关的其他参数

//其他分页的数据
PageInfo<User> pageInfo = new PageInfo<User>(select);
System.out.println("总条数："+pageInfo.getTotal());
System.out.println("总页数："+pageInfo.getPages());
System.out.println("当前页："+pageInfo.getPageNum());
System.out.println("每页显示长度："+pageInfo.getPageSize());
System.out.println("是否第一页："+pageInfo.isIsFirstPage());
System.out.println("是否最后一页："+pageInfo.isIsLastPage());

2.知识小结

MyBatis 核心配置文件常用标签：

1. properties 标签：该标签可以加载外部的 properties 文件
2. typeAliases 标签：设置类型别名
3. environments 标签：数据源环境配置标签
4. plugins 标签：配置MyBatis 的插件

十二、Mybatis 多表查询

1.数据库表关系介绍

关系型数据库表关系分为

• 一对一
• 一对多
• 多对多

举例

• 人和身份证号就是一对一
  一个人只能有一个身份证号
  一个身份证号只能属于一个人
• 用户和订单就是一对多，订单和用户就是多对一
  一个用户可以下多个订单
  多个订单属于同一个用户
• 学生和课程就是多对多
  一个学生可以选修多门课程
  一个课程可以被多个学生选修
• 特例
  一个订单只从属于一个用户，所以mybatis 将多对一看成了一对一

DROP TABLE IF EXISTS `orders`;
CREATE TABLE `orders` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `ordertime` varchar(255) DEFAULT NULL,
 `total` DOUBLE DEFAULT NULL,
 `uid` INT(11) DEFAULT NULL,
 PRIMARY KEY (`id`),
 KEY `uid` (`uid`),
 CONSTRAINT `orders_ibfk_1` FOREIGN KEY (`uid`) REFERENCES `user` (`id`)
) ENGINE=INNODB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of orders
-- ----------------------------
INSERT INTO `orders` VALUES ('1', '2020-12-12', '3000', '1');
INSERT INTO `orders` VALUES ('2', '2020-12-12', '4000', '1');
INSERT INTO `orders` VALUES ('3', '2020-12-12', '5000', '2');
-- ----------------------------
-- Table structure for sys_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role` (
 `id` INT(11) NOT NULL AUTO_INCREMENT,
 `rolename` VARCHAR(255) DEFAULT NULL,
 `roleDesc` VARCHAR(255) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of sys_role
-- ----------------------------
INSERT INTO `sys_role` VALUES ('1', 'CTO', 'CTO');
INSERT INTO `sys_role` VALUES ('2', 'CEO', 'CEO');
-- ----------------------------
-- Table structure for sys_user_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role` (
 `userid` INT(11) NOT NULL,
 `roleid` INT(11) NOT NULL,
 PRIMARY KEY (`userid`,`roleid`),
 KEY `roleid` (`roleid`),
 CONSTRAINT `sys_user_role_ibfk_1` FOREIGN KEY (`userid`) REFERENCES `user` (`id`),
 CONSTRAINT `sys_user_role_ibfk_2` FOREIGN KEY (`roleid`) REFERENCES `sys_role` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of sys_user_role
-- ----------------------------
INSERT INTO `sys_user_role` VALUES ('1', '1');
INSERT INTO `sys_user_role` VALUES ('2', '1');
INSERT INTO `sys_user_role` VALUES ('1', '2');
INSERT INTO `sys_user_role` VALUES ('2', '2');

2.一对一（多对一）multitable

①介绍

一对一查询模型
用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户一对一查询的需求：查询一个订单，与此同时查询出该订单所属的用户

一对一查询语句

SELECT * FROM orders o LEFT JOIN USER u ON o.uid = u.id

②代码实现

a.Order 实体

public class Order {
	private Integer id;
	private Date ordertime;
	private double money;
	// 表示当前订单属于哪个用户
	private User user;
	get/set方法
}

b.OrderMapper 接口

public interface OrderMapper {
	public List<Order> findAllWithUser();
}

c.OrderMapper.xml 映射

<!--1对1关联查询 查询所有订单，与此同时还要查询出每个订单所属的用户信息-->
    <resultMap id="orderMap" type="com.lagou.domain.Orders">
        <id property="id" column="id"/>
        <result property="ordertime" column="ordertime"/>
        <result property="total" column="total"/>
        <result property="uid" column="uid"/>

        <!--
            association 进行一对一关联查询配置时，使用association标签进行关联
            property="user" 要封装实体的属性名
            javaType="com.lagou.domain.User" 要封装实体的属性类型
        -->
        <association property="user" javaType="com.lagou.domain.User">
            <id property="id" column="uid"/>
            <result property="username" column="username"/>
            <result property="birthday" column="birthday"/>
            <result property="sex" column="sex"/>
            <result property="address" column="address"/>
        </association>
    </resultMap>

    <select id="findAllWithUser" resultMap="orderMap">
        SELECT * FROM orders o LEFT JOIN USER u ON o.uid=u.id
    </select>

d.测试代码

//1对1关联查询
    @Test
    public void test1() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
        List<Orders> orders = mapper.findAllWithUser();
        for (Orders order : orders) {
            System.out.println(order);
        }
        sqlSession.close();
    }

3.一对多

①介绍

一对多查询模型
用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户
一对多查询的需求：查询一个用户，与此同时查询出该用户具有的订单
一对多查询语句

SELECT u.*,o.id oid,o.ordertime,o.total,o.uid FROM orders o RIGHT JOIN USER u ON o.uid=u.id

②代码实现

a.User 实体

public class User {
	private Integer id;
	private String username;
	private Date birthday;
	private String sex;
	private String address;
	// 代表当前用户具备的订单列表
	private List<Order> orderList;
	get/set方法
}

b.UserMapper 接口

public interface UserMapper {
	public List<User> findAllWithOrder();
}

c.UserMapper.xml 映射

<!--一对多关联查询：查询所有的用户同时还要查询出每个用户所关联的订单信息-->
    <resultMap id="userMap" type="com.lagou.domain.User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>

        <!--
            collection：一对多使用collection标签进行关联
        -->
        <collection property="ordersList" ofType="com.lagou.domain.Orders">
            <id property="id" column="oid"/>
            <result property="ordertime" column="ordertime"/>
            <result property="total" column="total"/>
            <result property="uid" column="uid"/>
        </collection>
    </resultMap>

    <select id="findAllWithOrder" resultMap="userMap">
        SELECT u.*,o.id oid,o.ordertime,o.total,o.uid FROM orders o RIGHT JOIN USER u ON o.uid=u.id
    </select>

d.测试代码

//1对多关联查询
    @Test
    public void test2() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> list = userMapper.findAllWithOrder();
        for (User user : list) {
            System.out.println(user);
        }
    }

4.多对多

①介绍

多对多查询的模型
用户表和角色表的关系为，一个用户有多个角色，一个角色被多个用户使用
多对多查询的需求：查询用户同时查询出该用户的所有角色
多对多查询语句

SELECT u.*,r.id rid,r.rolename,r.roleDesc FROM USER u LEFT JOIN sys_user_role ur ON u.id=ur.userid LEFT JOIN sys_role r ON r.id=ur.roleid

②代码实现

a.User 和Role 实体

public class User {
	private Integer id;
	private String username;
	private Date birthday;
	private String sex;
	private String address;
	// 代表当前用户关联的角色列表
	private List<Role> roleList;
}

public class Role {
	private Integer id;
	private String roleName;
	private String roleDesc;
}

b.UserMapper 接口

public interface UserMapper {
	public List<User> findAllWithRole();
}

c.UserMapper.xml 映射

<!--多对多关联查询：查询所有的用户同时还要查询出每个用户所关联的角色信息-->
    <resultMap id="userRoleMap" type="com.lagou.domain.User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>
        <collection property="roleList" ofType="com.lagou.domain.Role">
            <id property="id" column="rid"/>
            <result property="rolename" column="rolename"/>
            <result property="roleDesc" column="roleDesc"/>
        </collection>
    </resultMap>
    <select id="findAllWithRole" resultMap="userRoleMap">
        SELECT u.*,r.id rid,r.rolename,r.roleDesc FROM USER u LEFT JOIN sys_user_role ur ON u.id=ur.userid LEFT JOIN sys_role r ON r.id=ur.roleid
    </select>

d.测试代码

//多对多关联查询
    @Test
    public void test3() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = userMapper.findAllWithRole();
        for (User user : users) {
            System.out.println(user);
        }
    }

5.小结

MyBatis 多表配置方式

• 一对一配置：使用+做配置
• 一对多配置：使用+做配置
• 多对多配置：使用+做配置
• 多对多的配置跟一对多很相似，难度在于SQL 语句的编写

十三、MyBatis 嵌套查询

1.什么是嵌套查询

嵌套查询就是将原来多表查询中的联合查询语句拆成单个表的查询，再使用 mybatis 的语法嵌套在一
起。
举个例子

• 需求：查询一个订单，与此同时查询出该订单所属的用户

1. 联合查询
   SELECT * FROM orders o LEFT JOIN USER u ON o.uid=u.id;
2. 嵌套查询
   a. 先查询订单
   SELECT * FROM orders
   b. 再根据订单uid 外键，查询用户
   SELECT * FROM user WHERE id = #{根据订单查询的 uid}
   c. 最后使用mybatis，将以上二步嵌套起来
   …

2.一对一嵌套查询

①介绍

需求：查询一个订单，与此同时查询出该订单所属的用户
一对一查询语句

-- 先查询订单
SELECT * FROM orders;
-- 再根据订单 uid 外键，查询用户
SELECT * FROM `user` WHERE id = #{订单的uid};

②代码实现

a.OrderMapper 接口

public interface OrderMapper {
	public List<Order> findAllWithUser2();
}

b.OrderMapper.xml 映射

<!--1对1嵌套查询-->
    <resultMap id="orderMap2" type="com.lagou.domain.Orders">
        <id property="id" column="id"/>
        <result property="ordertime" column="ordertime"/>
        <result property="total" column="total"/>
        <result property="uid" column="uid"/>
        <association property="user" javaType="com.lagou.domain.User" select="com.lagou.mapper.UserMapper.findById" column="uid">

        </association>
    </resultMap>
    <select id="findAllWithUser2" resultMap="orderMap2">
        select * from orders
    </select>

c.UserMapper 接口

public interface UserMapper {
	public User findById(Integer id);
}

d.UserMapper.xml 映射

<select id="findById" parameterType="int" resultType="user">
	SELECT * FROM `user` where id = #{uid}
</select>

e.测试代码

@Test
    public void test4() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
        List<Orders> orders = mapper.findAllWithUser2();
        for (Orders order : orders) {
            System.out.println(order);
        }
        sqlSession.close();
    }

3.一对多嵌套查询

①介绍

需求：查询一个用户，与此同时查询出该用户具有的订单
一对多查询语句

-- 先查询用户
SELECT * FROM `user`;
-- 再根据用户 id 主键，查询订单列表
SELECT * FROM orders where uid = #{用户 id};

②代码实现

a.UserMapper 接口

public interface UserMapper {
	public List<User> findAllWithOrder2();
}

b.UserMapper.xml 映射

<resultMap id="orderMap" type="com.lagou.domain.User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>
        <collection property="ordersList" ofType="com.lagou.domain.Orders" select="com.lagou.mapper.OrderMapper.findByUid" column="id"></collection>
    </resultMap>
    <select id="findAllWithOrder2" resultMap="orderMap">
        select * from user
    </select>

c.OrderMapper 接口

public interface OrderMapper {
	public List<Order> findByUid(Integer uid);
}

d.OrderMapper.xml 映射

<select id="findByUid" parameterType="int" resultType="order">
	SELECT * FROM orders where uid = #{uid}
</select>

e.测试代码

@Test
    public void test5() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.findAllWithOrder2();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

4.多对多嵌套查询

①介绍

需求：查询用户同时查询出该用户的所有角色
多对多查询语句

-- 先查询用户
SELECT * FROM `user`;
-- 再根据用户 id 主键，查询角色列表
SELECT * FROM role r INNER JOIN user_role ur ON r.`id` = ur.`rid`
WHERE ur.`uid` = #{用户 id};

②代码实现

a.UserMapper 接口

public interface UserMapper {
	public List<User> findAllWithRole2();
}

b.UserMapper.xml 映射

<resultMap id="userRoleMap2" type="com.lagou.domain.User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>
        <collection property="roleList" ofType="com.lagou.domain.Role" column="id" select="com.lagou.mapper.RoleMapper.findByUid"></collection>
    </resultMap>
    <select id="findAllWithRole2" resultMap="userRoleMap2">
        select * from user
    </select>

c.RoleMapper 接口

public interface RoleMapper {
	public List<Role> findByUid(Integer uid);
}

d.RoleMapper.xml 映射

<select id="findByUid" resultType="com.lagou.domain.Role" parameterType="int">
        select * from sys_role r inner join sys_user_role ur on ur.roleid = r.id where ur.userid = #{uid}
</select>

e.测试代码

@Test
    public void test6() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.findAllWithRole2();
        for (User user : users) {
            System.out.println(user);
        }
        sqlSession.close();
    }

5.小结

一对一配置：使用< resultMap >+< association >做配置，通过column 条件，执行 select 查询
一对多配置：使用< resultMap >+< collection >做配置，通过column 条件，执行 select 查询
多对多配置：使用< resultMap >+< collection >做配置，通过column 条件，执行 select 查询
优点：简化多表查询操作
缺点：执行多次sql 语句，浪费数据库性能

十四、MyBatis加载策略

1.什么是延迟加载？

问题
通过前面的学习，我们已经掌握了Mybatis中一对一，一对多，多对多关系的配置及实现，可以实现对象的关联查询。实际开发过程中很多时候我们并不需要总是在加载用户信息时就一定要加载他的订单信息。此时就是我们所说的延迟加载。
举个例子

• 在一对多中，当我们有一个用户，它有个100个订单
  在查询用户的时候，要不要把关联的订单查出来？
  在查询订单的时候，要不要把关联的用户查出来？
• 回答
  在查询用户时，用户下的订单应该是，什么时候用，什么时候查询。
  在查询订单时，订单所属的用户信息应该是随着订单一起查询出来。

延迟加载
就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载。

• 优点：
  先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。
• 缺点：
  因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。
• 在多表中：
  一对多，多对多：通常情况下采用延迟加载
  一对一（多对一）：通常情况下采用立即加载
• 注意：
  延迟加载是基于嵌套查询来实现的

2.实现

①局部延迟加载

在association和collection标签中都有一个fetchType属性,通过修改它的值,可以修改局部的加载策略。

<resultMap id="orderMap" type="com.lagou.domain.User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>
        <!--
            fetchType="lazy" :延迟加载策略
            fetchType="eager":立即加载策略
        -->
        <collection property="ordersList" ofType="com.lagou.domain.Orders" select="com.lagou.mapper.OrderMapper.findByUid" column="id" fetchType="lazy"></collection>
    </resultMap>
    <select id="findAllWithOrder2" resultMap="orderMap">
        select * from user
    </select>

②设置触发延迟加载的方法

大家在配置了延迟加载策略后，发现即使没有调用关联对象的任何方法，但是在你调用当前对象的equals、clone、hashCode、toString方法时也会触发关联对象的查询。
我们可以在配置文件中使用lazyLoadTriggerMethods配置项覆盖掉上面四个方法。

<settings>
	<!--所有方法都会延迟加载-->
	<setting name="lazyLoadTriggerMethods" value="toString()"/>
</settings>

③全局延迟加载

在Mybatis的核心配置文件中可以使用setting标签修改全局的加载策略。

<settings>
	<!--开启全局延迟加载功能-->
	<setting name="lazyLoadingEnabled" value="true"/>
</settings>

注意
局部的加载策略优先级高于全局的加载策略。

<resultMap id="orderMap" type="com.lagou.domain.User">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="birthday" column="birthday"/>
        <result property="sex" column="sex"/>
        <result property="address" column="address"/>
        <!--
            fetchType="lazy" :延迟加载策略
            fetchType="eager":立即加载策略
        -->
        <collection property="ordersList" ofType="com.lagou.domain.Orders" select="com.lagou.mapper.OrderMapper.findByUid" column="id" fetchType="eager"></collection>
    </resultMap>
    <select id="findAllWithOrder2" resultMap="orderMap">
        select * from user
    </select>

十五、MyBatis缓存

1.为什么使用缓存？

当用户频繁查询某些固定的数据时,第一次将这些数据从数据库中查询出来,保存在缓存中。当用户再次查询这些数据时,不用再通过数据库查询,而是去缓存里面查询。减少网络连接和数据库查询带来的损耗,从而提高我们的查询效率,减少高并发访问带来的系统性能问题。
一句话概括： 经常查询一些不经常发生变化的数据，使用缓存来提高查询效率。
像大多数的持久化框架一样，Mybatis也提供了缓存策略，通过缓存策略来减少数据库的查询次数，从而提高性能。 Mybatis中缓存分为一级缓存，二级缓存。

2.一级缓存

①介绍

一级缓存是SqlSession级别的缓存，是默认开启的
所以在参数和SQL完全一样的情况下，我们使用同一个SqlSession对象调用一个Mapper方法，往往只执行一次SQL，因为使用SelSession第一次查询后，MyBatis会将其放在缓存中，以后再查询的时候，如果没有声明需要刷新，并且缓存没有超时的情况下，SqlSession都会取出当前缓存的数据，而不会再次发送SQL到数据库。

②验证

@Test
    public void testOneCache() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //根据id查询用户信息
        //第一次查询数据库
        User user1 = userMapper.findById(1);
        System.out.println(user1);
        //clearCache:手动清空缓存
        //sqlSession.clearCache();
        //第二次查询一级缓存
        User user2 = userMapper.findById(1);
        System.out.println(user2);
        sqlSession.close();
    }

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

③分析

一级缓存是SqlSession范围的缓存，执行SqlSession的C（增加）U（更新）D（删除）操作，或者调
用clearCache()、commit()、close()方法，都会清空缓存。

1. 第一次发起查询用户id为41的用户信息，先去找缓存中是否有id为41的用户信息，如果没有，从数据库查询用户信息。
2. 得到用户信息，将用户信息存储到一级缓存中。
3. 如果sqlSession去执行commit操作（执行插入、更新、删除），清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。
4. 第二次发起查询用户id为41的用户信息，先去找缓存中是否有id为41的用户信息，缓存中有，直接从缓存中获取用户信息

④清除

@Test
public void testClearOneCache() throws Exception {
	SqlSession sqlSession = MybatisUtils.openSession();
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
	User user1 = userMapper.findById(41);
	System.out.println("第一次查询的用户：" + user1);
	//调用sqlSession清除缓存的方法
	sqlSession.clearCache();
	User user2 = userMapper.findById(41);
	System.out.println("第二次查询的用户：" + user2);
}

<!-- 每次查询时，都会清除缓存 -->
< select flushCache="true"></select>

3.二级缓存

①介绍

二级缓存是namspace级别（跨sqlSession）的缓存，是默认不开启的
二级缓存的开启需要进行配置，实现二级缓存的时候，MyBatis要求返回的POJO必须是可序列化的。也就是要求实现Serializable接口，配置方法很简单，只需要在映射XML文件配置 < cache /> 就可以开启二级缓存了。

②验证

a.配置核心配置文件

<settings>
	<!--
		因为cacheEnabled的取值默认就为true，所以这一步可以省略不配置。
		为true代表开启二级缓存；为false代表不开启二级缓存。
	-->
	<setting name="cacheEnabled" value="true"/>
</settings>

b.配置UserMapper.xml映射

<mapper namespace="com.lagou.dao.UserMapper">
	<!--当前映射文件开启二级缓存-->
	<cache></cache>
	<!--
		<select>标签中设置useCache=”true”代表当前这个statement要使用二级缓存。
		如果不使用二级缓存可以设置为false
		注意：
		针对每次查询都需要最新的数据sql，要设置成useCache="false"，禁用二级缓存。
	-->
	<select id="findById" parameterType="int" resultType="user" useCache="true">
		SELECT * FROM `user` where id = #{id}
	</select>
</mapper>

c.修改User实体

public class User implements Serializable {
	private Integer id;
	private String username;
	private Date birthday;
	private String sex;
	private String address;
	private List<Role> roleList;
	private List<Order> orderList;
}

d.测试结果

@Test
    public void testTwoCache() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession1 = sqlSessionFactory.openSession();
        UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
        //第一次查询
        User user1 = userMapper1.findById(1);
        System.out.println(user1);
        //只有执行sqlSession.commit或者sqlSession.close那么一级缓存中的内容才会刷新到二级缓存中
        sqlSession1.close();
        SqlSession sqlSession2 = sqlSessionFactory.openSession();
        UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
        User user2 = userMapper2.findById(1);
        System.out.println(user2);
        sqlSession2.close();
    }

③分析

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

1. 映射语句文件中的所有select语句将会被缓存。
2. 映射语句文件中的所有insert、update和delete语句会刷新缓存。

④.注意问题（脏读）

mybatis的二级缓存因为是namespace级别，所以在进行多表查询时会产生脏读问题

4.小结

1. mybatis的缓存，都不需要我们手动存储和获取数据。mybatis自动维护的。
2. mybatis开启了二级缓存后，那么查询顺序：二级缓存 —> 一级缓存 —> 数据库
3. 注意：mybatis的二级缓存会存在脏读问题，需要使用第三方的缓存技术解决问题。

十六、MyBatis注解

1.MyBatis常用注解

这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper映射文件了。我们先围绕一些基本的CRUD来学习，再学习复杂映射多表操作。

@Insert：实现新增，代替了<insert></insert>
@Delete：实现删除，代替了<delete></delete>
@Update：实现更新，代替了<update></update>
@Select：实现查询，代替了<select></select>

@Result：实现结果集封装，代替了<result></result>
@Results：可以与@Result 一起使用，封装多个结果集，代替了<resultMap></resultMap>
@One：实现一对一结果集封装，代替了<association></association>
@Many：实现一对多结果集封装，代替了<collection></collection>

2.MyBatis注解的增删改查

①创建UserMapper接口

public interface UserMapper {

    //查询所有用户
    @Select("select * from user")
    public List<User> findAll();

    //添加用户
    @Insert("INSERT INTO user(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})")
    public void save(User user);

    //更新用户
    @Update("UPDATE user SET username = #{username},birthday = #{birthday},sex = #{sex},address = #{address} WHERE id = #{id}")
    public void update(User user);

    //删除用户
    @Delete("DELETE FROM user where id = #{id}")
    public void delete(Integer id);

}

②编写核心配置文件

<!--方式1-->
<!--我们使用了注解替代的映射文件，所以我们只需要加载使用了注解的Mapper接口即可-->
<mappers>
	<!--扫描使用注解的Mapper类-->
	<mapper class="com.mybatis.mapper.UserMapper"></mapper>
</mappers>

<!--方式2-->
<!--或者指定扫描包含映射关系的接口所在的包也可以-->
<mappers>
	<!--扫描使用注解的Mapper类所在的包-->
	<package name="com.lagou.mapper"></package>
</mappers>

③测试代码

public class MybatisTest {

    private InputStream resourceAsStream;
    private SqlSessionFactory sqlSessionFactory;
    private SqlSession sqlSession;

    //在@Test方法标注的方法之前来执行
    @Before
    public void before() throws IOException {
        resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        sqlSession = sqlSessionFactory.openSession();
    }

    @After
    public void after(){
        sqlSession.commit();
        sqlSession.close();
    }

    //查询
    @Test
    public void testSelect() throws IOException {
        //业务调用
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }

    //新增
    @Test
    public void testInsert() throws IOException {
        //业务调用
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setUsername("Tom");
        user.setBirthday(new Date());
        user.setSex("男");
        user.setAddress("北京");
        userMapper.save(user);
    }

    //更新
    @Test
    public void testUpdate() throws Exception {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = new User();
        user.setId(14);
        user.setUsername("Timi");
        user.setBirthday(new Date());
        user.setSex("女");
        user.setAddress("上海");
        userMapper.update(user);
    }

    //删除
    @Test
    public void testDelete() throws Exception {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        userMapper.delete(11);
    }
    
}

3.使用注解实现复杂映射开发

• 之前我们在映射文件中通过配置 < resultMap >、< association >、< collection > 来实现复杂关系映射。
• 使用注解开发后，我们可以使用 @Results、@Result，@One、@Many 注解组合完成复杂关系的配置。

4.一对一查询

①介绍

需求：查询一个订单，与此同时查询出该订单所属的用户
一对一查询语句

SELECT * FROM orders;
SELECT * FROM user WHERE id = #{订单的uid};

②代码实现

a.OrderMapper接口

public interface OrderMapper {
	@Select("select * from orders")
    //@Results代替的就是resultMap标签  id = true代表主键字段  fetchType = FetchType.EAGER设置立即查询
    @Results({
            @Result(property = "id",column = "id",id = true),
            @Result(property = "ordertime",column = "ordertime"),
            @Result(property = "total",column = "total"),
            @Result(property = "uid",column = "uid"),
            @Result(property = "user",javaType = User.class,column = "uid",one = @One(select = "com.lagou.mapper.UserMapper.findById",fetchType = FetchType.EAGER))
    })
    //查询所有订单，同时查询订单所属的用户信息
    public List<Orders> findAllWithUser();
    }

b.UserMapper接口

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

c.测试代码

	//1对1 注解查询
    @Test
    public void testOneToOne(){
        OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
        List<Orders> orders = mapper.findAllWithUser();
        for (Orders order : orders) {
            System.out.println(order);
        }
    }

5.一对多查询

①介绍

需求：查询一个用户，与此同时查询出该用户具有的订单
一对多查询语句

SELECT * FROM user;
SELECT * FROM orders where uid = #{用户id};

② 代码实现

a.UserMapper接口

public interface UserMapper {
	//查询所有用户 以及关联订单信息
    @Select("select * from user")
    @Results({
            @Result(property = "id",column = "id",id = true),
            @Result(property = "username",column = "username"),
            @Result(property = "birthday",column = "birthday"),
            @Result(property = "sex",column = "sex"),
            @Result(property = "address",column = "address"),
            @Result(property = "ordersList",javaType = List.class,column = "id",many = @Many(select = "com.lagou.mapper.OrderMapper.findOrderByUid"))
    })
    public List<User> findAllWithOrder();
}

b.OrderMapper接口

public interface OrderMapper {
	//根据用户id查询该用户所具有的订单信息
    @Select("select * from orders where uid = #{uid}")
    public List<Orders> findOrderByUid(Integer uid);
}

c.测试代码

//1对多 注解查询
    @Test
    public void testOneToMany(){
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.findAllWithOrder();
        for (User user : users) {
            System.out.println(user);
            System.out.println(user.getOrdersList());
        }
    }

6.多对多查询

①介绍

需求：查询所有用户，同时查询出该用户的所有角色
多对多查询语句

SELECT * FROM user;
SELECT * FROM role r INNER JOIN user_role ur ON r.id = ur.rid WHERE ur.uid = #{用户id};

②代码实现

a.UserMapper接口

public interface UserMapper {
	//查询所有用户以及关联的角色信息
    @Select("select * from user")
    @Results({
            @Result(property = "id",column = "id",id = true),
            @Result(property = "username",column = "username"),
            @Result(property = "birthday",column = "birthday"),
            @Result(property = "sex",column = "sex"),
            @Result(property = "address",column = "address"),
            @Result(property = "roleList",javaType = List.class,column = "id",many = @Many(select = "com.lagou.mapper.RoleMapper.findAllByUid"))
    })
    public List<User> findAllWithRole();
}

b.RoleMapper接口

public interface RoleMapper {
    @Select("select * from sys_role r inner join sys_user_role ur on r.id = ur.roleid where ur.userid = #{uid}")
    //根据用户id查询该用户所具有的角色信息
    public List<Role> findAllByUid(Integer uid);
}

c.测试代码

//多对多 注解查询
    @Test
    public void testManyToMany(){
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.findAllWithRole();
        for (User user : users) {
            System.out.println(user);
            System.out.println(user.getRoleList());
        }
    }

7.基于注解的二级缓存

①配置SqlMapConfig.xml文件开启二级缓存的支持

<settings>
	<!--
		因为cacheEnabled的取值默认就为true，所以这一步可以省略不配置。
		为true代表开启二级缓存；为false代表不开启二级缓存。
	-->
	<setting name="cacheEnabled" value="true"/>
</settings>

②在Mapper接口中使用注解配置二级缓存

@CacheNamespace //配置了二级缓存
public interface UserMapper {...}

8.注解延迟加载

不管是一对一还是一对多 ，在注解配置中都有fetchType的属性

• fetchType = FetchType.LAZY 表示懒加载
• fetchType = FetchType.EAGER 表示立即加载
• fetchType = FetchType.DEFAULT 表示使用全局配置

9.小结

• 注解开发和xml配置优劣分析
  1.注解开发和xml配置相比，从开发效率来说，注解编写更简单，效率更高。
  2.从可维护性来说，注解如果要修改，必须修改源码，会导致维护成本增加。xml维护性更强。