JAVA学习笔记—Mybatis框架基础

Mybatis基本应用

一 框架简介

1.1 三层架构

软件开发常用的架构是三层架构，之所以流行是因为有着清晰的任务划分。一般包括以下三层：
持久层：主要完成与数据库相关的操作，即对数据库的增删改查。
因为数据库访问的对象一般称为Data Access Object（简称DAO），所以有人把持久层叫做DAO层。
业务层：主要根据功能需求完成业务逻辑的定义和实现。
因为它主要是为上层提供服务的，所以有人把业务层叫做Service层或Business层。
表现层：主要完成与最终软件使用用户的交互，需要有交互界面（UI）。
因此，有人把表现层称之为web层或View层。
三层架构之间调用关系为:表现层调用业务层，业务层调用持久层。
各层之间必然要进行数据交互，我们一般使用java实体对象来传递数据。

1.2 框架

1.2.1 什么是框架？

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

1.2.2 为什么使用框架？

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

1.2.3 常见的框架

Java世界中的框架非常的多，每一个框架都是为了解决某一部分或某些问题而存在的。下面列出在目前企业中
流行的几种框架（一定要注意他们是用来解决哪一层问题的）：
持久层框架：专注于解决数据持久化的框架。常用的有mybatis、hibernate、spring jdbc等等。
表现层框架：专注于解决与用户交互的框架。常见的有struts2、spring mvc等等。

二 Mybatis简介

2.1 原始jdbc操作的分析

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

2.2 Mybatis简介

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

2.3 ORM思想

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

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

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

三 Mybatis快速入门

3.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.释放资源

3.2 代码实现

1. 创建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,'子
慕','2020-11-11 00:00:00','男','北京海淀'),(2,'应颠','2020-12-12 00:00:00','男','北
京海淀');

2. 导入MyBatis的坐标和其他相关坐标

<properties>
<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
<maven.compiler.encoding>UTF-8maven.compiler.encoding>
<java.version>1.11java.version>
<maven.compiler.source>1.11maven.compiler.source>
<maven.compiler.target>1.11maven.compiler.target>
properties>

<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.4version>
dependency>

<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.6version>
<scope>runtimescope>
dependency>

<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
<scope>testscope>
dependency>

3. 编写User实体

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

4. 编写UserMapper映射文件

    
    
    	select * from user
	

5. 编写MyBatis核心文件

<configuration>

<environments default="mysql">

<environment id="mysql">

<transactionManager type="JDBC">transactionManager>

<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver">
property>
<property name="url" value="jdbc:mysql:///mybatis_db">
property>
<property name="username" value="root">property>
<property name="password" value="root">property>
dataSource>
environment>
environments>

<mappers>
<mapper resource="com/lagou/mapper/UserMapper.xml">mapper>
mappers>
configuration>

6. 编写测试类

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

四 Mybatis映射文件概述

五 Mybatis增删改查

5.1 新增

1）编写映射文件UserMapper.xml

