MyBatis完整笔记（搭建环境CURD、配置解析、单表结果集映射多表查询一对多多对一、日志分页使用注解开发、动态SQL、mybatis缓存）

本文详细介绍了MyBatis的动态SQL功能，包括if、where、choose、when、otherwise标签的使用，以及一级缓存和二级缓存的概念、配置与实践。通过对查询条件的判断，动态生成SQL语句，提高代码灵活性。同时，文章还探讨了缓存的启用、配置以及在提高系统性能中的作用，包括一级缓存的生命周期和二级缓存的配置，以及如何自定义缓存策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

MyBatis

SSM框架

环境：

JDK1.8
Mysql 5.7 或者升版本
maven3.6.1或者升版本
IDEA

回顾：

JDBC
Mysql
Java基础
Maven
Junit

**框架：**配置文件的。学习框架最好的方式：看官方文档；

**Mybatis3官方开发文档：**https://mybatis.org/mybatis-3/zh/getting-started.html

1.简介

1.1 什么是MyBatis

MyBatis 是一款优秀的持久层框架
它支持自定义 SQL、存储过程以及高级映射。
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
MyBatis 可以通过简单的XML或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了[google code](https://baike.baidu.com/item/google code/2346604)，并且改名为MyBatis 。2013年11月迁移到Github。
iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAOs）

获取方式：

gitHub搜索下载 https://github.com/mybatis/mybatis-3/releases
Maven仓库 https://mvnrepository.com/search?q=mybatis

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.6</version>
</dependency>

1.2 持久化

持久化是一个动作

数据持久化

持久化就是

将程序的数据在持久状态和瞬时状态转化的过程。
内存：断电即失
持久化方式：数据库（jdbc）,io文件持久化。
生活：冷藏罐头

为什么需要持久化

有一些对象，不能让他丢掉。
内存太贵了

1.3 持久层

持久层是一个概念

Dao层，Service层， Controller层…

完成持久化工作的代码块
层界限十分明显

1.4 为什么需要Mybatis？

帮助程序员将数据存入到数据库中
方便
传统的JDBC代码太复杂了。简化，框架。自动化
不用Mybatis也可以，更容易上手。
优点：
- 简单易学
- 灵活
- 解除sql与程序代码的耦合
- 提供映射标签，支持对象与数据库的orm字段关系映射
- 提供对象关系映射标签，支持对象关系组建维护
- 提供xml标签，支持编写动态sql。

最重要的一点：是用的人多，Spring SpringMVC SpringBoot

2.第一个Mybatis程序

思路：搭建环境–>导入Mybatis包–>编写代码–>测试

项目结构：

2.1 搭建环境

创建数据库和表：

CREATE DATABASE `mybatis`
USE mybatis

CREATE TABLE `user`(
`id` INT(20) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(30) DEFAULT NULL,
`pwd` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO `user`(`name`,`pwd`)VALUES
('狂神','123456'),
('张三','123456'),
('李四','123456');

新建项目：

1.新建一个普通的maven项目

2.删除src目录，便于后面创建子模块

3.导入maven依赖

导入mysql、mabatis、junit包

在build中配置resources，来防止我们资源导出的失败的问题

在父工程的pom.xml中

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

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!--父工程-->
    <groupId>org.example</groupId>
    <artifactId>mybatis</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>simpleDemo</module>
    </modules>

    <dependencies>
    <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
    <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.3</version>
        </dependency>
    <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
    </dependencies>

    <!--在build中配置resources，来防止我们资源导出的失败的问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>


</project>

2.2 创建一个子模块

（1）编写Mybatis的核心配置文件

在resources目录下创建mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!--每一个Mapper都需要在mybatis-config.xml中注册-->
    <!--易错：分隔出采用斜杠，不是点-->
    <mappers>
        <mapper resource="com/kuang/dao/UserMapper.xml"/>
    </mappers>

</configuration>

（2）编写Mybatis工具类

获取SqlSession对象（相当于connection对象），封装成工具类。

在utils包下建立工具类MybatisUtils

package com.kuang.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;


import java.io.IOException;
import java.io.InputStream;

//工具类
//需要获得数据库操作对象SqlSession
//SqlSessionFactory---->SqlSession
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;//提升作用域

    static {
        //使用Mybatis的第一步：获取SqlSessionFactory对象
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream =Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //有了SqlSessionFactory以后，我们可以从中获得SqlSession的实例
    //SqlSession提供了在数据库执行 SQL命令 所需的所有方法。
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

（3）创建实体类

在pojo包下面创建实体类User

package com.kuang.pojo;

public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

（4）dao层：UserDao接口和UserMapper.xml

持久层操作数据库执行sql

UserDao接口，UserMapper.xml采用配置文件形式替换以前的UserDaoImpl实现类实现操作数据库

UserDao接口：

public interface UserDao {
    public List<User> getUserList();
}

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


<!--namespace=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.kuang.dao.UserDao">
    <select id="getUserList" resultType="com.kuang.pojo.User">
        select * from `user`;
    </select>
</mapper>

（5）测试

在test目录下建立对应的dao包：test/com.kuang.dao

再建立UserDaoTest类添加测试方法

1.先获取SqlSession对象

2.利用SqlSession调用Mapper得到UserDao对象

3.操作数据库，返回与实体类对应的结果

package com.kuang.dao;

import com.kuang.pojo.User;
import com.kuang.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){
        //获取SqlSession对象
        SqlSession sqlSession= MybatisUtils.getSqlSession();

        //操作数据库 方式一：getMapper 推荐使用
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();

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

        //关闭SqlSession
        sqlSession.close();
    }
}

2.3 可能会遇到的问题

1.配置文件getUserMapper.xml没有注册

每一个Mapper.xml都需要在Mybatis核心配置文件mybatis-config.xml中注册

注册的资源路径，采用斜杠，而不是点分隔

<!--每一个Mapper都需要在mybatis-config.xml中注册-->
<!--易错：分隔出采用斜杠，不是点-->
<mappers>
    <mapper resource="com/kuang/dao/UserMapper.xml"/>
</mappers>

2.Maven导出资源问题，先放到外层pom.xml，如果没生效，子模块的pom.xml再放一次

<!--在build中配置resources，来防止我们资源导出的失败的问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

3.注意Mapper.xml文件中：绑定接口、方法名、返回类型

错误：

Cause: com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceExcep

解决方法：之前在pom.xml文件中删除了下面代码，现在加上：

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

2.4 运行思路

连接数据库，导入jar包（mysql、mabatis、junit、此处还可以配置好maven的资源导出问题build)
操作数据库需要一个SqlSession对象，为此建造了一个工具类utils/MybatisUtils，编写了配置文件mybatis-config.xml（配置文件一上来连接了数据库，仅需修改选项参数；删除mapper.xml的注册配置）
创建实体类User
创建接口UserDao，并创建getUserList()抽象方法
写Mapper配置文件UserMapper.xml，代替原来实现类Impl：namespace绑定接口，标签id绑定接口方法，标签体专注sql，返回类型专注返回值类型；每一个mapper写完需要到mabatis-config.xml中去注册

3.CURD

namespace：

Mapper.xml中使用的namespace中分包名，要和Dao/Mapper接口中的包名一致。

过程：

完成MyBatis的实现后，操作数据库：

