MyBatis 基础

2022-03-19 本文已影响0人 yjtuuige

环境说明：

jdk 17
MySQL-8.0.28
maven-3.8.4
Mybatis-3.5.9
IDEA 2021.2

需要掌握：

JDBC
MySQL
Java 基础
Maven
Junit

一、Mybatis 简介

1.1 什么是 MyBatis

Mybatis 【官方文档】
GitHub：链接
MyBatis 是一款优秀的 持久层框架；
MyBatis 避免了几乎所有的 JDBC 代码，和手动设置参数，以及获取结果集的过程；
MyBatis 可以使用简单的 XML 或注解，来配置和映射原生信息，将接口和 Java 的实体类【Plain Old Java Objects，普通的 Java 对象】映射成数据库中的记录；
MyBatis 以前是 apache 的一个开源项目 ibatis，2010 年，由apache 迁移到了 google code，并改名为 MyBatis ，2013 年 11 月，迁移到 Github；

1.2 持久化

持久化：将程序数据，在持久状态和瞬时状态间转换的机制；
- 即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）；
- 持久化的主要应用：
  - 将内存中的对象，存储在数据库中，或者存储在磁盘文件中、XML 数据文件中等等；
- JDBC 就是一种持久化机制，文件 IO 也是一种持久化机制；

为什么需要持久化服务？

由于内存本身的缺陷引起的：
- 内存断电后数据会丢失，但有些重要数据（如银行账号等），是不能丢失的，但无法保证内存永不掉电；
- 内存价格高，维持成本也高；
- 即使对象不需要永久保存，也会因为内存的容量限制，不能永久存储在内存中，所以，需要持久化，来缓存到外存。

1.3 持久层

什么是持久层？

完成持久化工作的代码块：dao层【DAO (Data Access Object) 数据访问对象】；
大多数情况下，特别是企业级应用，数据持久化，是将内存中的数据，保存到磁盘上加以固化，而持久化的实现过程，大多是通过各种关系型数据库来完成；
对于应用系统而言，数据持久功能，大多是必不可少的组成部分，也就是说，在系统中，已经具备了 持久层 概念，之所以要独立出一个 持久层 的概念，而不是持久模块、持久单元，意味着，在系统架构中，应该有一个相对独立的逻辑层面，专著于数据持久化逻辑的实现；
相对系统其他部分而言，持久层 应该具有一个较为清晰和严格的逻辑边界，说白了，就是 用来操作数据库存在的。
持久化，是一个动作，持久层，是一个概念；

1.4 为什么需要 Mybatis

Mybatis 是帮助使用者，将数据存入数据库中 , 和从数据库中取数据；
传统的 JDBC 操作 , 有很多重复代码块，比如：
- 数据取出时的封装；
- 数据库的建立连接等等；
- 通过框架，可以减少重复代码，提高开发效率；
MyBatis 是一个半自动化的 ORM 框架 Object Relationship Mapping --> 对象关系映射；
不是必须使用 MyBatis，只是用了它，所有实现会更加简单；

MyBatis 的优点

简单易学
灵活
解除 sql 与程序代码的耦合：
- 通过提供 DAO 层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试；
- sql 和代码的分离，提高了可维护性；
提供 xml 标签，支持编写动态 sql ；

二、使用 Mybatis

思路流程：搭建环境 --> 导入 Mybatis ---> 编写代码 ---> 测试；

2.1 搭建环境

搭建数据库：