<insert id="save" parameterType="com.lagou.domain.User">
    insert into user(username,birthday,sex,address)
    values(#{username},#{birthday},#{sex},#{address})
insert>	

2）编写测试类

@Test
public void testSave() throws Exception {
    // 加载核心配置文件
    InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
    // 获取SqlSessionFactory工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    // 获取SqlSession会话对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    // 执行sql
    User user = new User();
    user.setUsername("jack");
    user.setBirthday(new Date());
    user.setSex("男");
    user.setAddress("北京海淀");
    sqlSession.insert("UserMapper.save", user);
    // DML语句，手动提交事务
    sqlSession.commit();
    // 释放资源
    sqlSession.close();
}

3）新增注意事项

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

5.2 修改
1）编写映射文件UserMapper.xml

<update id="update" parameterType="com.lagou.domain.User">
    update user set username = #{username},birthday = #{birthday},
    sex = #{sex},address = #{address} where id = #{id}
update>

2）编写测试类

@Test
public void testUpdate() throws Exception {
    // 加载核心配置文件
    InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
    // 获取SqlSessionFactory工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    // 获取SqlSession会话对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    // 执行sql
    User user = new User();
    user.setId(4);
    user.setUsername("lucy");
    user.setBirthday(new Date());
    user.setSex("女");
    user.setAddress("北京朝阳");
    sqlSession.update("UserMapper.update", user);
    // DML语句，手动提交事务
    sqlSession.commit();
    // 释放资源
    sqlSession.close();
}

5.3 删除
1）编写映射文件UserMapper.xml

<delete id="delete" parameterType="java.lang.Integer">
    delete from user where id = #{id}
delete>

2）编写测试类

@Test
public void testDelete() throws Exception {
// 加载核心配置文件
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
// 获取SqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
// 获取SqlSession会话对象
SqlSession sqlSession = sqlSessionFactory.openSession();
// 执行sql
sqlSession.delete("UserMapper.delete", 50);
// DML语句，手动提交事务
sqlSession.commit();
// 释放资源
sqlSession.close();
}

六 Mybatis核心文件概述

6.1 MyBatis核心配置文件层级关系

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

6.2 MyBatis常用配置解析

1. environments标签
   数据库环境的配置，支持多环境配置

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

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

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

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

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

1. 使用相对于类路径的资源引用，例如：

2. 使用完全限定资源定位符（URL），例如：

《下面两种mapper代理开发中使用:暂时了解》
3. 使用映射器接口实现类的完全限定类名，例如：

4. 将包内的映射器接口实现全部注册为映射器，例如：

6.3 知识小结

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

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

typeAliases标签：设置类型别名

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

mappers标签：加载映射配置

<mapper resource="com/lagou/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概述

7.1 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 中加载资源文件。

7.2 SqlSession工厂对象SqlSessionFactory

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

7.3 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()

7.4 Mybatis基本原理介绍

八 Mybatis的dao层开发使用

8.1 代理开发方式

1）介绍
采用 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接口实现类方法。
2）编写UserMapper接口

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

3）编写UserMapper.xml

<mapper namespace="com.lagou.mapper.UserMapper">

<select id="findAll" resultType="user">
select * from user
select>
mapper>

4）测试

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

5）Mybatis基于接口代理方式的内部执行原理
我们的持久层现在只有一个接口，而接口是不实际干活的，那么是谁在做查询的实际工作呢？
下面通过追踪源码看一下：
1、通过追踪源码我们会发现，我们使用的mapper实际上是一个代理对象,是由MapperProxy代理产生的。

2、追踪MapperProxy的invoke方法会发现，其最终调用了mapperMethod.execute(sqlSession, args)

3、进入execute方法会发现，最终工作的还是sqlSession

Mybatis复杂映射&配置文件深入

一 Mybatis高级查询

1.1 ResutlMap属性

建立对象关系映射

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

1. 编写UserMapper接口

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

2. 编写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>

3）代码测试

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

1.2 多条件查询（三种）

需求
根据id和username查询user表
1）方式一
使用 #{arg0}-#{argn} 或者 #{param1}-#{paramn} 获取参数
UserMapper接口

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

UserMapper.xml

<mapper namespace="com.lagou.mapper.UserMapper">
<select id="findByIdAndUsername1" resultType="user">

select * from user where id = #{param1} and username = #{param2}
select>
mapper>

测试

@Test
public void testFindByIdAndUsername() throws Exception {
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<User> list = userMapper.findByIdAndUsername1(1 , "子慕");
    System.out.println(list);
}

2）方式二
使用注解，引入 @Param() 注解获取参数
UserMapper接口

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

UserMapper.xml

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

测试

@Test
public void testFindByIdAndUsername() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> list = userMapper.findByIdAndUsername2(1, "子慕");
System.out.println(list);
}

3）方式三（推荐）
使用pojo对象传递参数

UserMapper接口

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

UserMapper.xml

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

测试