所有的操作只和“接口”和“配置文件”有关
实体类、工具类、mybatis.config.xml不在需要改变
mapper.xml只需要去mybatis.config.xml中配置一次，mapper.xml中只需要有一个<mapper>

dao层：

UserMapper接口（从UserDao改名为UserMapper）

UserMapper配置文件（相当于实体类UserMapperImpl）

Mapper.xml元素概念

id: 就是对应的nsmespace中的方法名
resultType: Sql语句执行的返回值
parameterType: 参数类型

步骤：

3.1编写接口

在UserMapper中

public interface UserMapper {
    
    //根据id查询用户
    User getUserById(int id);

    //insert用户
    int insertUser(User user);

    //修改用户
    int updateUser(User user);

    //删除用户
    int deleteUserById(int id);

}

3.2编写对应的mapper.xml中的sql语句

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


<!--namespace=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.kuang.dao.UserMapper">
    <!--根据id查询用户-->
    <select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">
        select * from `user` where `id`=#{id};
    </select>

    <!--Insert用户-->
    <insert id="insertUser" parameterType="com.kuang.pojo.User">
        insert into `user`(`name`,`pwd`) values ('zhaoliu','zhao123456');
    </insert>

    <!--修改用户-->
    <update id="updateUser" parameterType="com.kuang.pojo.User">
        update `user` set `name`=#{name},`pwd`=#{pwd} where id=#{id};
    </update>

    <!--根据id删除用户-->
    <delete id="deleteUserById" parameterType="int">
        delete from `user` where id=#{id};
    </delete>
</mapper>

3.3测试

在UserMapperTest中

public class UserMapperTest {

    //根据id查找用户
    @Test
    public void getUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class); //相当于获得实现类对象
        User user = mapper.getUserById(1);

        System.out.println(user);

        sqlSession.close();

    }
    
    //插入用户
    @Test
    public void insertUser(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        int i = mapper.insertUser(new User(0, "liu", "liu123"));
        if(i>0){
            System.out.println("插入成功");
        }

        //【关键】Mybatis中增删改查，需要提交事务才能生效
        sqlSession.commit();

        sqlSession.close();
    }

    //修改用户
    @Test
    public void updateUser(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        int i = mapper.updateUser(new User(1, "liu", "liu123"));
        if(i>0){
            System.out.println("修改成功");
        }

        //【关键】Mybatis中增删改查，需要提交事务才能生效
        sqlSession.commit();

        sqlSession.close();
    }

    //删除用户
    @Test
    public void deleteUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        int i = mapper.deleteUserById(4);
        if(i>0){
            System.out.println("删除成功");
        }

        //【关键】Mybatis中增删改查，需要提交事务才能生效
        sqlSession.commit();

        sqlSession.close();
    }
}

在Mapper.xml中，对象中的属性，可以直接取出来，与实体类对应

Mybatis增删改必须提交事务才能生效

注意SqlSession对象使用完后关闭

3.4遇到的问题

Mapper.xml的curd标签不要匹配错
Mapper.xml需要到resource中的mybatis-config.xml中注册，路径要用‘/’，前面的命名空间使用的是包名 ‘.’
```
<mappers>
    <mapper resource="com/kuang/dao/UserMapper.xml"/>
</mappers>
```
程序配置文件mybatis-config.xml必须符合规范