CREATE DATABASE `mybatis`;
USE `mybatis`;
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`(
    `id` INT NOT NULL,
    `name` VARCHAR(30) DEFAULT NULL,
    `pwd` VARCHAR(30) DEFAULT NULL,
    PRIMARY KEY (`id`)
)ENGINE INNODB DEFAULT CHARSET=utf8mb4;

INSERT INTO `user`(`id`,`name`,`pwd`) VALUES 
(1,'张三','123456'),
(2,'李四','abc'),
(3,'王五','111');

创建父项目：

创建 maven 空项目，删除 src；
导入依赖：

<!--MySQL 依赖-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.28</version>
</dependency>
<!--单元测试-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
</dependency>
<!--mybatis-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.9</version>
</dependency>

2.2 创建模块（子项目）

创建 maven 空模块：子项目可直接使用父项目的依赖；
项目结构图：
编写 MyBatis 核心配置文件：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核心配置文件-->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url"
                          value="jdbc:mysql://localhost:3306/数据库名?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=true"/>
                <property name="username" value="用户名"/>
                <property name="password" value="密码"/>
            </dataSource>
        </environment>
    </environments>
    <!--注册 Mapper.xml-->
    <mappers>
        <mapper resource="com/study/mybatis/dao/userMapper.xml"/>
    </mappers>
</configuration>

编写代码

编写 MyBatis 工具类：MybatisUtils.java
1. 加载资源文件；
2. 创建执行 sql 的对象；

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

    // 静态代码块：类初始化时，一起加载
    // 1.获取SqlSessionFactory对象（加载资源文件）
    static {
        try {
            // 获取资源配置文件
            String resource = "mybatis-config.xml";
            // 配置文件转换为输入流
            InputStream inputStream = Resources.getResourceAsStream(resource);
            // 创建SqlSessionFactory实例    build加载流
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 2.通过sqlSessionFactory，获得sqlSession实例（创建执行sql的对象）
    // sqlSession完全包含，面向数据库执行sql命令所需的所有方法
    // 获取SqlSession连接
    public static SqlSession getSession() {
        return sqlSessionFactory.openSession();
    }
}

创建实体类：User.java

public class User {
    // id
    private int id;
    // 姓名
    private String name;
    // 密码
    private String pwd;
    // 构造方法：有参、无参
    // set/get
    // toString()
}

编写 Mapper 接口类：UserMapper.java

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

编写 Mapper.xml 配置文件（接口实现类）：userMapper.xml
- namespace：
  - 对应接口类，需要完整包名+类名；
  - 十分重要，不能写错！！！

<?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 对应接口类，需要完整包名+类名-->
<mapper namespace="com.study.mybatis.dao.UserMapper">
    <!--id 对应接口类的方法名，resultType 返回类型（集体为泛型），需要完整包名+类名-->
    <select id="getUserList" resultType="com.study.mybatis.pojo.User">
        select * from `user`
    </select>
</mapper>

编写测试类：UserTest.java

public class UserTest {
    @Test
    public void selectUser() {
        // 1.获取SqlSession对象
        SqlSession session = MybatisUtils.getSession();

        // 2.执行sql：需要获取dao(UserMapper)
        // 方法一：不推荐
        // List<User> users = session.selectList("com.study.mybatis.dao.UserMapper.getUserList");
        // 方法二：
        UserMapper mapper = session.getMapper(UserMapper.class);
        List<User> users = mapper.getUserList();
        for (User user : users) {
            System.out.println(user);
        }
        // 3.关闭SqlSession
        session.close();
    }
}

运行测试：

2.3 可能出现的问题：

未在 Mybatis 核心配置文件中注册 Mapper.xml；

解决方法：在 mybatis-config.xml 中注册

<!--注册 Mapper.xml-->
<mappers>
    <mapper resource="com/study/mybatis/dao/userMapper.xml"/>
</mappers>

Maven 静态资源过滤问题：

解决方法：配置 pom.xml，添加以下代码

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

三、CRUD 操作

3.1 namespace

Mapper.xml 配置文件中，namespace 对应 Mapper 接口，或者 Dao 接口的 完整包名，必须一致！

3.2 select 查询

select 标签是 mybatis 中最常用的标签之一；
select 语句有很多属性，可以详细配置每一条 SQL 语句：
- id：
  - 命名空间中，唯一的标识符；
  - 接口中的 方法名，与映射文件中的 SQL 语句 id 对应；
- parameterType：
  - 传入 SQL 语句的 参数类型 ；【万能的 Map，可以多尝试使用】
- resultType：
  - SQL 语句 返回值类型；【完整的类名或者别名】

实例：根据 id 查询用户

在 UserMapper（接口）中，添加对应方法：

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

在 UserMapper.xml 中添加 Select 语句：
- sql 语句结尾不要加分号，否则 Oracle 会报错；

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

测试类：

// 根据id查询用户
@Test
public void getUserById() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    User user = mapper.getUserById(2);
    System.out.println(user);
    session.close();
}

3.3 insert 插入

标签：insert

在数据库中，增加一个用户

在 UserMapper 接口中添加对应的方法：

// 增加用户
public int addUser(User user);

在 UserMapper.xml 中添加 insert 语句：

<!--增加用户-->
<insert id="addUser" parameterType="com.study.mybatis.pojo.User">
    insert into `user` (id, name, pwd) values (#{id}, #{name}, #{pwd})
</insert>

测试：

// 增加用户
@Test
public void addUser() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    int i = mapper.addUser(new User(4, "测试", "111"));
    if (i > 0) {
        System.out.println("添加成功！");
    }
    // 提交事务：增、删、改操作，都需要提交事务
    session.commit();
    session.close();
}

注意点：增、删、改操作，需要提交事务！

3.4 update 修改

标签：update

修改用户的信息

写接口方法：

// 根据id修改用户信息
public int updateUser(User user);

编写对应的配置文件 SQL：

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

测试：

// 修改用户信息
    @Test
    public void updateUser() {
        SqlSession session = MybatisUtils.getSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        int i = mapper.updateUser(new User(4, "新用户", "123456"));
        if (i > 0) {
            System.out.println("修改成功");
        }
        // 提交事务：增、删、改操作，都需要提交事务
        session.commit();
        session.close();
    }

    // 修改用户信息2
    @Test
    public void updateUser2() {
        SqlSession session = MybatisUtils.getSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        User user = mapper.getUserById(4);
        user.setPwd("abfdas");
        int i = mapper.updateUser(user);
        if (i > 0) {
            System.out.println("修改成功");
        }
        // 提交事务：增、删、改操作，都需要提交事务
        session.commit();
        session.close();
    }

3.5 delete 删除

标签：delete

根据 id 删除一个用户

编写接口方法：

// 删除用户
public int deleteUser(int id);

编写对应的配置文件 SQL：

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

测试：

// 删除用户
@Test
public void deleteUser() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    int i = mapper.deleteUser(4);
    if (i > 0) {
        System.out.println("删除成功！");
    }
    // 提交事务：增、删、改操作，都需要提交事务
    session.commit();
    session.close();
}

可能出现的问题：

sql 增、删、改、查对应不同的标签，不要匹配错；
核心配置文件的 mapper 映射，resource 需要使用路径方式；
程序配置文件，必须完全符合规范；
Maven 静态资源被过滤，未导出问题：需配置 pom.xml；

3.6 使用万能的 Map

实体类中的字段太多，可以通过 Map 来减少实参的使用：
- 先将数据传进 Map 中；
- 在实现 SQL 语句时，将 Map 中对象进行调用；

根据密码和名字查询用户

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

// 根据密码和名字查询用户
public User selectUserByNP(Map<String,Object> map);
}

编写 sql 语句，传递参数类型 map：#{map key}

<!--根据密码和名字查询用户-->
<select id="selectUserByNP" parameterType="map" resultType="com.study.mybatis.pojo.User">
    select * from `user` where name = #{username} and pwd =#{password}
</select>

使用方法时，Map 的 key 对应 sql 中的取值，没有顺序要求：

 // 根据密码和名字查询用户
@Test
public void selectUser1() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    Map<String, Object> map = new HashMap<>();
    map.put("username", "张三");
    map.put("password", "123456");
    User user = mapper.selectUserByNP(map);
    if (user != null) {
        System.out.println(user);
    }
    session.close();
}

如果参数较少，直接传递参数即可，多个参数，建议使用 Map 或注解 实现，；

3.7 模糊查询

在 Java 代码中，添加 sql 通配符 %：

配置文件：

<!--模糊查询 java-->
<select id="getUserLike" resultType="com.study.mybatis.pojo.User">
    select * from `user` where name like #{value}
</select>

测试：

// 模糊查询
@Test
public void selectUser2() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    String wildCardName = "%李%";
    List<User> user = mapper.getUserLike(wildCardName);
    System.out.println(user);
    session.close();
}

在 sql 语句中，拼接通配符 %，会引起 sql 注入：

配置文件：

<!--模糊查询 sql-->
<select id="getUserLike" resultType="com.study.mybatis.pojo.User">
    select * from `user` where name like "%"#{value}"%"
</select>

测试：

String wildCardName = "李";
List<User> user = mapper.getUserLike(wildCardName);

小结：

所有的增、删、改操作都需要提交事务！
接口所有的普通参数，尽量都写上 @Param 参数，尤其是多个参数时，必须写上！
有时候根据业务的需求，可以考虑使用 map 传递参数！
为了规范操作，在 SQL 的配置文件中，尽量将 Parameter 参数和 resultType 都写上！

四、配置解析

4.1 核心配置文件

系统核心配置文件：mybatis-config.xml （文件名可以自定义）；
MyBatis 的配置文件，包含了会深深影响 MyBatis 行为的设置和属性信息；
可配置的内容如下：

<!-- 注意元素节点的顺序！顺序不对会报错 -->
configuration（配置）
    properties（属性）
    settings（设置）
    typeAliases（类型别名）
    typeHandlers（类型处理器）
    objectFactory（对象工厂）
    plugins（插件）
    environments（环境配置）
        environment（环境变量）
            transactionManager（事务管理器）
            dataSource（数据源）
    databaseIdProvider（数据库厂商标识）
    mappers（映射器）

4.2 环境配置（environments）

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

environments：通过 default 指定环境；
- MyBatis 可配置多套运行环境，将 SQL 映射到，多个不同的数据库上，只能指定一个为默认运行环境;
environment：具体的一套环境；
- 通过设置 id 进行区别，id 要保证唯一！
transactionManager：事务管理器，不需要设置任何属性；
- JDBC（默认）；
- MANAGED （了解）；
dataSource：数据源；
- 使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源；
- 数据源是必须配置的；
- 三种内建的数据源类型：
  - POOLED（默认）：数据池；
  - UNPOOLED：非数据池；
  - JNDI（了解）：正常连接；
- 数据源有很多第三方的实现，如：dbcp，c3p0，druid等等；

4.3 属性（properties）

数据库属性都是可外部配置，且可动态替换的，既可以在典型的 Java 属性文件中配置，也可通过 properties 元素的子元素来传递；

优化配置文件

在资源目录下，创建 db.properties：

# mysql8 驱动
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/数据库名?useUnicode=true;characterEncoding=utf8;useSSL=true
username=用户名
password=密码

将文件导入 properties 配置文件：

<!--configuration核心配置文件-->
<configuration>
    <!--导入properties文件-->
    <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>
    <!--Mapper.xml-->
    <mappers>
        <mapper resource="com/study/mybatis/dao/userMapper.xml"/>
    </mappers>
</configuration>

注意：
- xml 文件的标签，都可以规定顺序，引入标签要注意；
- 配置文件优先级：优先使用配置文件 db.properties；

4.4 类型别名（typeAliases）

类型别名，是为 Java 类型设置一个短的名字，只和 XML 配置有关；

设置别名的两种方式：在核心配置文件中设置

为每个类单独指定类名：
- 实体类较少；
- 别名可自定义；

<!--实体类设置别名-->
<typeAliases>
    <typeAlias type="com.study.mybatis.pojo.User" alias="User"/>
</typeAliases>

扫描包：
- 实体类较多；
- 首字母小写的类名，作为别名（User --> user）；
- 若有注解，则别名为其注解值；

<!--指定包名-->
<typeAliases>
    <package name="com.study.mybatis.pojo"/>
</typeAliases>

类别名注解：

@Alias("user")
public class User {
    ...
}

4.5 设置（settings）

会改变 MyBatis 的运行时行为；
常见的设置：
- 懒加载：lazyLoadingEnabled 默认为 false；
- 日志实现：logImpl 默认无；
- 缓存开启关闭：cacheEnabled 默认为 true；
- 驼峰命名：mapUnderscoreToCamelCase 默认为 false；
settings 元素示例：

<settings>
    <setting name="cacheEnabled" value="true"/>
    <setting name="lazyLoadingEnabled" value="true"/>
    <setting name="multipleResultSetsEnabled" value="true"/>
    <setting name="useColumnLabel" value="true"/>
    <setting name="useGeneratedKeys" value="false"/>
    <setting name="autoMappingBehavior" value="PARTIAL"/>
    <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
    <setting name="defaultExecutorType" value="SIMPLE"/>
    <setting name="defaultStatementTimeout" value="25"/>
    <setting name="defaultFetchSize" value="100"/>
    <setting name="safeRowBoundsEnabled" value="false"/>
    <setting name="mapUnderscoreToCamelCase" value="false"/>
    <setting name="localCacheScope" value="SESSION"/>
    <setting name="jdbcTypeForNull" value="OTHER"/>
    <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

4.6 其它设置（了解）

typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
- mybatis-generator-core
- mybatis-plus (mybatis简化版)
- 通用mappers

4.7 映射器（mappers）

定义映射 SQL 语句文件，绑定 Mapper.xml 文件；

实现方式：

方式一（推荐）：resource 使用路径的方式；

<mappers>
    <mapper resource="com/study/mybatis/dao/userMapper.xml"/>
</mappers>

方式二：class 使用接口实现类；

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

方式三：package 扫描包；

<mappers>
    <package name="com.study.mybatis.dao"/>
</mappers>

方式四（不要用）：url；

注意：

使用接口实现类和扫描包时：
- 接口和 xml 配置文件，必须同名；
- 接口和 xml 配置文件，必须在同一包下；

4.8 生命周期和作用域

生命周期和作用域至关重要，错误的使用，会导致严重的并发问题；
Mybatis 的执行过程：
作用域理解：
- SqlSessionFactoryBulider：
  - 局部变量；
  - 作用：创建 SqlSessionFactory；
  - 最佳作用域：方法作用域（局部方法变量）；
- SqlSessionFactory：
  - 静态变量；
  - 相当于，数据库的连接池；
  - 一旦创建，在应用期间一直存在；
  - 最佳作用域：应用作用域；
- SqlSession：
  - 相当于数据库连接对象（Connection）；
  - 需要开启与关闭；
  - 不能共享；
  - 最佳作用域：请求或方法作用域；
- mapper：
  - 相当于一个具体的业务；
示意图：

五、ResultMap 结果集映射

要解决的问题：数据库中字段与实体类属性不一致；

5.1 查询为 null

数据库的字段名：
实体类：

public class User {
    private int id;
    private String name;
    // 密码，和数据库不一致
    private String password;
    // 构造函数
    // set/get
    // toString()
}

接口类：

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

mapper 映射文件：

<!--根据id查询用户-->
<select id="getUserById" resultType="User">
    select * from `user` where id = #{id}
</select>

测试：

// 根据id查询用户
@Test
public void getUserById() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    User user = mapper.getUserById(2);
    System.out.println(user);
    session.close();
}

结果：password='null'

分析：

select * from user where id = #{id} 可以看做 select id,name,pwd from user where id = #{id}；
mybatis 根据查询的列名（转化为小写，数据库不区分大小写) ，去对应的实体类中，查找相应列名的 set 方法，并设值，因为实体类中没有 setPwd()，所以 password 返回 null ; 【自动映射】

5.2 解决方案

方案1（不推荐）：为列名指定别名，和实体类的属性一致；

<select id="getUserById" resultType="User">
    select `id`,`name`,`pwd` as password from `user` where id = #{id}
</select>

方案2（推荐）：结果集映射 --> ResultMap；
- property：对应实体类的 属性名；
- column：对应数据库表的字段，有别名时为别名；

<!--结果集映射 id对应resultMap type对应实体类-->
<resultMap id="userMap" type="User">
    <!-- id为主键 -->
    <id column="id" property="id"/>
    <!-- column是数据库表的列名 , property是对应实体类的属性名 -->
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>
<select id="getUserById" resultMap="userMap">
    select * from `user` where id = #{id}
</select>

5.3 ResultMap

自动映射：

resultMap 元素是 MyBatis 中最重要最强大的元素；
ResultMap 的设计思想：
- 简单的语句，不需要配置显式的结果映射；
- 复杂语句，只需要描述它们的关系；

<!--简单映射-->
<select id="getUserById" resultType="User">
    select * from `user` where id = #{id}
</select>

手动映射

返回值类型为 resultMap：

<select id="getUserById" resultMap="userMap">
    select `id`,`name`,`pwd` from `user` where id = #{id}
</select>

实现手动映射：

<resultMap id="userMap" type="User">
    <!-- id为主键 -->
    <!--<id column="id" property="id"/>-->
    <!-- column是数据库表的列名 , property是对应实体类的属性名 -->
    <!--<result column="name" property="name"/>-->
    <!--可以只映射数据库与类属性不对应的-->
    <result column="pwd" property="password"/>
</resultMap>

六、日志

6.1 日志工厂

数据库的操作出现问题，可以根据输出 SQL 语句快速排错；
以往排错方式：
- debug；
- 控制台输出（sout）；
Mybatis 内置 日志工厂，提供日志功能，具体实现工具：
- SLF4J
- Apache Commons Logging
- Log4j 2
- Log4j (deprecated since 3.5.9) 掌握
- JDK logging
- COMMONS_LOGGING
- STDOUT_LOGGING 标准日志掌握
- NO_LOGGING

标准日志实现

STDOUT_LOGGING：在核心配置文件中，进行配置（注意 name 和 value 大小写，不能错，不能加空格）

<!--标准日志-->
<settings>
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

查看日志：

6.2 Log4j

简介：

Log4j 是 Apache 的开源项目；
- 可以控制日志信息输送的目的地：控制台，文本，GUI 组件等；
- 可以控制每一条日志的输出格式；
- 可以定义每一条日志信息的级别；
- 通过配置文件配置，不需要修改应用代码；

使用步骤：

导入 log4j 的 jar 包或依赖：

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

在资源目录下，创建配置文件：
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/mybatis-04.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 HH:mm:ss}][%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

核心配置文件，setting 设置日志实现：Log4j 注意大小写

<!--Log4j日志-->
<settings>
    <setting name="logImpl" value="Log4j"/>
</settings>

测试：
在程序中使用 Log4j 进行输出：

public class UserTest {
    // 注意导包：org.apache.log4j.Logger
    // 日志对象：参数为当前类的class
    static Logger logger = Logger.getLogger(UserTest.class);

    @Test
    public void getUserById() { 
        // 日志级别
        logger.info("info级别日志：进入getUserById方法");
        logger.debug("debug级别日志：进入getUserById方法");
        logger.error("error级别日志: 进入getUserById方法");

        SqlSession session = MybatisUtils.getSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);
        session.close();
    }
}

测试：
- 查看控制台：使用 Log4j 输出日志；
- 生成了日志文件，【需要修改 file 的日志级别】

七、分页的实现

分页：减少数据的处理量；

7.1 使用 limit 分页（掌握）

SQL 层面，实现分页；
基本语法

<!--stratIndex：起始记录 pageSize：页面大小（几条记录）-->
SELECT * FROM table LIMIT stratIndex，pageSize
<!--检索记录行 6-15-->
SELECT * FROM table LIMIT 5,10
<!--只给定一个参数，表示返回最大的记录行数目,等价于 LIMIT 0,n -->
SELECT * FROM table LIMIT 5
<!--先排序,再分页-->
SELECT * FROM table LIMIT 5,10 ORDER BY id

步骤：

Mapper 接口文件，参数为 map：

// 用户列表：分页
public List<User> getUserByLimit(Map<String,Integer> map);

Mapper.xml 配置文件：

<!--用户列表：分页-->
<select id="getUserByLimit" parameterType="map" resultMap="userMap">
    select * from `user` limit #{startIndex},#{pageSize}
</select>

测试：起始记录 = （当前页面 - 1 ）* 页面大小；

@Test
public void testLimit() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    // 当前页
    int currentPage = 1;
    // 页面大小（每页显示记录数）
    int pageSize = 2;
    Map<String, Integer> map = new HashMap<>();
    map.put("startIndex", (currentPage - 1) * pageSize);
    map.put("pageSize", pageSize);
    List<User> userList = mapper.getUserByLimit(map);
    for (User user : userList) {
        System.out.println(user);
    }
    session.close();
}

7.2 RowBounds 分页（了解）

Java 代码层面，实现分页；
Mapper 接口文件：

// 分页：RowBounds
public List<User> getUserByRowBounds();

Mapper.xml 配置文件：

<!--用户列表：分页 RowBounds-->
<select id="getUserByRowBounds" resultMap="userMap">
    select * from `user`
</select>

测试：
- 需要使用 RowBounds 类；

@Test
public void testRowBounds() {
    SqlSession session = MybatisUtils.getSession();
    int currentPage = 2;
    int pageSize = 2;
    RowBounds rowBounds = new RowBounds((currentPage - 1) * pageSize, pageSize);
    // 通过session.selectList方法传递rowBounds（已经不推荐使用）
    List<User> userList = session.selectList("com.study.mybatis.dao.UserMapper.getUserByRowBounds", null, rowBounds);
    for (User user : userList) {
        System.out.println(user);
    }
    session.close();
}

7.4 分页插件 PageHelper（了解）

官方文档：链接

八、使用注解开发

8.1 面向接口编程

面向接口优点：
- 解耦；
- 可拓展；
- 提高复用；

关于接口的理解：

是定义（规范、约束）与实现（名、实分离的原则）的分离；
反映了系统设计人员，对系统的抽象理解；
接口分两类：
- 对个体的抽象，对应为一个抽象体（abstract class）；
- 对个体某一方面的抽象，即形成一个抽象面（interface）；
一个抽象体，可能有多个抽象面（抽象体与抽象面是有区别的）；

三个面向区别

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

8.2 利用注解开发

MyBatis 最初配置信息是基于 XML，映射语句 sql 也定义在 XML 中，MyBatis 3 提供了基于注解的配置，但 Java 注解能力有限，MyBatis 映射并不能完全用注解来构建；
sql 类型主要包括：
- @select()；
- @update()；
- @Insert()；
- @delete()；
注意：利用注解开发，不需要用 mapper.xml 映射文件；

注解开发实例：只适用于简单的 SQL 语句；

接口中添加注解：

public interface UserMapper {
    @Select("select * from `user`")
    List<User> selectUser();
}

核心配置文件 绑定接口：

<!--使用class绑定接口-->
<mappers>
    <mapper class="com.study.mybatis.dao.UserMapper"/>
</mappers>

测试：

@Test
public void testGetAllUser() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    List<User> usersList = mapper.selectUser();
    for (User user : usersList) {
        System.out.println(user);
    }
    session.close();
}

利用 Debug 查看本质：
本质（反射）：利用了 jvm 的动态代理机制；
Mybatis 详细的执行流程：

8.3 注解 CRUD 操作

修改工具类，设置 自动提交：

// true 设置自动提交
public static SqlSession getSession() {
    return sqlSessionFactory.openSession(true);
}

编写接口，增加注解：

public interface UserMapper {
    @Select("select * from `user`")
    List<User> selectUser();

    @Insert("insert into `user` (id,name,pwd) values (#{id},#{name},#{password})")
    int addUser(User user);

    // 方法存在多个参数，参数前必须加上@Param()注解
    @Select("select * from `user` where `id`=#{id}")
    User getUserById(@Param("id") int id);

    @Update("update `user` set `name`=#{name},`pwd`=#{password} where `id`=#{id}")
    int updateUser(User user);

    @Delete("delete from `user` where `id`=#{uid}")
    int deleteUser(@Param("uid") int id);
}

注意：
- 必须将接口注册，绑定到核心配置文件中！
- 增、删、改一定记得对事务的处理（设置自动提交后，自动处理）；

8.4 关于 @Param

@Param 注解，用于给方法参数起一个名字；

使用原则

基本类型的参数或者 String 类型，需要加上；
引用类型不需要加；
如果只有一个基本类型的话，可以忽略，但是建议都加上！
在 SQL 中引用的是 @Param() 中设定的属性名！
如果参数是 JavaBean ，不能使用@Param；
不使用 @Param 注解时，参数只能有一个，并且是 Javabean；

8.5 #{} 与 ${} 的区别

{}（推荐使用）：预编译，防止 sql 注入；
${}：直接进行字符串替换，无法防止 sql 注入，不安全；

九、Lombok（了解）

一个 Java 库的插件；
简化代码，只需要添加一个注解即可；

使用步骤：

在 IDEA 中下载 Lombok 插件；
在 maven 中添加依赖：

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.22</version>
    <scope>provided</scope>
</dependency>

添加注解：

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

十、多对一的处理

多对一的理解：
- 多个学生对应一个老师；
- 如果对于学生，就是一个多对一的现象，即从学生这边关联一个老师！

10.1 数据库设计

结构图：
sql：

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

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

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

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

10.2 搭建测试环境

创建实例类：Student

// Lombok方式或手动创建get、set、toString、有参、无参构造
@Data
public class Student {
    private int id;
    private String name;
    // 学生需要关联一个老师（多对一方式）
    private Teacher teacher;
}

创建实例类：Teacher

// Lombok方式或手动创建get、set、toString、有参、无参构造
@Data
public class Teacher {
    private int id;
    private String name;
}

编写实体类对应的 Mapper 接口：
- 无论有没有需求，都应该写上，以备后来之需！
- StudentMapper：
```
public interface StudentMapper {
}
```
- TeacherMapper：
```
public interface TeacherMapper {    
}
```

编写 Mapper 接口对应的 mapper.xml 配置文件：

无论有没有需求，都应该写上，以备后来之需！
如放置在 resources 资源目录下，需要与接口类的包名一致；
StudentMapper.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.study.mybatis.dao.StudentMapper">
   
</mapper>

TeacherMapper.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.study.mybatis.dao.TeacherMapper">

</mapper>

在核心配置文件中，绑定注册的 Mapper 接口或者文件：

<!--使用class绑定接口-->
<mappers>
    <mapper class="com.study.mybatis.dao.TeacherMapper"/>
    <mapper class="com.study.mybatis.dao.StudentMapper"/>
</mappers>

测试环境搭建是否成功；

10.3 按查询嵌套处理

给 StudentMapper 接口增加方法：

// 获取所有学生及对应老师的信息
List<Student> getStudentList();

编写对应的 StudentMapper.xml 文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.study.mybatis.dao.StudentMapper">
    <!--
        思路：
            1.查询所有的学生信息
            2.根据查询出来的学生的tid，寻找对应的老师！子查询
    -->
    <select id="getStudentList" resultMap="studentTeacher">
        select id, name, tid from student
    </select>

    <resultMap id="studentTeacher" type="Student">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <!--
            复杂的属性,需要单独处理
            对象:association
            集合:collection
            select:对应子查询
         -->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>

    <!--
        当传递过来的参数，只有一个属性的时候，可以写任何值
        association中column多参数配置：
        column="{key=value,key=value}"
        键值对，key是传给下个sql的取值名称，value是sql查询的字段名
    -->
    <select id="getTeacher" resultType="Teacher">
        select * from teacher where id = #{id}
    </select>
</mapper>

@Test
public void TestStudentList() {
    SqlSession session = MybatisUtils.getSession();
    StudentMapper mapper = session.getMapper(StudentMapper.class);
    List<Student> studentList = mapper.getStudentList();
    for (Student student : studentList) {
        System.out.println(student);
    }
    session.close();
}

10.4 按结果嵌套处理

接口方法编写：

List<Student> getStudentList2();

编写对应的 mapper 文件：

<!--
    按查询结果嵌套处理
    思路：直接查询出结果，进行结果集的映射
-->
<select id="getStudentList2" resultMap="studentTeacher2">
    select s.id sid,s.name sname,t.name tname from student s,teacher t
    where s.tid=t.id
</select>
<resultMap id="studentTeacher2" type="Student">
    <id property="id" column="sid"/>
    <result property="name" column="sname"/>
    <!--关联对象property 关联对象在Student实体类中的属性-->
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/>
    </association>
</resultMap>

测试：

@Test
public void TestStudentList2() {
    SqlSession session = MybatisUtils.getSession();
    StudentMapper mapper = session.getMapper(StudentMapper.class);
    List<Student> studentList = mapper.getStudentList2();
    for (Student student : studentList) {
        System.out.println(
                "学生:" + student.getName()
                        + "\t老师:" + student.getTeacher().getName()
        );
    }
    session.close();
}

小结：

按照 查询进行嵌套 处理，就像 SQL 中的 子查询；
按照 结果进行嵌套 处理，就像 SQL 中的 联表查询；

十一、一对多的处理

一对多的理解：
- 一个老师拥有多个学生；
- 对于老师，一对多的现象，即一个老师，拥有一群学生（集合）；

11.1 实体类编写

搭建环境：参照多对一；
Student：

// Lombok方式或手动创建get、set、toString、有参、无参构造
@Data
public class Student {
    private int id;
    private String name;
    private int tid;
}

Teacher：

// Lombok方式或手动创建get、set、toString、有参、无参构造
@Data
public class Teacher {
    private int id;
    private String name;
    // 一个老师对应多个学生（集合）
    private List<Student> students;
}

11.2 按结果嵌套处理

编写 TeacherMapper 接口方法：

public interface TeacherMapper {
    // 获取指定老师，及老师下的所有学生
    // xml的取值#{tid}与@Param("tid")对应
    public Teacher getTeacher(@Param("tid") int id);
}

编写接口对应的 Mapper 配置文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.study.mybatis.dao.TeacherMapper">
    <!--
        思路:
            1. 从学生表和老师表中查出学生id，学生姓名，老师姓名
            2. 对查询出来的操作做结果集映射
            集合：使用collection
    -->
    <select id="getTeacher" resultMap="teacherStudent">
        select s.id sid, s.name sname, t.name tname, t.id tid
        from student s,
             teacher t
        where s.tid = t.id
          and t.id = #{tid};
    </select>

    <resultMap id="teacherStudent" type="Teacher">
        <id property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--ofType:实例类中,集合的泛型类型-->
        <collection property="students" ofType="Student">
            <id property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>
</mapper>

<!--使用class绑定接口-->
<mappers>
    <mapper class="com.study.mybatis.dao.TeacherMapper"/>
    <mapper class="com.study.mybatis.dao.StudentMapper"/>
</mappers>

测试：

@Test
public void testGetTeacher() {
    SqlSession session = MybatisUtils.getSession();
    TeacherMapper mapper = session.getMapper(TeacherMapper.class);
    Teacher teacher = mapper.getTeacher(1);
    System.out.println(teacher.getName());
    System.out.println(teacher.getStudents());
    session.close();
}

11.3 按查询嵌套处理

编写 TeacherMapper 接口方法：

public Teacher getTeacher2(@Param("tid") int id);

编写接口对应的 Mapper 配置文件：

<!--按查询嵌套处理-->
<select id="getTeacher2" resultMap="teacherStudent2">
    select * from teacher where id = #{tid}
</select>
<resultMap id="teacherStudent2" type="Teacher">
    <!--只映射不同的内容,id,name自动映射-->
    <!--column="id":teacher的id,传递给子查询-->
    <collection property="students" column="id" javaType="ArrayList" ofType="Student"
                select="getStudentByTeacherId"/>
</resultMap>
<select id="getStudentByTeacherId" resultType="Student">
    select * from student where tid = #{tid}
</select>

测试：

@Test
public void testGetTeacher() {
    SqlSession session = MybatisUtils.getSession();
    TeacherMapper mapper = session.getMapper(TeacherMapper.class);
    Teacher teacher = mapper.getTeacher2(1);
    System.out.println(teacher.getName());
    System.out.println(teacher.getStudents());
    session.close();
}

小结：

关联 - association：适用于 一对一，和 多对一；
集合 - collection：只用于 一对多 的关系；
JavaType 和 ofType：指定对象类型；
- JavaType：实体类中属性的类型；
- ofType：映射到 List 集合属性中实体类的类型（泛型中的约束类型）；
注意：
- 保证 SQL 的可读性，尽量通俗易懂；
- 根据实际要求，尽量编写性能更高的 SQL 语句；
- 注意属性名和字段不一致的问题；
- 注意一对多和多对一中：字段和属性对应的问题；
- 尽量使用 Log4j，通过日志来查看错误；

十二、动态 SQL

动态 SQL：根据不同的查询条件 , 生成不同的 SQL 语句；
- if
- choose (when, otherwise)
- trim (where, set)
- foreach

12.1 搭建环境

创建数据库表：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 NOT NULL COMMENT '浏览量'
) ENGINE=INNODB DEFAULT CHARSET=utf8mb4

创建 Mybatis 基础工程：
创建 IDutil 工具类：UUID

public class IDUtil {
    public static String getId() {
        // 去掉UUID的"-",将值返回
        return UUID.randomUUID().toString().replaceAll("-", "");
    }
}

编写实体类：

// Lombok方式或手动创建get、set、toString、有参、无参构造
@Data
public class Blog {
    private String id;
    private String title;
    private String author;
    // 数据表字段create_time,类属性名createTime,
    // 需在核心配置文件,设置下划线驼峰自动转换
    private Date createTime;
    private int views;
}

编写 Mapper 接口：

public interface BolgMapper {
}

编写 Mapper.xml 文件：

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

配置 mybatis 核心配置文件：
- 设置下划线驼峰自动转换；
- 设置别名；
- 注册 Mapper；

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

<typeAliases>
    <typeAlias type="com.study.mybatis.pojo.Blog" alias="Blog"/>
</typeAliases>

<!--使用class绑定接口-->
<mappers>
    <mapper class="com.study.mybatis.mapper.BolgMapper"/>
</mappers>

插入初始数据：

编写接口

int addBlog(Blog blog);

编写 Mapper.xml 文件：

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

创建初始化博客方法：

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

        Blog blog = new Blog();
        blog.setId(IDUtil.getId());
        blog.setTitle("Mybatis如此简单");
        blog.setAuthor("admin");
        blog.setCreateTime(new Date());
        blog.setViews(9999);

        mapper.addBlog(blog);

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

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

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

        session.close();
    }
}

12.2 if 语句

需求：
- 根据作者和标题，查询博客；
- 如果作者为空，只根据标题查询，反之，根据标题查询；
编写接口类：

// if 语句 根据作者和标题，查询
List<Blog> queryBlogIF(Map map);

编写 Mapper.xml 文件：

<!--
    if 语句:根据作者和标题，查询博客
    select * from blog where author = #{author} and title = #{title}
-->
<select id="queryBlogIF" parameterType="map" resultType="Blog">
    select * from blog where 1=1
    <if test="author!=null">
        and author=#{author}
    </if>
    <if test="title!=null">
        and title=#{title}
    </if>
</select>

测试：

@Test
public void testIf() {
    SqlSession session = MybatisUtils.getSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);
    HashMap map = new HashMap();
    map.put("author", "admin");
    map.put("title", "Mybatis如此简单");
    List<Blog> blogs = mapper.queryBlogIF(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }
    session.close();
}

问题：

上面查询语句 select * from blog where 1=1 ，当 map 为空，不需要使用 where 1=1，如果去掉，当 map 添加查询条件时，sql 语句将出错，所以需要动态添加 where；

12.3 choose 语句（when、otherwise）

choose 标签：类似 java 中的 switch 关键字，一般会与otherwise 共同搭配；
当有多个查询条件，只需要满足其中一个即可（其余不被执行）；
编写接口方法：

List<Blog> queryBlogChoose(Map map);

编写 Mapper.xml 文件：

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

测试：

@Test
public void testChoose() {
    SqlSession session = MybatisUtils.getSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);
    HashMap map = new HashMap();
    map.put("author", "admin");
    map.put("title", "Mybatis如此简单");
    map.put("views", "9999");
    List<Blog> blogs = mapper.queryBlogChoose(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }
    session.close();
}

12.4 trim（where、set）

where：

如果它包含的标签中，有返回值，就在动态插入一个 where ；
如果标签返回的内容，是以 AND 或 OR 开头，会自动剔除；
修改上面的 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：

set 标签：用来替代 sql 中传统的 set，一般配合 if 标签使用；
作用：用于 update 的 sql 中，把末尾多余的逗号去掉；
编写接口方法：

int updateBlog(Map map);

编写 Mapper.xml 文件：

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

测试：

@Test
public void testSet() {
    SqlSession session = MybatisUtils.getSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);
    HashMap map = new HashMap();
    map.put("author", "test");
    map.put("title", "动态SQL");
    map.put("id", "dcbb78122be34654bb8750447ede2257");
    mapper.updateBlog(map);
    session.close();
}

所谓的动态 SQL，本质还是 SQL 语句，只是可以在 SQL 层面，去执行一个逻辑代码；

12.5 SQL 片段

将重复代码抽取出来，使用时直接调用，增加代码的重用性，简化代码；
使用 SQL 标签抽取公共部分：

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

在需要使用的地方，使用 include 标签引用：

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

注意：
- 最好基于单表来定义 SQL 片段！
- 不要存在 where 标签；

12.6 Foreach 语句

foreach 标签：可以迭代对象的属性、数组、集合、对象数组、对象集合；
需求：查询 blog 表中 id 分别为 1、2、3 的信息；
- 先将数据表的 id 修改为 1、2、3；
编写接口：

List<Blog> queryBlogForeach(Map map);

编写 SQL 语句：

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

测试：

@Test
public void testForeach() {
    SqlSession session = MybatisUtils.getSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);
    HashMap map = new HashMap();
    List<Integer> ids = new ArrayList<Integer>();
    ids.add(1);
    ids.add(2);
    ids.add(3);
    map.put("ids", ids);
    List<Blog> blogs = mapper.queryBlogForeach(map);
    System.out.println(blogs);
    session.close();
}

小结：

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

十三、缓存（了解）

13.1 简介

什么是缓存 Cache：
- 存在内存中的临时数据；
- 将用户经常查询的数据，放在缓存（内存）中，用户查询数据，不用从磁盘上（关系型数据库、数据文件）查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题；
为什么使用缓存：
- 减少和数据库的交互次数，减少系统开销，提高系统效率；
什么样的数据能 使用缓存：
- 经常查询，并且不经常改变的数据；

13.2 Mybatis 缓存

MyBatis 包含一个非常强大的查询缓存特性，可以非常方便的定制和配置缓存；
缓存可以极大的，提升查询效率；

MyBatis 系统中，默认定义了两级缓存：

一级缓存（默认）：
- 也称为本地缓存，属于 SQLSession 级别的缓存；
二级缓存：
- 需要手动开启和配置，是基于 namespace 级别的缓存；
- 每一个 mapper 都会对应一个缓存;
为了提高扩展性，MyBatis 定义了缓存接口 Cache，可以通过实现 Cache 接口，来自定义二级缓存；

缓存清除策略：

LRU (默认) – 最近最少使用：移除最长时间不被使用的对象；
FIFO – 先进先出：按对象进入缓存的顺序来移除它们；
SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象；
WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象；

13.3 一级缓存

一级缓存，也叫本地缓存：
- 与数据库同一次会话期间，查询到的数据，会放在本地缓存中；
- 以后如果需要获取相同的数据，直接从缓存中取，不用再去查询数据库；

测试：

搭建环境（user 表），并开启日志，方便查看结果；
编写接口方法：

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

接口对应的 Mapper 文件：

<select id="getUserById" resultType="User">
    select * from user where id = #{id}
</select>

测试：在一个 Session 中，查询两次相同记录

@Test
public void getUser() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    // 第一次查询
    User user1 = mapper.getUserById(1);
    System.out.println(user1);
    // 第二次查询
    User user2 = mapper.getUserById(1);
    System.out.println(user2);
    // 判断两个对象是否相同
    System.out.println(user1 == user2);
    session.close();
}

结果分析：

一级缓存失效的四种情况：

查询不同的内容；
增、删、改操作，有可能会改变原来的数据，所以必定会刷新数据；
查询不同的 Mapper.xml；

手动清理缓存；

// 手动清理缓存
session.clearCache();

小结：

一级缓存是默认开启的，只在一次 SqlSession 中有效（拿到链接到关闭链接这个区间段）；
一级缓存就是一个 Map 集合；

13.4 二级缓存

二级缓存：也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存；
基于 namespace 级别的缓存，一个名称空间，对应一个二级缓存；

工作机制：

一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
如果当前会话关闭，这个会话对应的一级缓存就没了；
需求：会话关闭后，一级缓存中的数据，被保存到二级缓存中，新的会话查询信息，可以从二级缓存中获取内容；
不同的 mapper 查出的数据，会放在自己对应的缓存（map）中；

使用步骤：

开启全局缓存：mybatis-config.xml

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

在使用二级缓存的 Mapper 中开启：

<!--在当前Mapper.xml中使用二级缓存-->
<cache/>

也可以自定义参数：

<!--在当前Mapper.xml中使用二级缓存 60秒刷新-->
<cache eviction="FIFO"
       flushInterval="60000"
       size="512"
       readOnly="true"
/>

测试：

@Test
public void getUser() {
    SqlSession session = MybatisUtils.getSession();
    // 创建另一个session
    SqlSession session2 = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    UserMapper mapper2 = session2.getMapper(UserMapper.class);
    // 第一次查询
    User user1 = mapper.getUserById(1);
    System.out.println(user1);
    session.close();
   
    // 第二次查询
    User user2 = mapper2.getUserById(1);
    System.out.println(user2);
    // 判断两个对象是否相同
    System.out.println(user1 == user2);
    session.close();
}

发现问题：未设置相关参数会报错，提示实体类未序列化

Cause: java.io.NotSerializableException:

解决方法：将所有的实体类，实现序列化接口：

public class User implements Serializable {
}

小结：

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

13.5 缓存原理

执行顺序：
- 查询二级缓存；
- 查询一级缓存；
- 查询数据库；

13.6 自定义缓存 EhCache（了解）

Ehcache 是一种广泛使用的 Java 分布式缓存，用于通用缓存；

使用步骤：

导入依赖：

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

在 Mapper.xml 中使用对应的缓存即可：

<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

创建 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"/>    
</ehcache>

MyBatis 基础

一、Mybatis 简介

1.1 什么是 MyBatis

1.2 持久化

1.3 持久层

1.4 为什么需要 Mybatis

二、使用 Mybatis

2.1 搭建环境

2.2 创建模块（子项目）

2.3 可能出现的问题：

三、CRUD 操作

3.1 namespace

3.2 select 查询

3.3 insert 插入

3.4 update 修改

3.5 delete 删除

3.6 使用万能的 Map

3.7 模糊查询

四、配置解析

4.1 核心配置文件

4.2 环境配置（environments）

4.3 属性（properties）

4.4 类型别名（typeAliases）

4.5 设置（settings）

4.6 其它设置（了解）

4.7 映射器（mappers）

4.8 生命周期和作用域

五、ResultMap 结果集映射

5.1 查询为 null

5.2 解决方案

5.3 ResultMap

六、日志

6.1 日志工厂

6.2 Log4j

七、分页的实现

7.1 使用 limit 分页（掌握）

7.2 RowBounds 分页（了解）

7.4 分页插件 PageHelper（了解）

八、使用注解开发

8.1 面向接口编程

8.2 利用注解开发

8.3 注解 CRUD 操作

8.4 关于 @Param

8.5 #{} 与 ${} 的区别

{}（推荐使用）：预编译，防止 sql 注入；

九、Lombok（了解）

十、多对一的处理

10.1 数据库设计

10.2 搭建测试环境

10.3 按查询嵌套处理

10.4 按结果嵌套处理

十一、一对多的处理

11.1 实体类编写

11.2 按结果嵌套处理

11.3 按查询嵌套处理

十二、动态 SQL

12.1 搭建环境

12.2 if 语句

12.3 choose 语句（when、otherwise）

12.4 trim（where、set）

12.5 SQL 片段

12.6 Foreach 语句

十三、缓存（了解）

13.1 简介

13.2 Mybatis 缓存

13.3 一级缓存

13.4 二级缓存

13.5 缓存原理

13.6 自定义缓存 EhCache（了解）

猜你喜欢

热点阅读