@Test
public void testFindByIdAndUsername() throws Exception {
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User param = new User();
    param.setId(1);
    param.setUsername("子慕");
    List<User> list = userMapper.findByIdAndUsername3(param);
    System.out.println(list);
}

1.3 模糊查询

需求
根据username模糊查询user表
1）方式一
UserMapper接口

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

UserMapper.xml

<mapper namespace="com.lagou.mapper.UserMapper">
<select id="findByUsername1" parameterType="string" resultType="user">
select * from user where username like #{username}
select>
mapper>

测试

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

2）方式二
UserMapper接口

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

UserMapper.xml

<mapper namespace="com.lagou.mapper.UserMapper">

<select id="findByUsername2" parameterType="string" resultType="user">
select * from user where username like '${value}'
select>
mapper>

测试

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

3） ${} 与 #{} 区别【笔试题】
#{} :表示一个占位符号
通过 #{} 可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。
#{} 可以接收简单类型值或pojo属性值。
如果parameterType传输单个简单类型值， #{} 括号中名称随便写。
${} :表示拼接sql串
通过 ${} 可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换，会出现sql注入问题。
${} 可以接收简单类型值或pojo属性值。
如果parameterType传输单个简单类型值， ${} 括号中只能是value。

二 Mybatis映射文件深入

2.1 返回主键

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

2.1.1 useGeneratedKeys

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

<insert id="save" parameterType="user" useGeneratedKeys="true" keyProperty="id">
INSERT INTO `user`(username,birthday,sex,address)
values(#{username},#{birthday},#{sex},#{address})
insert>

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

2.1.2 selectKey

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

<insert id="save" 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 testSave() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
User user = new User();
user.setUsername("子慕");
user.setAddress("北京");
user.setBirthday(new Date());
user.setSex("男");
userMapper.save(user);
System.out.println("返回主键:" + user.getId());
}

2.2 动态SQL

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

2.2.1 动态 SQL 之’’

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

public List<User> findByIdAndUsernameIf(User user);

b）UserMapper.xml映射

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

2.2.2 动态 SQL 之’’

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

public void updateIf(User user);

b）UserMapper.xml映射

<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(1);
user.setUsername("小二王");
user.setSex("女");
userMapper.updateIf(user);
}

2.2.3 动态 SQL 之’’

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

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

a）集合
UserMapper接口

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

UserMaper.xml映射

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

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

2.3 SQL片段

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

<sql id="selectUser">
SELECT * FROM `user`
sql>
<select id="findByList" parameterType="list" resultType="user" >

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

<include refid="selectUser">include>
<where>
<foreach collection="array" open="id in(" close=")" item="id"
separator=",">
#{id}
foreach>
where>
select>

三 Mybatis核心配置文件深入

3.1 plugins标签

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

①导入通用PageHelper坐标

<dependency>
<groupId>com.github.pagehelpergroupId>
<artifactId>pagehelperartifactId>
<version>3.7.5version>
dependency>
<dependency>
<groupId>com.github.jsqlparsergroupId>
<artifactId>jsqlparserartifactId>
<version>0.9.1version>
dependency>

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

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

3.2 知识小结

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

四 Mybatis多表查询