NullPointerException，没有注册到资源，MybatisUtils中提升作用域内外定义变量sqlSessionFactory

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;//提升作用域

    static {
        //使用Mybatis的第一步：获取SqlSessionFactory对象
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream =Resources.getResourceAsStream(resource);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //有了SqlSessionFactory以后，我们可以从中获得SqlSession的实例
    //SqlSession提供了在数据库执行 SQL命令 所需的所有方法。
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

输出的xml文件如果存在乱码，删除即可
maven资源导出问题，pom.xml中加<build>

3.5万能的Map

Mapper.xml中参数类型如果为实体类，在测试时需要初始化所有字段，传递整个实体类对象；如果sql操作只需要少量字段，则不合适；
实体类中的字段名和参数中字段名必须一致。

在接口方法中，参数直接传递实体类User；

//insert用户
int insertUser(User user);

编写sql语句的时候，需要传递参数类型，参数类型为实体类"com.kuang.pojo.User"

<!--Insert用户-->
<!--使用实体类：test中传入的“对象中的属性”必须和“数据库表中字段名”对应-->
<insert id="insertUser" parameterType="com.kuang.pojo.User">
    insert into `user`(`name`,`pwd`) values (#{name},#{pwd});
</insert>

在使用方法的时候，需要创建实体类User对象，赋值所有属性

使用实体类：test中传入的“对象中的属性”必须和“数据库表中字段名”对应

//插入用户
@Test
public void insertUser(){
    SqlSession sqlSession=MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    int i = mapper.insertUser(new User(0, "田七1", "tian123456"));
    if(i>0){
        System.out.println("插入成功");
    }

    //【关键】Mybatis中增删改查，需要提交事务才能生效
    sqlSession.commit();

    sqlSession.close();
}

考虑用map作为参数，map中的key值也可以自定义，只需要在测试类中定义相应的key值。

在接口方法中，参数直接传递Map；

//insert用户
int insertUser(User user);

编写sql语句的时候，需要传递参数类型，参数类型为Map

<!--Insert用户-->
<!--使用万能的Map：test中传入的“map的key值”可以自定义，无需和“数据库表中字段名”对应-->
<insert id="insertUser2" parameterType="map">
    insert into `user`(`name`,`pwd`) values (#{username},#{password});
</insert>

在使用方法的时候，需要创建实体类User对象，赋值所有属性

使用万能的Map：test中传入的“map的key值”可以自定义，无需和“数据库表中字段名”对应

//插入用户
@Test
public void insertUser2(){
    SqlSession sqlSession=MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    Map<String,Object> map=new HashMap<>();
    map.put("username","田七");
    map.put("password","tian123456");
    int i = mapper.insertUser2(map);
    if(i>0){
        System.out.println("插入成功");
    }

    //【关键】Mybatis中增删改查，需要提交事务才能生效
    sqlSession.commit();

    sqlSession.close();
}

传递参数类型：

对象传递参数：直接在sql中取出对象的属性（实体类定义时属性和数据库表字段名一一对应）【parameterType=“Object”】
Map传递参数：直接在sql中取出key即可，map的key值无需和数据库表字段名一致，【parameterType=“map”】
传递参数类型只有一个，且为基本类型，如int，可省略不写，直接在sql中取到。

多个参数用map，或者注解

返回结果类型：当为实体类对象时需要写，当为int时可省略。

3.6模糊查询

1.test中传递的字符串采用拼接，传递通配符%

容易造成sql注入，用户传入的值一般我们要求只能为值，不能拼接字符串

 List<User> userList = mapper.getUserLike("%李%");

2.在Mapper.xml的sql中拼接，使用通配符，推荐

select * from `user` where name like "%"#{name}"%"

4.配置解析

核心配置文件mybatis-config.xml

【注意】在mybatis-config.xml的<configuration>标签中，所有配置标签有顺序

4.1环境配置（enviroments）

MyBatis 可以配置成适应多种环境
不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

事务管理器（transactionManager）

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）：

JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。

数据源（dataSource）

是否使用连接池

Mybatis默认的事务管理器就是JDBC，连接池：POOLED

学会使用配置多套运行环境。

4.2属性（properties）

我们可以通过properties属性来实现引用配置文件。

mybatis-config.xml使用到的属性可以在外部进行配置，并可以进行动态替换:

既可以在典型的 Java 属性文件中配置这些属性【db.properties】

db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8
username=root
password=123456

mybatis-config.xml中引入配置文件并使用

<properties resource="db.properties"/>

<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="${driver}"/>
            <property name="url" value="${url}"/>
            <property name="username" value="${username}"/>
            <property name="password" value="${password}"/>
        </dataSource>
    </environment>
</environments>

也可以在 properties 元素的子元素中设置

<properties resource="db.properties">
    <property name="username" value="root"/> <!--可以动态增加属性-->
    <property name="password" value="123456"/>
</properties>

mybatis-config.xml的<dataSource>属性配置：

可以直接配置
可以全部放到db.properties中，再在mybatis-config.xml中引用
可以部分放到db.properties中，mybatis-config.xml中<properties>可以动态增加属性（如果两个文件有同一个字段，优先使用外部配置文件。properties里面的属性优先）

4.3类型别名（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。
它仅用于 XML 配置，意在降低冗余的全限定类名书写
常用于在mybatis-config.xml中，为实体类起别名，简化在Mapper.xml中对实体类引用包名的书写

（1）为具体实体类指定类型别名

<typeAliases>
    <typeAlias type="com.kuang.pojo.User" alias="User"/>
</typeAliases>

在Mapper.xml中使用

<select id="getUserList" parameterType="map" resultType="User">
    select * from `user` where `name` like "%"#{name}"%";
</select>

（2）指定一个包名

MyBatis会在包名下面搜索需要的实体类（JavaBean）

扫描实体类的包，它的默认别名就为这个类的类名，首字母小写

<typeAliases>
    <package name="com.kuang.pojo"/>
</typeAliases>

在Mapper.xml中使用

<select id="getUserList" parameterType="map" resultType="user">
    select * from `user` where `name` like "%"#{name}"%";
</select>

（3）自定义类型别名

为具体实体类指定类型别名，可以自定义包名
指定一个包名，别名默认类名，且首字母小写。但可以通过在实体类上增加注解自定义包名
```
//实体类
@Alias("user")
public class User {
    ...
}
```

4.4映射器（mapper）

MapperRegistry：每一个Mapper.xml都需要到mybatis-config.xml中的<mapper>中去配置

配置方法：

1.使用resource绑定注册

注意路径采用反斜杠分隔

<mappers>
    <mapper resource="com/kuang/dao/UserMapper.xml"/>
</mappers>

2.使用class文件绑定注册

<mappers>
    <mapper class="com.kuang.dao.UserMapper"/>
</mappers>

注意点：

接口和他的Mapper配置文件必须同名！
接口和他的Mapper配置文件必须在同一个包下！（方式一Mapper.xml随便放）

3.使用扫描包进行注册绑定

<mappers>
     <package name="com.kuang.dao"/>
</mappers>

注意点：

接口和他的Mapper配置文件必须同名！
接口和他的Mapper配置文件必须在同一个包下！（方式一随便放）

4.5设置（enviroments）

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

数据库命名与实体类字段转换，需要Mabatis框架的设置支持

4.6其他

typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
- mybatis-generator-core
- mybatis-plus
- 通用mapper

4.7生命周期和作用域

生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题

SqlSessionFactoryBuilder:

这个类可以被实例化、使用和丢弃；一旦创建了SqlSessionFactory，就不再需要它了
设为局部变量

SqlSessionFactory：

说白了就是可以想象为：数据库连接池。
一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
SqlSessionFactory 的作用域是全局作用域（应用作用域 ApplicationContext）
最简单的就是使用单例模式或者静态单例模式。

SqlSession：

连接池的一个请求。
SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的作用域是请求或方法作用域。
用完之后赶紧关闭，否则资源被占用。

这里的每一个Mapper,就代表一个具体的业务！

5.ResultMap结果集映射

要解决的问题：属性名和字段名不一致

5.1 实体类属性和数据库字段不匹配问题

数据库字段：

实体类属性：

public class User {
    private int id;
    private  String name;
    private String password; //字段和属性不一致
}

测试字段不一致问题：

Mapper.xml

<!--根据id查询用户-->
<select id="getUserById" parameterType="_int" resultType="com.kuang.pojo.User">
    select * from `user` where `id`=#{id};
</select>

查询结果：password属性为null

解决办法：

sql查询字段起别名 pwd as password

select id,name,pwd as password from mybatis.user where id = #{id}

结果集映射resultMap，属性名和字段名映射

5.2 resultMap

结果集映射

实体类User： id  name  pwd
数据库user表：id  name  password

在Mapper.xml中配置resultMap

<mapper namespace="com.kuang.dao.UserMapper">
    <!--结果集映射:可以只映射不一致的字段和属性-->
    <!--Column：数据库中的字段，properties实体类中的属性-->
    <resultMap id="UserMap" type="User">
    <!--<result column="id" property="id"/>-->
    <!--<result column="name" property="name"/>-->
        <result column="pwd" property="password"/>
    </resultMap>
    
    <select id="getUserById"  resultMap="UserMap">
        select * from mybatis.user where id = #{id}
    </select>
</mapper>

resultMap元素时MyBatis中最重要的最强大的元素。
ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
ResultMap 的优秀之处——你完全可以不用显式地配置它们，可以只映射不一致的字段和属性

6.日志

如果一个数据库操作，出现了异常，我们需要排错。日志就是最好的助手。

曾经：sout 、debug

现在：日志工厂

SLF4J
LOG4J 【掌握】
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING 【掌握】
NO_LOGGING

在mybatis-config.xml中配置<setting name="logImpl" value=""/>

在Mybatis中具体使用哪一个日志实现，在设置中设定。

6.1.STDOUT_LOGGING标准日志输出

<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

【注意】书写日志不要有空格

STDOUT_LOGGING日志只需要配置一下setting，就能使用。

6.2.LOG4J 拓展日志输出

什么是LOG4J：

Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是**控制台、文件、**GUI组件等；
我们也可以控制每一条日志的输出格式；
通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1.先导出log4j的包

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

2.在resources目录下创建log4j.properties

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/kuang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

3.配置log4j为日志实现

<settings>
    <setting name="logImpl" value="LOG4J"/>
</settings>

4.Log4j的使用，直接测试运行刚才的查询

简单实用：

1.在要使用Log4j的类中，导入包import org.apache.log4j.Logger;

2.日志对象，参数为当前类的class

3.可以设置日志级别

import org.apache.log4j.Logger; //导入包

public class log4j{
    static Logger logger=Logger.getLogger(log4j.class); //获取当前类的反射
    @Test
    public void testLog(){
        logger.info("info：进入selectUser方法");
        logger.debug("debug：进入selectUser方法");
        logger.error("error: 进入selectUser方法");

        SqlSession session= MybatisUtils.getSqlSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserList();

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

        session.close();
    }
}

7.分页

思考：为什么要分页？

减少数据的处理量

7.1 sql层面limit实现分页

1.接口

//分页查询
List<User> getUserByLimit(Map<String,Integer> map);

2.Mapper.xml

<!--结果集映射-->
<!--Column：数据库中的字段，properties实体类中的属性-->
<resultMap id="UserMap" type="User">
    <!--可以只映射不一致的字段和属性-->
    <!--<result column="id" property="id"/>-->
    <!--<result column="name" property="name"/>-->
    <result column="pwd" property="password"/>
</resultMap>

<!--分页查询-->
<select id="getUserByLimit" parameterType="map" resultMap="UserMap">
    select * from `user` limit #{startIndex},#{pageSize};
</select>

3.测试

//分页查询
@Test
public void getUserByLimit(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    Map<String,Object> map=new HashMap<>();
    map.put("startIndex",0);
    map.put("pageSize",3);

    List<User> userList = mapper.getUserByLimit(map);
    for (User user : userList) {
        System.out.println(user);
    }

    sqlSession.close();
}

7.2 使用RowBounds实现分页

1.接口

//分页查询
List<User> getUserByRowBounds();

2.Mapper.xml

<!--结果集映射-->
<!--Column：数据库中的字段，properties实体类中的属性-->
<resultMap id="UserMap" type="User">
    <!--可以只映射不一致的字段和属性-->
    <!--<result column="id" property="id"/>-->
    <!--<result column="name" property="name"/>-->
    <result column="pwd" property="password"/>
</resultMap>

<!--分页查询-->
<select id="getUserByRowBounds" parameterType="map" resultMap="UserMap">
    select * from `user` limit #{startIndex},#{pageSize};
</select>

3.测试

//RowBounds分页查询
@Test
public void getUserByRowBounds(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    int currentPage=2; //第几页
    int pageSize=2; //每页显示几个
    RowBounds rowBounds = new RowBounds((currentPage - 1) * pageSize, pageSize);

    List<User> userList = sqlSession.selectList("com.kuang.dao.UserMapper.getUserByRowBounds", null, rowBounds);
    for (User user : userList) {
        System.out.println(user);
    }

    sqlSession.close();
}

7.3 分页插件

MyBatis分页插件 PageHelper

https://pagehelper.github.io/

了解即可，万一以后公司的架构师，说要使用，你需要知道它是什么东西。

8.使用注解开发

8.1面向接口编程

大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程
根本原因 : 解耦 , 可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准 , 使得开发变得容易 , 规范性更好
在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了；
而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程

关于接口的理解：

接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
接口应有两类：
- 第一类是对一个个体的抽象，它可对应为一个抽象体（abstract class)
- 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）
一个个体可能有多个抽象面，抽象体和抽象面是有区别的。

三个“面向”区别：

面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法
面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现
接口设计与非接口设计是针对复用技术而言的，与面向对象和面向过程不是一个问题，更多的体现是对系统整体的架构

8.2利用注解开发

mybatis最初配置信息是基于XML，映射语句（SQL）也是定义在XML中的。到Mybatis3提供了新的基于注解的配置。
不幸的是，Java注解的表达力和灵活性十分有限。最强到的MyBatis映射并不能用注解来构建，所以真实项目开发尽量少用
Sql类型主要分成：
- @Select()
- @Update()
- @Insert()
- @Delete()
**利用注解开发，就不需要Mapper.xml映射文件了。**利用在Mapper接口中注解代替 Mapper.xml

1.在我们的接口中直接添加注解

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

2.记得每个Mapper都要去mybatis-config.xml核心配置文件中注册

利用mapper.xml时可以采用三种注册方式，利用注解开发只能使用class绑定接口

<mappers>
    <mapper class="com.kuang.dao.UserMapper"/>
    <!--<mapper resource="com/kuang/dao/UserMapper.xml"/>-->
    <!--<package name="com.kuang.dao"/>-->
</mappers>

3.测试

//查找所有用户
@Test
public void getUserList() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> userList = mapper.getUserList();

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

    sqlSession.close();
}

4.查看Debugben本质

在test中打断点Debug

5.本质上利用了jvm的动态代理机制

6.Mybatis详细执行流程

8.3 采用注解CURD

可以改造MybatisUtils工具类的getSession( ) 方法，开启自动提交；但是实际开发中一般不采用自动提交

public static SqlSession getSession(boolean flag){
	return sqlSessionFactory.openSession(flag);
}

UserMapper接口：

//根据id查询用户
@Select("select * from `user` where id=#{id}")
User selectUserById(@Param("id") int id);

//添加一个用户
@Insert("insert into `user`(id,name,pwd) values(#{id},#{name},#{pwd})")
int addUser(User user);

//修改用户
@Update("update user set name=#{name},pwd=#{pwd} where id=#{id}")
int updateUser(User user);

//删除用户
@Delete("delete from `user` where id=#{id}")
int deleteUser(@Param("id") int id);

测试：

//根据id查询用户
@Test
public void selectUserById() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.selectUserById(3);

    System.out.println(user);

    sqlSession.close();
}

//添加一个用户
@Test
public void addUser() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.addUser(new User(8,"zhangsan","zhang123"));

    sqlSession.commit();
    sqlSession.close();
}

//修改用户
@Test
public void updateUser() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.updateUser(new User(8,"zhangsan333","zhang123"));

    sqlSession.commit();
    sqlSession.close();
}

//删除用户
@Test
public void deleteUser() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.deleteUser(8);

    sqlSession.commit();
    sqlSession.close();
}

注意增删改需要提交事务
采用注解开发，需要确保实体类和数据库字段对应
在需要传参的情况下，接口中基本类型和String类型需要使用@Param声明，对象实体类不需要

关于@Param：

@Param注解用于给方法参数起一个名字。以下是总结的使用原则：

在方法只接受一个参数的情况下，可以不使用@Param。
在方法接受多个参数的情况下，建议一定要使用@Param注解给参数命名。
如果参数是 JavaBean ，则不能使用@Param。
不使用@Param注解时，参数只能有一个，并且是Javabean。

#{}和${}区别：

#{}的作用主要是替换预编译语句（PrepareStatement）中占位符【推荐使用】
```
INSERT INTO user (name) VALUES (#{name});
INSERT INTO user (name) VALUES (?);
```

${}的作用是直接进行字符串替换

INSERT INTO user (name) VALUES ('${name}');
INSERT INTO user (name) VALUES ('kuangshen');

8.4 Lombok注解插件

Lombok是为了偷懒，主要是自动实体类生成：无参构造和有参构造、getter和setter、toString等

优点：

能够通过注解的形式自动生成代码：构造器、getter/setter，equals,hashcode,toString等方法，提高了一定的开发效率
让代码变得简洁，不用过多的去关注相应的方法
属性做修改时，也简化了维护这些属性所生成的getter/setter方法等

缺点：

不支持多种参数构造器的重载，但可以在类中手动添加重载
虽然省去了手动创建getter/setter方法的麻烦，但大大降低了源代码的可读性和完整性，降低了阅读源代码的舒适度，公司一般不建议使用，了解即可

常用注解：

使用步骤：

1.在IDEA中安装Lombok插件，一般自动安装了，如果没有手动安装

file->setting->plugins,Marketplace，Browse repositories

2.使用lombok需要添加jar包

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>

3.实体类中直接应用

@Data //无参构造。get set toString hashcode equals
@AllArgsConstructor //有参构造
@NoArgsConstructor //无参构造
public class User {
    private int id;
    private String name;
    private String pwd;
}

9.多表查询结果集映射

问题：

需要多表查询，但是返回的结果集往往只能是一个实体类型；
数据库多表查询结果（可能多张表的字段），与实体类（可能涉及多个实体类），但是Mybatis返回结果中，只有一个returnType——结果集映射