4.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 `sys_role`
(`id`),
CONSTRAINT `sys_user_role_ibfk_2` FOREIGN KEY (`roleid`) REFERENCES `user`
(`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');

4.2 一对一（多对一）

4.2.1 介绍

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

一对一查询语句

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

4.2.2 代码实现

1 ）Order实体

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

2 ）OrderMapper接口

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

3 ）OrderMapper.xml映射

<resultMap id="orderMap" type="com.lagou.domain.Order">
<id column="id" property="id"></id>
<result column="ordertime" property="ordertime"></result>
<result column="money" property="money"></result>
<!--
一对一（多对一）使用association标签关联
property="user" 封装实体的属性名
javaType="user" 封装实体的属性类型
-->
<association property="user" javaType="com.lagou.domain.User">
<id column="uid" property="id"></id>
<result column="username" property="username"></result>
<result column="birthday" property="birthday"></result>
<result column="sex" property="sex"></result>
<result column="address" property="address"></result>
</association>
</resultMap>

4 ）测试代码

@Test
public void testOrderWithUser() throws Exception {
OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
List<Order> list = orderMapper.findAllWithUser();
for (Order order : list) {
System.out.println(order);
}
}

4.3 一对多

4.3.1 介绍

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

一对多查询语句

SELECT *,o.id oid FROM USER u LEFT JOIN orders o ON u.`id` = o.`uid`;

4.3.2 代码实现

1 ）User实体

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

2 ）UserMapper接口

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

3 ）UserMapper.xml映射

<resultMap id="userMap" type="com.lagou.domain.User">
<id column="id" property="id">id>
<result column="username" property="username">result>
<result column="birthday" property="birthday">result>
<result column="sex" property="sex">result>
<result column="address" property="address">result>

<collection property="orderList" ofType="com.lagou.domain.Order">
<id column="oid" property="id">id>
<result column="ordertime" property="ordertime">result>
<result column="money" property="money">result>
collection>
resultMap>
<select id="findAllWithOrder" resultMap="userMap">
SELECT *,o.id oid FROM USER u LEFT JOIN orders o ON u.`id`=o.`uid`;
select>

4 ）测试代码

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

4.4 多对多

4.4.1 介绍

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

多对多查询语句

SELECT
*
FROM
USER u -- 用户表
LEFT JOIN user_role ur -- 左外连接中间表
ON u.`id` = ur.`uid`
LEFT JOIN role r -- 左外连接中间表
ON ur.`rid` = r.`id` ;

4.4.2 代码实现

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

2 ）UserMapper接口

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

3 ）UserMapper.xml映射

<resultMap id="userAndRoleMap" type="com.lagou.domain.User">
<id column="id" property="id">id>
<result column="username" property="username">result>
<result column="birthday" property="birthday">result>
<result column="sex" property="sex">result>
<result column="address" property="address">result>
<collection property="orderList" ofType="com.lagou.domain.Role">
<id column="rid" property="id">id>
<result column="role_name" property="roleName">result>
<result column="role_desc" property="roleDesc">result>
collection>
resultMap>
<select id="findAllWithRole" resultMap="userAndRoleMap">
SELECT * FROM USER u LEFT JOIN user_role ur ON u.`id`=ur.`uid` INNER JOIN
role r ON ur.`rid` = r.`id`;
select>

4 ）测试代码

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

4.5 小结

MyBatis多表配置方式

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

五 MyBatis嵌套查询

5.1 什么是嵌套查询

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

* 需求：查询一个订单，与此同时查询出该订单所属的用户
1. 联合查询
SELECT * FROM orders o LEFT JOIN USER u ON o.`uid`=u.`id`;
2. 嵌套查询
2.1 先查询订单
SELECT * FROM orders
2.2 再根据订单uid外键，查询用户
SELECT * FROM `user` WHERE id = #{根据订单查询的uid}
2.3 最后使用mybatis，将以上二步嵌套起来
...

5.2 一对一嵌套查询

5.2.1 介绍

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

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

5.2.2 代码实现

1）OrderMapper接口

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

2）OrderMapper.xml映射

<resultMap id="orderMap" type="order">
<id column="id" property="id">id>
<result column="ordertime" property="ordertime">result>
<result column="money" property="money">result>

<association property="user" javaType="user" column="uid"
select="com.lagou.mapper.UserMapper.findById">association>
resultMap>
<select id="findAllWithUser" resultMap="orderMap" >
SELECT * FROM orders
select>

3）UserMapper接口

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

4）UserMapper.xml映射

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

5）测试代码

@Test
public void testOrderWithUser() throws Exception {
    OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
    List<Order> list = orderMapper.findAllWithUser();
    for (Order order : list) {
    System.out.println(order);
    }
}

5.3 一对多嵌套查询

5.3.1 介绍

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

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

5.3.2 代码实现

a）UserMapper接口

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

b）UserMapper.xml映射

<resultMap id="userMap" type="user">
<id column="id" property="id">id>
<result column="username" property="username">result>
<result column="birthday" property="birthday">result>
<result column="sex" property="sex">result>
<result column="address" property="address">result>

<collection property="orderList" column="id" ofType="order"
select="com.lagou.mapper.OrderMapper.findByUid">collection>
resultMap>
<select id="findAllWithOrder" resultMap="userMap">
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 testUserWithOrder() throws Exception {
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> list = userMapper.findAllWithOrder();
for (User user : list) {
System.out.println(user);
}
}

5.4 多对多嵌套查询

5.4.1 介绍

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

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

5.4.2 代码实现

a）UserMapper接口

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

b）UserMapper.xml映射

<resultMap id="userAndRoleMap" type="user">
<id column="id" property="id">id>
<result column="username" property="username">result>
<result column="birthday" property="birthday">result>
<result column="sex" property="sex">result>
<result column="adress" property="address">result>

<collection property="roleList" column="id" ofType="role"
select="com.lagou.mapper.RoleMapper.findByUid">collection>
resultMap>
<select id="findAllWithRole" resultMap="userAndRoleMap">
SELECT * FROM `user`
select>

c）RoleMapper接口

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

d）RoleMapper.xml映射

<select id="findByUid" parameterType="int" resultType="role">
SELECT r.id,r.`role_name` roleName,r.`role_desc` roleDesc FROM role r
INNER JOIN user_role ur ON r.`id` = ur.`rid` WHERE ur.`uid` = #{uid}
select>

e）测试代码

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

Mybatis加载策略及注解开发

一 MyBatis加载策略

1.1 什么是延迟加载？

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

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

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

1.2 实现

1.2.1 局部延迟加载

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

<resultMap id="userMap" type="user">
<id column="id" property="id">id>
<result column="username" property="username">result>
<result column="password" property="password">result>
<result column="birthday" property="birthday">result>

<collection property="orderList" ofType="order" column="id"
select="com.lagou.dao.OrderMapper.findByUid" fetchType="lazy">
collection>
resultMap>
<select id="findAll" resultMap="userMap">
SELECT * FROM `user`
select>

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

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

<settings>

<setting name="lazyLoadTriggerMethods" value="toString()"/>
settings>

1.2.3 全局延迟加载

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

<settings>

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

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

<resultMap id="orderMap" type="order">
<id column="id" property="id">id>
<result column="ordertime" property="ordertime">result>
<result column="total" property="total">result>

<association property="user" column="uid" javaType="user"
select="com.lagou.dao.UserMapper.findById" fetchType="eager">
association>
resultMap>
<select id="findAll" resultMap="orderMap">
SELECT * from orders
select>

二 MyBatis缓存

2.1 为什么使用缓存？

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

2.2 一级缓存

2.2.1 介绍

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

2.2.3 分析

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

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

2.2.4 清除

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

2.3 二级缓存

2.3.1 介绍

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

2.3.2 验证

a）配置核心配置文件

<settings>

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

b）配置UserMapper.xml映射

<mapper namespace="com.lagou.dao.UserMapper">

<cache>cache>

<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 Exception {
    SqlSession sqlSession = MyBatisUtils.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = userMapper.findById(41);
    System.out.println("第一次查询的用户：" + user);
    sqlSession.close();
    SqlSession sqlSession1 = MyBatisUtils.openSession();
    UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
    User user1 = userMapper1.findById(41);
    System.out.println("第二次查询的用户："+user1);
    sqlSession1.close();
    }

2.3.3 分析

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

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

2.3.4 注意问题（脏读）

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

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

三 MyBatis注解

3.1 MyBatis常用注解

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

* @Insert：实现新增，代替了
* @Delete：实现删除，代替了
* @Update：实现更新，代替了
* @Select：实现查询，代替了
* @Result：实现结果集封装，代替了
* @Results：可以与@Result 一起使用，封装多个结果集，代替了
* @One：实现一对一结果集封装，代替了
* @Many：实现一对多结果集封装，代替了

3.2 MyBatis注解的增删改查

3.2.1 创建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);
}

3.2.2 编写核心配置文件

<mappers>

<mapper class="com.lagou.mapper.UserMapper">mapper>
mappers>

<mappers>

<package name="com.lagou.mapper">package>
mappers>

3.2.3 测试代码

public class TestUser extends TestBaseMapper {
// 查询
    @Test
    public void testFindAll() throws Exception {
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<User> list = userMapper.findAll();
    for (User user : list) {
    System.out.println(user);
    }
    } /
    / 添加
    @Test
    public void testSave() throws Exception {
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = new User();
    user.setUsername("于谦");
    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(49);
    user.setUsername("郭德纲");
    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(49);
    }
}

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

之前我们在映射文件中通过配置 、、 来实现复杂关系映射。

使用注解开发后，我们可以使用 @Results、@Result，@One、@Many 注解组合完成复杂关系的配置。

3.4 一对一查询

3.4.1 介绍

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

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

3.4.2 代码实现

a）OrderMapper接口

public interface OrderMapper {
    @Select("SELECT * FROM orders")
    @Results({
        @Result(id = true, column = "id", property = "id"),
        @Result(column = "ordertime", property = "ordertime"),
        @Result(column = "money", property = "money"),
        @Result(property = "user", javaType = User.class,
        column = "uid", one = @One(select =
        "com.lagou.mapper.UserMapper.findById", fetchType = FetchType.EAGER))
        })
    public List<Order> findAllWithUser();
}

b）UserMapper接口

public interface UserMapper {
@Select("SELECT * FROM `user` WHERE id = #{id}")
public User findById(Integer id);
}

c）测试代码

	@Test
    public void testOrderWithUser() throws Exception {
    OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
    List<Order> list = orderMapper.findAllWithUser();
    for (Order order : list) {
    System.out.println(order);
    }
}

3.5 一对多查询

3.5.1 介绍

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

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

3.5.2 代码实现

a）UserMapper接口

public interface UserMapper {
    @Select("SELECT * FROM `user`")
    @Results({
        @Result(id = true, column = "id", property = "id"),
        @Result(column = "brithday", property = "brithday"),
        @Result(column = "sex", property = "sex"),
        @Result(column = "address", property = "address"),
        @Result(property = "orderList", javaType = List.class,column = "id" ,many = @Many(select = "com.lagou.mapper.OrderMapper.findByUid"))
    })
    public List<User> findAllWithOrder();
}

b）OrderMapper接口

public interface OrderMapper {
@Select("SELECT * FROM orders WHERE uid = #{uid}")
public List<Order> findByUid(Integer uid);
}

c）测试代码

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

3.6 多对多查询

3.6.1 介绍

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

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

3.6.2 代码实现

a）UserMapper接口

public interface UserMapper {
    @Select("SELECT * FROM `user`")
    @Results({
        @Result(id = true, column = "id", property = "id"),
        @Result(column = "brithday", property = "brithday"),
        @Result(column = "sex", property = "sex"),
        @Result(column = "address", property = "address"),
        @Result(property = "roleList", javaType = List.class,column = "id" ,many = @Many(select = "com.lagou.mapper.RoleMapper.findByUid"))
        })
    public List<User> findAllWithRole();
}

b）RoleMapper接口

public interface RoleMapper {
@Select("SELECT * FROM role r INNER JOIN user_role ur ON r.`id` = ur.`rid`
WHERE ur.`uid` = #{uid}")
public List<Role> findByUid(Integer uid);
}

c）测试代码

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

3.7 基于注解的二级缓存

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

<settings>

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

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

@CacheNamespace
public interface UserMapper {...}

3.8 注解延迟加载

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

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

3.9 小结

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