两种情况：

student表：id，name，tid

techear表：id，name

多对一：需要查询所有学生，及其对应的老师姓名（s.id s.name t.name），主体是学生（查询结果存在多个学生对应一个老师）

查询条件是所有的学生，学生表join老师表
**一对多：**需要查询指定老师，及其所有的学生信息（s.id s.name t.name），主体是老师（一个老师对应多个学生）

查询结果是指定老师，老师表join学生表

此处把握住是**“谁是主体”+“谁连接谁”**，join后面的是一个对象（多对一），join后面是一个集合（一对多）

9.1 老师学生例子数据库表

对于学生而言：多个学生对应一个老师，association关系，多对一
对于老师而言：一个老师对应多个学生，collection关系，一对多

新建数据库表：

SQL:

CREATE TABLE `teacher` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师'); 

CREATE TABLE `student` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  `tid` INT(10) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fktid` (`tid`),
  CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');

9.2多对一

需求：

需要查询所有学生，及其对应的老师姓名（s.id s.name t.name），主体是学生（查询结果存在多个学生对应一个老师）
查询条件是所有的学生，学生表join老师表

（1）测试环境搭建

项目结构：

导入lombok

1.新建实体类

Student:

@Data
public class Student {
    private int id;
    private String name;

    //学生需要关联一个老师，此处属性为一个对象
    private Teacher teacher;
}

Teacher:

@Data
public class Teacher {
    private int id;
    private String name;

}

2.建立Mapper接口

StudentMapper:

public interface StudentMapper {
	//查找所有学生，以及每个学生对应的老师姓名
    List<Student> getStudent();

}

TeacherMapper:

public interface TeacherMapper {
	//根据id查找老师，及老师的所有学生
    Teacher getTeacher(int id);
}

3.建立Mapper.xml文件（后续改）

在Resources目录下，建立和java目录下同样的包结构com.kuang.dao，易错：resources下建包用 / 分隔，java下建包用 . 分隔

而且Mapper.xml需要和Mapper同名

StudentMapper.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.kuang.dao.StudentMapper">
    
</mapper>

TeacherMapper.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.kuang.dao.TeacherMapper">

</mapper>

5.在核心配置文件中绑定注册Mapper接口或者Mapper.xml或者包

<mappers>
    <mapper class="com.kuang.dao.TeacherMapper"/>
    <mapper class="com.kuang.dao.StudentMapper"/>
</mappers>

6.测试是否能够查询成功（后续改）

（2）按照结果嵌套处理（类连接查询、重点）

查询主体是学生

StudentMapper.xml：

<select id="getStudent" resultMap="StudentTeacher">
    select s.id sid,s.name sname,t.name tname
    from student s,teacher t
    where s.tid = t.id;
</select>

<!--查询主体是学生，学生表join老师表-->
<resultMap id="StudentTeacher" type="Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    
    <!--在学生实体类中，Teacher属性是一个对象-->
    <association property="teacher" javaType="Teacher"> 
        <result property="name" column="tname"/>
    </association>
</resultMap>

先通过sql查询出结果，再 “sql结果字段” 与“实体类对象属性” 映射

测试：

@Test
public void testStudent(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(StudentMapper.class);
    
    List<Student> studentList = mapper.getStudent();
    for (Student student : studentList) {
        System.out.println(student);
    }
    sqlSession.close();
}

（3）按照查询嵌套处理（类子查询）

查询主体是学生

StudentMapper.xml：

<mapper namespace="com.kuang.dao.StudentMapper">
<!--
思路：
1.查询所有学生的信息
2.根据查询出来的学生的tid，寻找对应的老师
--> 
    
    <!--查询主体是学生，学生表join老师表-->
    <select id="getStudent" resultMap="StudentTeacher">
        select * from student
    </select>
    
    <resultMap id="StudentTeacher" type="Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <!--复杂的属性，我们需要单独处理  
		对象association  集合：collection
        javaType="" 指定属性的类型
        集合中的泛型信息，我们使用ofType获取（一对多采用）
        -->
        
        <!--在学生实体类中，Teacher属性是一个对象-->
        <association property="teacher" javaType="Teacher" select="getTeacher" column="tid"  />
    </resultMap>

    
    <select id="getTeacher" resultType="Teacher">
        select * from teacher where id = #{id}
    </select>
</mapper>

测试：

@Test
public void testStudent(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(StudentMapper.class);
    
    List<Student> studentList = mapper.getStudent();
    for (Student student : studentList) {
        System.out.println(student);
    }
    sqlSession.close();
}

9.3一对多

需求：

需要查询指定老师，及其所有的学生信息（s.id s.name t.name），主体是老师（一个老师对应多个学生）
查询结果是指定老师，老师表join学生表

（1）测试环境搭建

实体类：

Student:

@Data
public class Student {
    private int id;
    private String name;
    private int tid;

}

Teacher:

@Data
public class Teacher {
    private int id;
    private String name;

    //一个老师拥有多个学生,此处属性为一个List
    private List<Student> students;
}

（2）按照结果嵌套处理（类连接查询、重点）

查询主体是老师

TeacherMapper.xml：

<select id="getTeacher" resultMap="TeacherStudent">
    select s.id sid,s.name sname,t.name tname,t.id tid
    from teacher t
    	inner join student s
    		on t.id=s.tid
    where t.id=#{id}
</select>

<!--查询主体是老师，老师表join学生表-->
<resultMap id="TeacherStudent" type="Teacher">
    <result property="id" column="tid"/>
    <result property="name" column="tname"/>
        
     <!--在Teacher实体类中，Student属性是一个List，泛型需要指明类型-->
    <collection property="students" javaType="ArrayList" ofType="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="tid" column="tid"/>
    </collection>
</resultMap>

先通过sql查询出结果，再 “sql结果字段” 与“实体类对象属性” 一一映射

测试：

public class TeacherMapperTest {
    @Test
    public void getTeacher(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);

        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);

        sqlSession.close();
    }
}

（3）按照查询嵌套处理（类子查询）

查询主体是老师

TeacherMapper.xml：

<select id="getTeacher" resultMap="TeacherStudent">
    select * from `teacher` where id=#{id}
</select>

<resultMap id="TeacherStudent" type="Teacher">
    <collection property="students" javaType="ArrayList" ofType="Student"
                select="getStudent" column="id"/>
</resultMap>

<select id="getStudent" resultType="Student">
    select * from `student` where tid=#{id};
</select>

测试：

public class TeacherMapperTest {
    @Test
    public void getTeacher(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);

        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);

        sqlSession.close();
    }
}

小结：

关联 association，多对一
集合 collection，一对多
javaType 和 ofType
- javaType 用来制定实体类中属性的类型
- ofType用来指定映射到List（或者集合）中的pojo类型，泛型中的约束类

注意点：

保证SQL的可读性，尽量保证通俗易懂
注意一对多和多对一中属性名和字段的问题
如果问题不好排查错误，可以使用日志，建议使用Log4j

面试高频：

MySQL引擎
InnoDB底层原理
索引
索引优化

10.动态SQL

10.1简介

什么是动态SQL：

动态SQL是指根据==不同的查询条件，拼接生成不同的Sql语句==

简介：

MyBatis 的强大特性之一便是它的动态 SQL
如果你有使用 JDBC 或其它类似框架的经验，你就能体会到根据不同条件拼接 SQL 语句的痛苦：
- 拼接是要确保不能忘记添加必要的空格
- 第一个查询条件不要and where id=1 and name=“zhangsan” and password=“123456”
- 去掉列名最后一个列名的逗号 insert into user(id,name,value) values(1,”zhangsna”,”123456) update user set name=”zhangsan2”,password=”123” where id=1
动态sql元素和 JSTL标签类似；
复杂的SQL语句，往往需要拼接。而拼接SQL稍微不注意，由于引号，空格等的缺失可能都会导致错误。

解决办法：

使用MyBatis的动态SQL，通过if where,set,trim foreach choose,when,otherwise等标签，可以组合成非常灵活的SQL语句，从而在提高SQL语句的准确性的同时，也大大提高了开发人员的效率。

10.2搭建环境

新建一个数据库表：blog

CREATE TABLE `blog` (
`id` varchar(50) NOT NULL COMMENT '博客id',
`title` varchar(100) NOT NULL COMMENT '博客标题',
`author` varchar(30) NOT NULL COMMENT '博客作者',
`create_time` datetime NOT NULL COMMENT '创建时间',
`views` int(30) NOT NULL COMMENT '浏览量'
) ENGINE=InnoDB DEFAULT CHARSET=utf8

1.创建一个maven基础工程

2.IDutils工具类

使用UUID创建唯一id

IDUtils:

public class IDUtils {
    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }
}

3.实体类的编写

Blog:

@Data
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;
    private int views;

}

4.编写Mapper接口及xml文件

BlogMapper：

public interface BlogMapper {
}

BlogMapper.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.kuang.dao.BlogMapper">

</mapper>

5.mybatis核心配置文件，下划线命名驼峰命名自动转换

<settings>
<!--下划线命名 驼峰命名自动转换-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

<!--注册Mapper.xml-->
<mappers>
    <mapper class="com.kuang.dao.BlogMapper"/>
</mappers>

6.初始化接口数据

编写接口：

//新增一个博客
int addBlog(Blog blog);

Mapper.xml：

<insert id="addBlog" parameterType="Blog">
    insert into mybatis.blog (id,title,author,create_time,views)
    values (#{id},#{title},#{author},#{createTime},#{views});
</insert>

test:初始化博客数据

@Test
public void addInitBlog(){
    SqlSession session = MybatisUtils.getSqlSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);

    Blog blog = new Blog();

    blog.setId(IDUtils.getId());
    blog.setTitle("Mybatis如此简单");
    blog.setAuthor("狂神说");
    blog.setCreateTime(new Date());
    blog.setViews(9999);
    mapper.addBlog(blog);

    blog.setId(IDUtils.getId());
    blog.setTitle("Java如此简单");
    mapper.addBlog(blog);

    blog.setId(IDUtils.getId());
    blog.setTitle("Spring如此简单");
    mapper.addBlog(blog);

    blog.setId(IDUtils.getId());
    blog.setTitle("微服务如此简单");
    mapper.addBlog(blog);

    session.commit();
    session.close();
}

10.3 if标签

应用场景：

根据条件append查询条件，拼接SQL

需求：根据作者名字author和博客名字title来查询博客：

如果author和title都为空，查询全部博客
author不为空，title为空，查询所有属于author的博客
author为空，title不为空，查询指定博客名字的博客
author和title都不为空，查询符合两者条件的博客

1.编写接口类：

//需求1
List<Blog> queryBlogIf(Map map);

2.编写Mapper.xml中SQL语句

<select id="queryBlogIf" parameterType="map" resultType="Blog">
    select * from `blog` where

    <if test="author!=null">
        author=#{author}
    </if>
    <if test="title!=null">
        and title=#{title}
    </if>

</select>

3.测试

@Test
public void test(){
    SqlSession session = MybatisUtils.getSqlSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);

    Map<String,Object> map=new HashMap<String, Object>();
    map.put("author","狂神说");
    map.put("title","Mybatis如此简单");

    List<Blog> blogs = mapper.queryBlogIf(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }
    session.close();
}

问题：

当author为null,title不为空时，select语句为：select * from blog where and title=#{title} ，这是错误的SQL语句。如何解决呢？采用下面where标签；

10.4 where标签

应用场景：

如果查询条件有返回值，就插入where；没有查询条件不插入where；
如果第一个查询条件前有and，就去除该and

修改上面的SQL语句：

<select id="queryBlogIf" parameterType="map" resultType="Blog">
    select * from `blog`
    <where>
        <if test="author!=null">
            author=#{author}
        </if>
        <if test="title!=null">
            and title=#{title}
        </if>
    </where>
    </select>

set标签

应用场景：

update操作，尾部最后一个逗号 , 剔除
当author不为null，title为null时，造成错误： SQL尾部多了一个逗号 update blog set author=#{author},

编写Mapper.xml中SQL语句

<update id="updateBlog" parameterType="map">
    update `blog`
    <set>
        <if test="author!=null">
            author=#{author},
        </if>
        <if test="title!=null">
            title=#{title}
        </if>
    </set>
    where id=#{id}
</update>

trim标签

10.5 foreach标签

应用场景：

**对应于 select * from blog where id in (1,2,3,4) **

1.编写接口类：

List<Blog> queryBlogForeach(Map map);

2.编写Mapper.xml中SQL语句

<select id="queryBlogForeach" parameterType="map" resultType="Blog">
    select * from blog
    <where>
        <!--
        collection:指定输入对象中的集合属性
        item:每次遍历生成的对象
        open:开始遍历时的拼接字符串
        close:结束时拼接的字符串
        separator:遍历对象之间需要拼接的字符串
        select * from blog where 1=1 and (id=1 or id=2 or id=3)
        -->
        <foreach collection="idList" item="id" open="(" close=")" separator="or">
            id=#{id}
        </foreach>
    </where>
</select>

3.测试

@Test
public void test(){
    SqlSession session = MybatisUtils.getSqlSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);

    Map<String,Object> map=new HashMap<String, Object>();
    List<String> idList=new ArrayList<String>();
    idList.add("ae52b845132a4a7190d4c3e192265fd2");
    map.put("idList",idList); //List是map的一个属性

    List<Blog> blogs = mapper.queryBlogForeach(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }

    session.commit();
    session.close();
}

10.6 choose、when、otherwise标签

应用场景：

有时候我们不想用所有的查询条件，只想选择其中一个，查询条件有一个满足即可
使用choose，类似switch语句，前面的优先匹配优先级更高

1.编写接口类：

List<Blog> queryBlogChoose(Map map);

2.编写Mapper.xml中SQL语句

<select id="queryBlogChoose" parameterType="map" resultType="Blog">
    select * from blog
    <where>
        <choose>
            <when test="author!=null">
                author=#{author}
            </when>
            <when test="title!=null">
                title=#{title}
            </when>
            <otherwise>
                and views=#{views}
            </otherwise>
        </choose>

    </where>
</select>

3.测试

@Test
public void test(){
    SqlSession session = MybatisUtils.getSqlSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);

    Map<String,Object> map=new HashMap<String, Object>();
    map.put("title","Java如此简单2");
    map.put("author","狂神说2");
    map.put("views",9999);

    List<Blog> blogs = mapper.queryBlogChoose(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }

    session.commit();
    session.close();
}

10.7 提取SQL片段

有时候可能某个sql语句我们用的特别多，为了增加代码的复用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用。

提取SQL片段：

<sql id="if-title-author">
    <if test="author!=null">
        author=#{author}
    </if>
    <if test="title!=null">
        and title=#{title}
    </if>
</sql>

引用SQL片段：

<select id="queryBlogIf" parameterType="map" resultType="Blog">
    select * from `blog`
    <where>
        <!-- 引用 sql 片段，如果refid 指定的不在本文件中，那么需要在前面加上 namespace-->
        <include refid="if-title-author"/>
        <!-- 在这里还可以引用其他的 sql 片段 -->
    </where>
</select>

注意：

最好基于单表定义sql片段，提高片段的可重用性
在sql片段中不要包括where

动态SQL小结：

动态SQL语句的编写往往就是一个拼接的问题
为了保证拼接准确，最好先写出原生的sql语句
然后再通过mabatis动态SQL对照修改，防止出错

11.缓存

11.1简介

问题：

查询：连接数据库，耗费资源。

一次查询的结果，给他暂存在一个可以直接取到的地方——内存：缓存

我们再次查询相同数据的时候，直接走缓存，就不用走数据库了。

1.什么是缓存？

存在内存中的临时数据
将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库数据文件）查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。

2.为什么使用缓存？

减少和数据库的交互次数，减少系统开销，提高系统效率。

3.什么样的数据能使用缓存

经常查询并且不经常改变的数据
不经常查询 or 经常改变的数据不使用缓存

11.2Mybatis缓存

MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
- 默认情况下，只有一级缓存开启（SQLSession级别的缓存，也称本地缓存，作用域从SQLSession开启到结束
- 二级缓存需要手动配置和开启，它是基于namespace级别的缓存（在一个Mapper中有效，也称全局缓存；查询数据库，数据存入一级缓存，当SQLSession关闭时，将其缓存交付给二级缓存）
- MyBatis自定义了缓存接口Cache，可以自定义二级缓存

缓存清除策略：

11.3一级缓存

一级缓存也叫本地缓存，SqlSession级别，从SqlSession开始到关闭期间
- 与数据库同一次会话期间查询到的数据会放在本地缓存中
- 这期间需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；
- 一级缓存自动开启

1.测试

在同一SqlSession中查询两次相同记录

开启日志
测试代码：

Mapper接口：

//根据id查询用户
User queryUserbyId(@Param("id") int id);

Mapper.xml：

<select id="queryUserbyId" resultType="com.kuang.pojo.User">
    select * from `user` where id=#{id};
</select>

test:

public void testQueryUserById(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    User user1 =mapper.queryUserbyId(1);
    System.out.println(user1);

    System.out.println("===========同一个SqlSession中两次查询相同记录================");

    User user2 =mapper.queryUserbyId(1);
    System.out.println(user2);

    System.out.println("user1==user2:"+(user1==user2));

    sqlSession.close();
}

测试结果：

2.一级缓存失效

SqlSession一级缓存失效的情况

（1）SqlSession不同

public void testQueryUserById(){
    SqlSession sqlSession1 = MybatisUtils.getSqlSession();
    SqlSession sqlSession2 = MybatisUtils.getSqlSession();

    //第一次查询
    UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
    User user1 =mapper1.queryUserbyId(1);
    System.out.println(user1);

    System.out.println("===========Sqlsession不同================");

    //第二次查询
    UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
    User user2 =mapper2.queryUserbyId(1);
    System.out.println(user2);


    sqlSession1.close();
    sqlSession2.close();
}

观察结果：两次查询都查询了数据库；

结论：每个SqlSession中缓存相互独立

（2）SqlSession相同，查询条件不同

public void testQueryUserById(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    User user1 =mapper.queryUserbyId(1);
    System.out.println(user1);

    System.out.println("===========SqlSession相同，查询条件不同================");

    User user2 =mapper.queryUserbyId(2);
    System.out.println(user2);

    System.out.println("user1==user2:"+(user1==user2));

    sqlSession.close();
}

（3）增删改操作，可能会改变原来的数据，所以必定会刷新缓存

增删改之后，再次查询，会重新查询数据库；

//第一次查询
User user1 =mapper.queryUserbyId(1);
System.out.println(user1);

System.out.println("===========增删改操作，会刷新缓存================");
//更新
Map<String,Object> map=new HashMap<String, Object>();
map.put("id",1);
map.put("name","zhangsan2");
map.put("pwd","zhang123321");
mapper.updateUser(map);

//第二次查询
User user2 =mapper.queryUserbyId(1);
System.out.println(user2);

（4）SqlSession相同，手动清除一级缓存

第二次查询会重新查询数据库

public void testQueryUserById(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    //第一次查询
    UserMapper mapper1 = sqlSession.getMapper(UserMapper.class);
    User user1 =mapper1.queryUserbyId(1);
    System.out.println(user1);

    System.out.println("===========手动清除以及缓存================");

    //手动清除以及缓存
    sqlSession.clearCache();

    //第二次查询
    UserMapper mapper2 = sqlSession.getMapper(UserMapper.class);
    User user2 =mapper2.queryUserbyId(1);
    System.out.println(user2);

    sqlSession.close();

}

一级缓存就是一个Map，key-value键值对

11.4二级缓存

二级缓存也叫全局缓存，一级缓存作用域只在一个SqlSession内，作用于太低，所以诞生了二级缓存
基于namespace级别的缓存，一个命名空间，对应一个二级缓存
工作机制：
- 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
- 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存的数据被保存到二级缓存中；
- 新的会话查询信息，就可以从二级缓存中获取内容；
- 不同的mapper查出的数据会放在自己对应的缓存（map）中

使用步骤

1.在mybatis-config.xml核心配置文件中，开启全局缓存

 <!--显式的开启全局缓存--> 
<setting name="cacheEnabled" value="true"/>

2.在要使用二级缓存的Mapper.xml中开启

<cache/>

也可以自定义参数

<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

3.测试

（1）遇到问题：实体类需要序列化，否则就会报错

Cause: java.io.NotSerializableException: com.kuang.pojo.User

解决：

public class User implements Serializable {......}

（2）两个SqlSession测试二级缓存：

public void testQueryUserById(){
    //第一次查询
    SqlSession sqlSession1 = MybatisUtils.getSqlSession();
    UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
    User user1 =mapper1.queryUserbyId(1);
    System.out.println(user1);
    sqlSession1.close();

    System.out.println("===========两个SqlSession测试二级缓存================");

    //第二次查询
    SqlSession sqlSession2 = MybatisUtils.getSqlSession();
    UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
    User user2 =mapper2.queryUserbyId(1);
    System.out.println(user2);
    sqlSession2.close();
}

小结

只要开启了二级缓存，在同一个Mapper下就有效
所有的数据都会先放在一级缓存中
只有当会话提交或者关闭时，才会提交到二级缓存中

11.5缓存原理

采用缓存后，查询数据先后顺序：

1.先看二级缓存中有没有

2.再看二级缓存中有没有

3.都没有查询数据库

11.6自定义缓存ehcache

ehcache是第三方缓存，是一个纯Java的进程内缓存框架
是一种广泛使用的java分布式缓存，用于通用缓存

1.使用需要导入jar包

<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.2.1</version>
</dependency>

2.在mapper.xml中使用对应的缓存即可

<mapper namespace="com.kuang.dao.UserMapper">
    <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
</mapper>

3.编写ehcache.xml配置文件，放在resources中；如果在加载时未找到/ehcache.xml资源，将使用默认配置

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--
       diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
       java.io.tmpdir – 默认临时文件路径
     -->
    <diskStore path="./tmpdir/Tmp_EhCache"/>
    
    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>
 
    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
    <!--
       defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个。
     -->
    <!--
      name:缓存名称。
      maxElementsInMemory:缓存最大数目
      maxElementsOnDisk：硬盘最大缓存个数。
      eternal:对象是否永久有效，一但设置了，timeout将不起作用。
      overflowToDisk:是否保存到磁盘，当系统当机时
      timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
      timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
      diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
      diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
      diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
      memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
      clearOnFlush：内存数量最大时是否清除。
      memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
      FIFO，first in first out，这个是大家最熟的，先进先出。
      LFU， Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
      LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->

</ehcache>

Mybatis缓存使用不多，大多被Redis缓存数据库，key-value键值对。

12.错误

【错误1】测试类不要和Mapper接口同名，测试类的测试函数不要和Mapper中接口函数同名

否则会出现找不到java方法

或者找到测试类的测试函数，但是传递方法参数不对

【错误2】

Cause: com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceExcep

解决方法：之前在pom.xml文件中删除了下面代码，现在加上：

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

【错误3】

新建Mapper接口时不要建成了类

13.Mybatis常用配置总结

13.1Mybatis流程

项目结构

Mapper.xml和Mapper接口放在一起

Mapper.xml和Mapper接口放在相同包名下，Mapper.xml放在Resources目录下

Mybatis项目构建

1.新建配置文件

mybatis-config.xml 核心配置文件（后续不要忘记在此注册Mappper）
db.properties 数据库配置文件
log4j.properties 日志配置文件

2.新建工具类

MybatisUtils 提取生成SqlSession工具类
其他工具类

3.新建实体类

4.新建dao层

Mapper接口
Mapper.xml（类实现类，书写sql）（每个需要在mybatis-config.xml 核心配置文件中注册）

5.测试

13.2常用配置

MyBatis的maven项目pom.xml常用依赖

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

    <groupId>org.example</groupId>
    <artifactId>mybatis3</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.3</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
        <!--log4j日志输出 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!--lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <!--mybatis-ehcache-->
        <dependency>
            <groupId>org.mybatis.caches</groupId>
            <artifactId>mybatis-ehcache</artifactId>
            <version>1.2.1</version>
        </dependency>

    </dependencies>

    <!--在build中配置resources，来防止我们资源导出的失败的问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>


</project>

1.新建配置文件

mybatis-config.xml 核心配置文件（后续不要忘记在此注册Mappper）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <properties resource="db.properties"/>
    
    <settings>
        <!--开启日志-->
        <setting name="logImpl" value="LOG4J"/>
        <!--驼峰命名转换-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>

    <!--简化Mapper.xml中书写returnType类型，为实体类起别名-->
    <typeAliases>
        <package name="com.kuang.pojo"/>
    </typeAliases>
    
    <!--配置环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--注册Mapper-->
    <mappers>
        <mapper class="com.kuang.dao.BlogMapper"/>
    </mappers>

</configuration>

db.properties 数据库配置文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8
username=root
password=123456

log4j.properties 日志配置文件

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/kuang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

2.新建工具类

MybatisUtils 提取生成SqlSession工具类

//工具类
//需要获得数据库操作对象SqlSession
//SqlSessionFactory---->SqlSession
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;//提升作用域

    static {
        //使用Mybatis的第一步：获取SqlSessionFactory对象
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream =Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //有了SqlSessionFactory以后，我们可以从中获得SqlSession的实例
    //SqlSession提供了在数据库执行 SQL命令 所需的所有方法
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

其他工具类，如IDUtils

public class IDUtils {
    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }
}

3.新建实体类

import java.util.Date;
@Data
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;
    private int views;

}

4.新建dao层

Mapper接口

public interface BlogMapper {
    //查询
    List<Blog> queryBlogIf(Map map);
}

Mapper.xml（类实现类，书写sql）（每个需要在mybatis-config.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.kuang.dao.BlogMapper">

    <select id="queryBlogIf" parameterType="map" resultType="Blog">
        select * from `blog`
        <where>
            <if test="author!=null">
                author=#{author}
            </if>
            <if test="title!=null">
                and title=#{title}
            </if>
        </where>
    </select>

</mapper>

5.测试

public class BlogTest {
    @Test
    public void test(){
        SqlSession session = MybatisUtils.getSqlSession();
        BlogMapper mapper = session.getMapper(BlogMapper.class);

        Map<String,Object> map=new HashMap<String, Object>();
        map.put("title","Java如此简单2");
        map.put("author","狂神说2");


        List<Blog> blogs = mapper.queryBlogIf(map);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }

        session.commit();
        session.close();
    }
}

MyBatis完整笔记（搭建环境CURD、配置解析、单表结果集映射 多表查询一对多多对一、日志 分页 使用注解开发、动态SQL、mybatis缓存）

MyBatis

1.简介

1.1 什么是MyBatis

1.2 持久化

1.3 持久层

1.4 为什么需要Mybatis？

2.第一个Mybatis程序

2.1 搭建环境

2.2 创建一个子模块

（1）编写Mybatis的核心配置文件

（2）编写Mybatis工具类

（3）创建实体类

（4）dao层：UserDao接口和UserMapper.xml

（5）测试

2.3 可能会遇到的问题

2.4 运行思路

3.CURD

3.1编写接口

3.2编写对应的mapper.xml中的sql语句

3.3测试

3.4遇到的问题

3.5万能的Map

3.6模糊查询

4.配置解析

4.1环境配置（enviroments）

4.2属性（properties）

4.3类型别名（typeAliases）

（1）为具体实体类指定类型别名

（2）指定一个包名

（3）自定义类型别名

4.4映射器（mapper）

4.5设置（enviroments）

4.6其他

4.7生命周期和作用域

5.ResultMap结果集映射

5.1 实体类属性和数据库字段不匹配问题

5.2 resultMap

6.日志

6.1.STDOUT_LOGGING标准日志输出

6.2.LOG4J 拓展日志输出

7.分页

7.1 sql层面limit实现分页

7.2 使用RowBounds实现分页

7.3 分页插件

8.使用注解开发

8.1面向接口编程

8.2利用注解开发

8.3 采用注解CURD

8.4 Lombok注解插件

9.多表查询结果集映射

9.1 老师学生例子数据库表

9.2多对一

（1）测试环境搭建

（2）按照结果嵌套处理（类连接查询、重点）

（3）按照查询嵌套处理（类子查询）

9.3一对多

（1）测试环境搭建

（2）按照结果嵌套处理（类连接查询、重点）

（3）按照查询嵌套处理（类子查询）

10.动态SQL

10.1简介

10.2搭建环境

10.3 if标签

10.4 where标签

set标签

trim标签

10.5 foreach标签

10.6 choose、when、otherwise标签

10.7 提取SQL片段

11.缓存

11.1简介

11.2Mybatis缓存

11.3一级缓存

1.测试

2.一级缓存失效

11.4二级缓存

使用步骤

小结

11.5缓存原理

MyBatis完整笔记（搭建环境CURD、配置解析、单表结果集映射多表查询一对多多对一、日志分页使用注解开发、动态SQL、mybatis缓存）