NightWatch

# MyBatis从入门到精通

# MyBatis简介

# MyBatis简介

MyBatis最初是Apach的一个开源项目iBatis，2020年6月被基金会迁移到了Google Code，iBatis3.x随后正式更名为MyBatis。

iBatis是一个基于Java的持久层框架，提供SQL Maps和Data Access Objects

# MyBatis特性

  1. MyBatis支持定制化SQL，存储过程以及高级映射
  2. MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集
  3. MyBatis可以使用简单的XML或者注解用于配置和原始映射，将接口和Java的POJO映射为数据库的记录
  4. MyBatis是一个半自动化的ORM框架

# MyBatis和其他持久层框架的对比

  • JDBC
    • SQL夹杂在Java代码中耦合度高
    • SQL需求变化时，不易维护
    • 代码冗长，开发效率低
  • Hibernate和JPA
    • 操作简便，开发效率低
    • 长难复杂SQL需要绕过框架
    • 内部生成SQL，不容易做特殊优化
    • 基于全映射的全自动框架，大量字段POJO进行部分映射比较困难
    • 反射操作太多，导致数据库性能下降
  • MyBatis
    • 轻量级，性能出色
    • SQL和Java编码分开，功能边界清晰
    • 开发效率略低于Hibernate

# MyBatis下载

# 搭建MyBatis

# 开发环境

IDE：IDEA2023.3.4

构建工具：maven3.8.6

MySQL版本：MySQL8.0

MyBatis版本：MyBatis3.5.7

# 创建Maven工程

# 引入依赖

<!-- Mybatis核心 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.7</version>
</dependency>
<!-- junit测试 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!-- MySQL驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.12</version>
</dependency>

# Mybatis核心配置文件

习惯上命名mybatis-comfig.xml,放在resources资源目录下

<?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"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    </mappers>
</configuration>

# 创建mapper接口

Mybatis的mapper接口相当于以前的dao。区别在于mapper仅仅是接口，不需要提供实现类。

package com.rong.hui.mapper;

public interface UserMapper {

    // 添加用户信息
    int insertUser();
}

# 创建MyBatis的映射文件

相关概念：ORM（Object Relationship Mapping）对象关系映射

1、映射文件命名规则

表所对应的实体类的类名+Mapper.xml

例如：表t_user，映射的实体类为User，所对应的映射文件为UserMapper.xml

一个映射文件对应一个实体类，对应一张表的操作

映射文件存放位置：src/main/resources/mappers目录下

2、mybatis中可以面向接口操作数据，

  • mapper接口的全类名和映射文件的命名空间保持一致
  • mapper接口的方法名和映射文件中编写sql标签的id属性值一致
<?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="org.mybatis.example.BlogMapper">
  <select id="selectBlog" resultType="Blog">
    select * from Blog where id = #{id}
  </select>
</mapper>

# 测试添加功能

public class MyBatisTest {
    @Test
    public void testMyBatis() throws IOException {
        // 读取核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
        // 获取sqlSessionFactoryBuilder
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 通过核心配置文件所对应的字节流创建工厂类对象SqlSessionFactory，生产sqlSession对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(resourceAsStream);
        // 获取sqlSession对象,此时sqlSession操作的sql语句必须手动提交或回滚事务
        // SqlSession sqlSession = sqlSessionFactory.openSession();
        // 获取sqlSession对象,此时sqlSession操作的sql语句会自动提交
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        // 获取mapper接口对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        // 测试功能
        int result = mapper.insertUser();
        // 提交事务
        // sqlSession.commit();
        System.out.println("result:"+result);
    }
}

注意：sqlSession默认不自动提交事务，如果需要自动提交事务，需要设置SqlSession sqlSession = sqlSessionFactory.openSession(true);

# 加入log4j日志功能

  1. 引入依赖
<!-- log4j日志 -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>
  1. 加入log4j的配置文件log4j.xml，位置为src/main/resources/log4j.xml

日志的级别：从上到下内容越来越详细

  • FATAL(致命)：程序出现严重错误，可能导致程序崩溃或无法运行
  • ERROR(错误)：程序出现错误，仍在尝试执行任务
  • WARN(警告)：存在警告，但程序仍在按预期运行
  • INFO(信息)：正常的操作和状态信息，相对简洁，不包含细节
  • DEBUG(调试) ：输出内容非常详细，对程序性能产生一定影响

通常DEBUG在测试开发阶段使用，帮助开发者了解程序运行细节，而ERROR和FATAL只在生产环境使用，用于确保系统稳定运行

通用模板

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

# MyBatis增删改查

<mapper namespace="com.rong.hui.mapper.UserMapper">
    <insert id="insertUser">
        insert into t_user values(null,'admin','123456',23,'男','12345@qq.com')
    </insert>

    <!---->
    <update id="updateUser">
        update t_user set username = '张三' where id = 4;
    </update>

    <delete id="deleteUser">
        delete from t_user where id = 5
    </delete>

    <select id="getUserById" resultType="com.rong.hui.pojo.User">
        select * from t_user where id = 3;
    </select>
</mapper>

注意：

  1. 查询标签的select必须设置属性resultType或resultType
    • resultType：自动映射，用于属性名和表中字段一致的情况
    • resultType：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况
  2. 当查询数据为多条时，不能使用实体类作为返回值，只能使用集合

# MyBatis核心配置文件详解

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--MyBatis核心配置文件标签顺序，没有可以不写，顺序不能乱
        properties、settings、typeAliases、typeHandlers、objectFactory、objectWrapperFactory、
        reflectorFactory、plugins、environments、databaseIdProvider、mappers
    -->
    <!--引入properties文件，并使用${属性名}方式获取变量-->
    <properties resource="jdbc.properties"/>

    <!--设置类型标签-->
    <typeAliases>
        <!--type为全限定类名，alias为别名，使用的时候不区分大小写，如果不写，默认就是类名User-->
        <!--<typeAlias type="com.rong.hui.pojo.User" alias="User"></typeAlias>-->

        <!--以包为单位，将包下所有类型设置默认的类型别名，即类名且不区分大小写-->
        <package name="com.rong.hui.pojo"></package>
    </typeAliases>

    <!--配置多个连接数据库的环境，default设置默认环境的id-->
    <environments default="development">
        <!--id不能重复-->
        <environment id="development">
            <!--设置事务管理方式：type="JDBC|MANAGED"
                JDBC:表示操作SQL时，事务的提交和回滚需要手动处理
                MANAGED:表示被管理，例如Spring
            -->
            <transactionManager type="JDBC"/>
            <!--配置数据源使用连接池：type="POOLED|UNPOOLED|JNDI"
                POOLED:表示使用数据库连接池缓存数据库连接
                UNPOOLED：表示不使用数据库连接池
                JNDI:表示使用上下文中的数据源
            -->
            <dataSource type="POOLED">
                <!--设置连接数据库的驱动-->
                <property name="driver" value="${jdbc.driver}"/>
                <!--设置连接数据库的地址-->
                <property name="url" value="${jdbc.url}"/>
                <!--设置连接数据库的用户名-->
                <property name="username" value="${jdbc.username}"/>
                <!--设置连接数据库的密码-->
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <!--<mapper resource="mapper/UserMapper.xml"/>-->

        <!--以包为单位，将包下所有映射文件引入核心配置文件
        注意：
            1.mapper接口所在的包要和映射文件所在的包一致,src/main/java和  src/main/resources下的包名要一样
            2.mapper接口要和映射文件名字一致,UserMapper.java UserMapper.xml
        -->
        <package name="com.rong.hui.mapper"></package>
    </mappers>
</configuration>

jdbc.properties文件

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&serverTimezone=UTC
jdbc.username=root
jdbc.password=123456

# MyBatis获取参数值的两种方式

两种方式：

  • ${}本质是字符串拼接
  • #{}本质是占位符赋值

# 单个字面量类型的参数

mapper接口方法的参数为单个，可以使用${}和#{}以任意的名称获取参数值，但是需要注意${}的单引号问题

<select id="GetUserByUsername" resultType="User">
    select * from t_user where username = #{username}
</select>

<select id="GetUserByUsername" resultType="User">
	select * from t_user where username = '${username}'
</select>

# 多个字面量类型的参数

mapper接口方法的参数为多个，mybatis底层会把若干个参数放在一个map集合中，以两种方式存储：

  1. 以arg0,arg1为键，以参数为值
  2. 以param1,param2为键，以参数为值
<select id="checkLogin" resultType="User">
    select * from t_user where username = #{arg0} and password = #{arg1}
</select>

<select id="checkLogin" resultType="User">
    select * from t_user where username = '${param1}' and password = '${param2}'
</select>

# map集合类型的参数

mapper接口方法的参数为多个，可手动将多个参数放在map中

@Test
public void testCheckLoginByMap(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    Map<String, Object> map = new HashMap<>();
    map.put("username","张三");
    map.put("password","123456");
    User user = mapper.checkLoginByMap(map);
    System.out.println(user);
}

<select id="checkLoginByMap" resultType="User">
    select * from t_user where username = #{username} and password = #{password}
</select>

# 实体类型的参数

通过实体类对象中的属性名获取属性值

<insert id="insertUser" >
    insert into t_user values(null,#{username},#{password},#{age},#{sex},#{email})
</insert>

@Test
public void testInsertUser(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    mapper.insertUser(new User(null,"huyadish","12345678",26,"男","123456@qq.com"));
}

# 使用@Param标识参数

  • mapper接口
    User checkLoginByParam(@Param("username") String username, @Param("password") String password);
  • 测试
@Test
public void testCheckLoginByParam(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
    User user = mapper.checkLoginByParam("张三", "123456");
}

注意：

  1. 有多个字面量参数的情况，不能直接用属性名访问
  2. @Param方式可以通过属性名访问，也可以通过param1，param2访问
  3. 实体类型、map类型必须用属性名访问

推荐使用@Param和实体方式

# Mybatis的各种查询功能

# 查询一个实体类对象

// 通过实体类对象接收
User getUserById(@Param("id") Integer id);
// 通过实体数组接收
List<User> getUserById(@Param("id") Integer id);

# 查询一个List集合

// 通过实体数组接收
List<User> getAllUser();

# 查询单个数据

// 查询单个数据
Integer getCount();

用Integer接收

// 这里resultType可以写Integer、integer、Int、int都可以
<select id="getCount" resultType="java.lang.Integer">
    select count(*) from t_user
</select>

注：mybatis为基本数据类型设置了类型别名，且不区分大小写

# 查询一条数据为map集合

<select id="getUserByIdToMap" resultType="java.util.Map">
    select * from t_user where id = #{id}
</select>

// 使用map对象接收单条数据
Map<String,Object> getUserByIdToMap(@Param("id") Integer id);

注：多表查询的结果可以用map接收

# 查询多条数据为map集合

// 通过map的List接收多条数据
List<Map<String,Object>> getAllUserToMap();

// 通过map接收多条数据，但是要指定mapkey为哪个字段
@MapKey("id")
Map<String,Object> getAllUserToMap();

# 特殊SQL的执行

# 模糊查询

<select id="getUserByLike" resultType="com.rong.hui.pojo.User">
    // 使用${}拼接字符串
    select * from t_user where username like '%${username}%'
    // 使用concat函数
    select * from t_user where username like concat('%',#{username},'%')
    // 使用#{}占位符
    select * from t_user where username like '%'#{username}'%'
</select>

# 批量删除

// 传入类似于"1,2,3"的ids字符串
int deleteBatch(@Param("ids") String ids);

<delete id="deleteBatch">
    delete from t_user where id in (${ids})
</delete>

注：批量删除使用${}

# 动态设置表名

// 表名作为参数输入
List<User> getUserByTableName(@Param("tableName") String tableName);

<select id="getUserByTableName" resultType="User">
    select * from ${tableName}
</select>

注：动态设置表名使用${}

# 添加功能获取自动递增主键

// 添加用户信息
void insertUser(User user);

// 使用自动生成的主键，并且自增的主键将字放在参数的id属性中
<insert id="insertUser" useGeneratedKeys="true" keyProperty="id" >
    insert into t_user values (null,#{username},#{password},#{age},#{sex},#{email})
</insert>

@Test
public void testInsertUser(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
    User user = new User(null, "李四", "12345", 23, "男", "test@qq.com");
    // 添加用户后新增的id会存放在user对象中
    mapper.insertUser(user);
    System.out.println(user);
}

注：insert、update、delete返回的结果都是收影响的行数，得用特殊的方法返回自增的主键

# 自定义映射resultMap

# 处理映射关系

解决字段名和属性名不一致的情况：

  1. 为字段起别名，保持和属性名一致
<select id="getAllEmp" resultType="com.rong.hui.pojo.Emp">
    select eid,emp_name,age,sex,email from t_emp
</select>
  1. 全局配置下划线转驼峰
<settings>
    <setting name="mapUnderscoreToCamelCase" value="true"></setting>
  1. 通过resultmap设置自定义映射关系
// id属性为唯一标识，不能重复, type设置映射关系中的实体类类型
<resultMap id="empResultMap" type="Emp">
    // id设置主键映射关系 property设置实体属性，column设置字段名
    <id property="eid" column="eid"></id>
    // result设置其他属性映射关系
    <result property="empName" column="emp_name"></result>
    <result property="age" column="age"></result>
    <result property="sex" column="sex"></result>
    <result property="email" column="email"></result>
</resultMap>

<select id="getAllEmp" resultMap="empResultMap">
    select * from t_emp
</select>

注意：

  1. 如果只是解决字段名不一致问题，只需要全局开启mapUnderscoreToCamelCase就行
  2. resultMap强大的地方在于可以处理一对多和多对一映射

# 多对一映射

# 使用级联属性

<!--多对一映射方式一，级联属性赋值-->
<resultMap id="empAndDeptResultMapOne" type="Emp">
    <id property="eid" column="eid"></id>
    <result property="empName" column="emp_name"></result>
    <result property="age" column="age"></result>
    <result property="sex" column="sex"></result>
    <result property="email" column="email"></result>
    <result property="dept.did" column="did"></result>
    <result property="dept.deptName" column="dept_name"></result>
</resultMap>

# 使用association

<!--多对一映射方式一，使用association-->
<resultMap id="empAndDeptResultMapTwo" type="Emp">
    <id property="eid" column="eid"></id>
    <result property="empName" column="emp_name"></result>
    <result property="age" column="age"></result>
    <result property="sex" column="sex"></result>
    <result property="email" column="email"></result>
    <association property="dept" javaType="Dept">
        <id property="did" column="did"></id>
        <result property="deptName" column="dept_name"></result>
    </association>
</resultMap>

# 分步查询

在resultMap中定义分步查询

<!--多对一映射方式三，使用分步查询-->
<resultMap id="empAndDeptByStepResultMap" type="Emp">
    <id property="eid" column="eid"></id>
    <result property="empName" column="emp_name"></result>
    <result property="age" column="age"></result>
    <result property="sex" column="sex"></result>
    <result property="email" column="email"></result>
    <!--select是分布查询第二步方法的全限定名，column是关联的列-->
    <association property="dept"
                 select="com.rong.hui.mapper.DeptMapper.getEmpAndDeptByStepTwo"
                 column="eid">
    </association>
</resultMap>

第一步：先查emp

<select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap">
	select * from t_emp where eid = #{eid}
</select>

第二步：再查关联的dept

<select id="getEmpAndDeptByStepTwo" resultType="Dept">
    select * from t_dept where did = #{did}
</select>

# 延迟加载

使用分步查询的好处？

  • 可以实现延迟加载，需要设置配置信息：
    1. lazyLoadingEnabled：延迟加载的全局开关。默认开启。当开启时，所有关联对象都会延迟加载
    2. aggressiveLazyLoading：当开启时，任何方法调用都会加载该对象的所有属性（包含关联属性），默认关闭

1、开启懒加载的情况：

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

测试类：

@Test
public void testEmpAndDeptByStep(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    Emp emp = mapper.getEmpAndDeptByStepOne(3);
    // 访问了某个属性才会去执行
    System.out.println(emp.getEmpName());
    System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++");
    System.out.println(emp.getDept());
}

输出日志：

DEBUG 06-28 15:15:53,434 ==>  Preparing: select * from t_emp where eid = ? (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:15:53,463 ==> Parameters: 3(Integer) (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:15:53,519 <==      Total: 1 (BaseJdbcLogger.java:137) 
王五
+++++++++++++++++++++++++++++++++++++++++++++++
DEBUG 06-28 15:15:53,521 ==>  Preparing: select * from t_dept where did = ? (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:15:53,521 ==> Parameters: 3(Integer) (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:15:53,523 <==      Total: 1 (BaseJdbcLogger.java:137) 
Dept{did=3, deptName='C'}

可以看到员工表查询Sql和部门表查询sql是分步执行的

2、未开启懒加载的情况

DEBUG 06-28 15:19:12,462 ==>  Preparing: select * from t_emp where eid = ? (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:19:12,484 ==> Parameters: 3(Integer) (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:19:12,506 ====>  Preparing: select * from t_dept where did = ? (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:19:12,506 ====> Parameters: 3(Integer) (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:19:12,508 <====      Total: 1 (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:19:12,509 <==      Total: 1 (BaseJdbcLogger.java:137) 
王五
+++++++++++++++++++++++++++++++++++++++++++++++
Dept{did=3, deptName='C'}

可以看到SQL语句是一起执行的

<association property="dept"
             select="com.rong.hui.mapper.DeptMapper.getEmpAndDeptByStepTwo"
             column="eid"
             fetchType="eager"
>
</association>

注意：可在association中设置fetchType属性控制当前查询是否需要延迟加载，可选值为eager或lazy，可以精细化控制延迟加载

# 一对多映射

# 使用collection标签

Dept实体属性

private List<Emp> emps;

mapper映射文件

<resultMap id="deptAndEmpResultMap" type="Dept">
    <id property="did" column="did"></id>
    <result property="deptName" column="dept_name"></result>
    
    <!--这里property是实体属性，ofType是集合中存放的实体属性-->
    <collection property="emps" ofType="Emp">
        <id property="eid" column="eid"></id>
        <result property="empName" column="emp_name"></result>
        <result property="age" column="age"></result>
        <result property="sex" column="sex"></result>
        <result property="email" column="email"></result>
    </collection>
    
</resultMap>

<select id="getDeptAndEmp" resultMap="deptAndEmpResultMap">
    select * from t_dept left join t_emp on t_dept.did = t_emp.did where t_dept.did = #{did}
</select>

测试

@Test
public void testGetDeptAndEmp(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
    Dept dept = mapper.getDeptAndEmp(2);
    System.out.println(dept);
}

输出日志：

DEBUG 06-28 15:40:49,685 ==>  Preparing: select * from t_dept left join t_emp on t_dept.did = t_emp.did where t_dept.did = ? (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:40:49,705 ==> Parameters: 2(Integer) (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:40:49,723 <==      Total: 2 (BaseJdbcLogger.java:137) 
Dept{did=2, deptName='B', emps=[Emp{eid=2, empName='李四', age=32, sex='男', email='12345@qq.com', dept=null}, Emp{eid=4, empName='赵六', age=23, sex='女', email='12345@qq.com', dept=null}]}

可以看到emps属性中存放了两条员工信息

# 分步查询

使用collection配置一对多分步查询

<resultMap id="deptAndEmpResultMapByStep" type="Dept">
    <id property="did" column="did"></id>
    <result property="deptName" column="dept_name"></result>
    <!--这里property是实体属性，ofType是集合中存放的实体属性,select是分步查询的sql,column是关联的列-->
    <collection property="emps" select="com.rong.hui.mapper.EmpMapper.getDeptAndEmpByStepTwo" column="did" ofType="Emp"></collection>
</resultMap>

输出日志

DEBUG 06-28 15:57:09,588 ==>  Preparing: select * from t_dept where t_dept.did = ? (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:57:09,612 ==> Parameters: 2(Integer) (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:57:09,664 <==      Total: 1 (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:57:09,667 ==>  Preparing: select * from t_emp where did = ? (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:57:09,668 ==> Parameters: 2(Integer) (BaseJdbcLogger.java:137) 
DEBUG 06-28 15:57:09,670 <==      Total: 2 (BaseJdbcLogger.java:137) 
Dept{did=2, deptName='B', emps=[Emp{eid=2, empName='李四', age=32, sex='男', email='12345@qq.com', dept=null}, Emp{eid=4, empName='赵六', age=23, sex='女', email='12345@qq.com', dept=null}]}

可以看到先执行部门表的查询、再执行与部门关联的员工表的查询

总结：

  1. association用于处理多对一映射，并且支持分步查询
  2. collection用于处理一对多的情况，并且支持分步查询
  3. 分步查询需要在实体对象中添加关联的属性
  4. 懒加载需要开启全局配置

# 动态SQL

# if

作用：根据test属性表达式决定标签中内容是否要拼接到SQL中

<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp where 1=1
    <if test="empName != null and empName != ''">
        and emp_name = #{empName}
    </if>
    <if test="age != null and age != ''">
        and age = #{age}
    </if>
    <if test="sex != null and sex != ''">
        and sex = #{sex}
    </if>
</select>

# where

作用：

  • 当where标签中有内容时，自动生成where关键字，并且将内容前面多余的and或or去掉，
  • 当where标签中没有内容是，不会生成where关键字

注意：where不能去除内容后面多余的and或or

<select id="getEmpByConditionOne" resultType="Emp">
    select * from t_emp
    <where>
        <if test="empName != null and empName != ''">
            and emp_name = #{empName}
        </if>
        <if test="age != null and age != ''">
            and age = #{age}
        </if>
        <if test="sex != null and sex != ''">
            sex = #{sex}
        </if>
    </where>
</select>

# trim

作用：

  • prefix|suffix：为trim标签中内容前面或后面添加指定内容，
  • prefixOverrides|suffixOverrides：为trim标签中内容前面或后面去掉指定内容
  • 当标签没有内容时，trim没有任何效果
    <select id="getEmpByConditionTwo" resultType="Emp">
        select * from t_emp
        <trim prefix="where" suffix="" prefixOverrides="" suffixOverrides="and|or">
            <if test="empName != null and empName != ''">
                emp_name = #{empName} and
            </if>
            <if test="age != null and age != ''">
                age = #{age} or
            </if>
            <if test="sex != null and sex != ''">
                sex = #{sex}
            </if>
        </trim>
    </select>

# choose、when、otherwise

作用：从若干条件中选择一项拼接到SQL,并且可以指定默认条件，类似于switch语句

<select id="getEmpByConditionThree" resultType="Emp">
    select * from t_emp
    <where>
        <choose>
            <when test="empName != null and empName != ''">emp_name = #{empName}</when>
            <when test="age != null and age != ''">age = #{age}</when>
            <when test="sex != null and sex != ''">sex = #{sex}</when>
            <otherwise> did = 1</otherwise>
        </choose>
    </where>
</select>

# foreach

# 批量删除

作用：可用于批量操作

属性：collection为需要循环的数组或集合，item为数组或集合中的每个数据，separator分隔符，open|close是对整个循环结果添加符合

int batchDeleteByArray(@Param("eids") Integer[] eids);

<delete id="batchDeleteByArray">
    delete from t_emp where eid in
    <foreach collection="eids" item="eid" separator="," open="(" close=")">
        #{eid}
    </foreach>
</delete>

或者可以简写为

<delete id="batchDeleteByArray">
    delete from t_emp
    <where>
        <foreach collection="eids" item="eid" separator="or">
            eid = #{eid}
        </foreach>
    </where>
</delete>

# 批量添加

int batchInsertByList(@Param("emps") List<Emp> emps);

<insert id="batchInsertByList">
    insert into t_emp values
    <foreach collection="emps" item="emp" separator=",">
        (null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},null)
    </foreach>
</insert>

# SQL片段

<sql id="empColumns">eid,emp_name,age,sex,email</sql>

<include refid="empColumns"></include>

# MyBatis缓存

# MyBatis的一级缓存

一级缓存是SqlSession级别的，默认开启，通过同一个SqlSession查询的数据会被缓存，下次查询相同数据，就会从缓存中直接获取，不会从数据库访问。

一级缓存失效的四个条件：

  1. 不同的sqlSession对应不同的一级缓存
  2. 同一个sqlSession但是查询条件不同
  3. 同一个sqlSession两次查询期间执行了任何一次增删改操作
  4. 同一个sqlSession两次查询期间手动清空了缓存
@Test
public void testCache(){
    SqlSession sqlSession1 = SqlSessionUtils.getSqlSession();
    CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
    Emp emp1 = mapper1.getEmpByID(1);
    System.out.println(emp1);

    // 相同的sqlSession查询的数据会被缓存，这里的sql不会执行
    CacheMapper mapper2 = sqlSession1.getMapper(CacheMapper.class);
    Emp emp2 = mapper2.getEmpByID(1);
    System.out.println(emp2);

    // 重新获取sqlSession,那么相同的查询是不会被缓存的，这里的sql会执行
    SqlSession sqlSession2 = SqlSessionUtils.getSqlSession();
    CacheMapper mapper3 = sqlSession2.getMapper((CacheMapper.class));
    Emp emp3 = mapper3.getEmpByID(1);
    System.out.println(emp3);
}

# MyBatis的二级缓存

二级缓存是SqlSessionFactory级别的，通过SqlSessionFactory创建的SqlSession查询的结果会被缓存

二级缓存开启的条件：

  1. 核心配置文件中配置cacheEnabled="true"，默认为true，不用设置
  2. 映射文件中设置cache标签
  3. 二级缓存必须在SqlSession关闭或提交后有效
  4. 查询数据转换的实体类类型必须实现序列化接口

二级缓存失效的条件：

  1. 两次查询之间进行了任意的增删改

测试方法

@Test
public void testTwoCache(){
    try {
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

        SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
        CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
        Emp emp1 = mapper1.getEmpByID(1);
        System.out.println(emp1);
        sqlSession1.close();

        // 同一个sqlSessionFactory创建出的sqlSession，查询结果会被缓存
        SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
        CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
        Emp emp2 = mapper2.getEmpByID(1);
        System.out.println(emp2);
        sqlSession2.close();
    } catch (IOException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }
}

输出结果

DEBUG 07-02 11:03:05,705 Cache Hit Ratio [com.rong.hui.mapper.CacheMapper]: 0.0 (LoggingCache.java:60) 
DEBUG 07-02 11:03:05,838 ==>  Preparing: select * from t_emp where eid=? (BaseJdbcLogger.java:137) 
DEBUG 07-02 11:03:05,859 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:137) 
DEBUG 07-02 11:03:05,878 <==      Total: 1 (BaseJdbcLogger.java:137) 
Emp{eid=1, empName='张三', age=23, sex='男', email='12345@qq.com', dept=null} 
DEBUG 07-02 11:03:05,900 Cache Hit Ratio [com.rong.hui.mapper.CacheMapper]: 0.5 (LoggingCache.java:60) 
Emp{eid=1, empName='张三', age=23, sex='男', email='12345@qq.com', dept=null}

可以看到执行了一次查询，并且显示缓存命中率

# 二级缓存相关配置

cache标签可以设置一些属性

  • eviction：缓存回收策略
    • LRU：最近最少使用的，移除长时间不使用的对象
    • FIFO：先进先出：按对象进入缓存的顺序来移除它们
    • SOFT：软引用：基于垃圾回收器状态和软引用规则移除对象
    • WEAK：弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象
  • flushInterval：刷新间隔，正整数，单位毫秒
    • 默认没有刷新间隔，调用增删改语句时刷新
  • size：引用数目，正整数，代表最多可以缓存多少个对象，默认 1024
  • readOnly：只读，true/false
    • true就是共享缓存实例，不能修改
    • false就是返回缓存对象的拷贝，会慢一些

# 缓存查询顺序

  1. 先查二级缓存
  2. 如果二级缓存没有，查询一级缓存
  3. 如果一级缓存也没有，再查数据库
  4. SqlSession关闭后，一级缓存的数据会写入二级缓存

# 整合第三方缓存EHCache

# 添加依赖

<!-- Mybatis EHCache整合包 -->
<dependency>
	<groupId>org.mybatis.caches</groupId>
	<artifactId>mybatis-ehcache</artifactId>
	<version>1.2.1</version>
</dependency>
<!-- slf4j日志门面的一个具体实现 -->
<dependency>
	<groupId>ch.qos.logback</groupId>
	<artifactId>logback-classic</artifactId>
	<version>1.2.3</version>
</dependency>

# Jar包功能

jar包名称 作用
mybatis-ehcache Mybatis和EHCache的整合包
ehcache EHCache核心包
slf4j-api SLF4J日志门面包
logback-classic 支持SLF4J门面接口的一个具体实现

# 配置文件

名字必须叫ehcache.xml

<?xml version="1.0" encoding="utf-8" ?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    <!-- 磁盘保存路径 -->
    <diskStore path="D:\atguigu\ehcache"/>
    <defaultCache
            maxElementsInMemory="1000"
            maxElementsOnDisk="10000000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>
</ehcache>

# 设置二级缓存类型

在xxxMapper.xml文件中设置二级缓存类型

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

# 加入logback日志

存在SLF4J时，作为简易日志的log4j将失效，此时我们需要借助SLF4J的具体实现logback来打印日志。创建logback的配置文件logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
    <!-- 指定日志输出的位置 -->
    <appender name="STDOUT"
              class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- 日志输出的格式 -->
            <!-- 按照顺序分别是：时间、日志级别、线程名称、打印日志的类、日志主体内容、换行 -->
            <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern>
        </encoder>
    </appender>
    <!-- 设置全局日志级别。日志级别按顺序分别是：DEBUG、INFO、WARN、ERROR -->
    <!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
    <root level="DEBUG">
        <!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender -->
        <appender-ref ref="STDOUT" />
    </root>
    <!-- 根据特殊需求指定局部日志级别 -->
    <logger name="com.atguigu.crowd.mapper" level="DEBUG"/>
</configuration>

# EHCache配置文件说明

  • maxElementsInMemory：内存中缓存元素的最大数量
  • maxElementsOnDisk：磁盘上缓存的元素最大数量，默认0表示无限大
  • eternal：true表示永不过期
  • overflowToDisk：true表示内存溢出时将过期元素缓存到磁盘
  • timeToIdleSeconds：可选，前后两次访问时间间隔，超出数据会删除，默认0表示无限大
  • timeToLiveSeconds：可选，缓存元素的有效生命周期，默认0表示无限大
  • diskSpoolBufferSizeMB：可选，磁盘缓存区大小，默认30Mb
  • diskPersistent：可选，VM重启时是否启用缓存中数据，默认false
  • diskExpiryThreadIntervalSeconds：可选，磁盘缓存的清理线程运行间隔，默认是120秒。
  • memoryStoreEvictionPolicy：当内存缓存达到最大，有新的元素加入的时候， 移除缓存中element的策略。 默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出

# MyBatis逆向工程

  • 正向工程：先创建Java类，由框架负责生成数据库表。Hibernate支持正向工程
  • 逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成Java实体类，Mapper接口，Mapper映射文件

# 逆向工程步骤

# 添加依赖和插件

<dependencies>
	<!-- MyBatis核心依赖包 -->
	<dependency>
		<groupId>org.mybatis</groupId>
		<artifactId>mybatis</artifactId>
		<version>3.5.9</version>
	</dependency>
	<!-- junit测试 -->
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.13.2</version>
		<scope>test</scope>
	</dependency>
	<!-- MySQL驱动 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>8.0.27</version>
	</dependency>
	<!-- log4j日志 -->
	<dependency>
		<groupId>log4j</groupId>
		<artifactId>log4j</artifactId>
		<version>1.2.17</version>
	</dependency>
</dependencies>
<!-- 控制Maven在构建过程中相关配置 -->
<build>
	<!-- 构建过程中用到的插件 -->
	<plugins>
		<!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
		<plugin>
			<groupId>org.mybatis.generator</groupId>
			<artifactId>mybatis-generator-maven-plugin</artifactId>
			<version>1.3.0</version>
			<!-- 插件的依赖 -->
			<dependencies>
				<!-- 逆向工程的核心依赖 -->
				<dependency>
					<groupId>org.mybatis.generator</groupId>
					<artifactId>mybatis-generator-core</artifactId>
					<version>1.3.2</version>
				</dependency>
				<!-- 数据库连接池 -->
				<dependency>
					<groupId>com.mchange</groupId>
					<artifactId>c3p0</artifactId>
					<version>0.9.2</version>
				</dependency>
				<!-- MySQL驱动 -->
				<dependency>
					<groupId>mysql</groupId>
					<artifactId>mysql-connector-java</artifactId>
					<version>8.0.27</version>
				</dependency>
			</dependencies>
		</plugin>
	</plugins>
</build>

# 创建MyBatis核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="jdbc.properties"/>
    <typeAliases>
        <package name=""/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name=""/>
    </mappers>
</configuration>

# 创建逆向工程配置文件

文件名必须是：generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--
    targetRuntime: 执行生成的逆向工程的版本
    MyBatis3Simple: 生成基本的CRUD（清新简洁版）
    MyBatis3: 生成带条件的CRUD（奢华尊享版）
    -->
    <context id="DB2Tables" targetRuntime="MyBatis3Simple">
        <!-- 数据库的连接信息 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis"
                        userId="root"
                        password="123456">
        </jdbcConnection>
        <!-- javaBean的生成策略-->
        <javaModelGenerator targetPackage="com.rong.hui.pojo" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- SQL映射文件的生成策略 -->
        <sqlMapGenerator targetPackage="com.rong.hui.mapper"
                         targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <!-- Mapper接口的生成策略 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.rong.hui.mapper" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>
        <!-- 逆向分析的表 -->
        <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
        <!-- domainObjectName属性指定生成出来的实体类的类名 -->
        <table tableName="t_emp" domainObjectName="Emp"/>
        <table tableName="t_dept" domainObjectName="Dept"/>
    </context>
</generatorConfiguration>

# 执行MBG插件的generate目标

1、双击运行插件

1719970451098

生成如下文件：包括实体类、实体类对应的查询条件类、mapper接口、mapper映射文件

20240703102812

Mysql时区不一致导致的问题

解决The server time zone value ‘Öйú±ê׼ʱ¼ä‘ is unrecognized or represents more than one time zone问题

在mysql中执行语句：

set global time_zone='+8:00'

# QBC风格

Mybatis Generator简称MBG，是一个专门为Mybatis框架使用者定制的代码生成器，可以快速根据表生成对应的映射文件，接口及Bean类。

QBC（Query by Criteria,按条件查询）是一种面向对象的查询方式，支持以函数API方式动态设置查询条件，组成查询语句。

# 查询

@Test
public void testMBG(){
    try {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);

        // 查询所有数据
        List<Emp> list = mapper.selectByExample(null);
        list.forEach(emp -> System.out.println(emp));

        // 根据条件查询,需要构造一个条件对象
        EmpExample example = new EmpExample();
        // 查询员工名称为张三，并且年龄大于20
        example.createCriteria().andEmpNameEqualTo("张三").andAgeGreaterThan(20);
        //  example.or()方法将之前条件与之后条件拼接
        example.or().andDidIsNotNull();
        List<Emp> list1 = mapper.selectByExample(example);
        list1.forEach(emp -> System.out.println(emp));

        // 根据主键更新
        mapper.updateByPrimaryKey(new Emp(1,"admin",22,null,"test@163.com",3));
        // 选择性修改,如果属性值为null,则会忽略这个属性值的更新
        mapper.updateByPrimaryKeySelective(new Emp(1,"admin",23,null,"test@163.com",3));
        
        // 添加
        mapper.insert(new Emp(null,"admin",24,null,"test@163.com",3));

        // 删除
        EmpExample example1 = new EmpExample();
        example1.createCriteria().andEmpNameEqualTo("张三");
        mapper.deleteByExample(example1);
        
        
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

# 分页插件

# 分页插件使用步骤

# 添加依赖

pom.xml中添加

<!--分页插件-->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.2.0</version>
</dependency>

# 配置分页插件

mybatis-config.xml中添加

<plugins>
    <!--设置分页插件-->
    <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

# 分页插件使用

# 开启分页功能

在查询功能之前开启分页

@Test
public void testPageHelper(){
    try {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        // 第一个参数pageNum当前页数，第二个参数pageSize每页显示的条数
        PageHelper.startPage(2,4);
        List<Emp> list = mapper.selectByExample(null);
        list.forEach(emp-> System.out.println(emp));
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

# 分页相关数据

1、在查询之前使用Page对象

Page<Object> page = PageHelper.startPage(2, 4);
System.out.println(page);

List<Emp> list = mapper.selectByExample(null);

控制台输出分页基本数据

Page{count=true, pageNum=2, pageSize=4, startRow=4, endRow=8, total=0, pages=0, reasonable=null, pageSizeZero=null}[]

2、在查询之后使用PageInfo

List<Emp> list = mapper.selectByExample(null);

// 第一个参数为查询到的数据，第二个参数navigatePages为导航分页的页数
PageInfo<Emp> pageInfo = new PageInfo<>(list, 5);
System.out.println(pageInfo);

控制台输出分页详细数据：前一页页面，后一页页码，是否第一页，是否最后一页，是否有前一页，是否有后一页等等

PageInfo{
pageNum=2, pageSize=4, size=4, startRow=5, endRow=8, total=10, pages=3, 

prePage=1, nextPage=3, isFirstPage=false, isLastPage=false, hasPreviousPage=true, hasNextPage=true, navigatePages=5, navigateFirstPage=1, navigateLastPage=3, navigatepageNums=[1, 2, 3]}

3、常用数据

  • pageNum：当前页的页码
  • pageSize：每页显示的条数
  • size：当前页显示的真实条数
  • total：总记录数
  • pages：总页数
  • prePage：上一页的页码
  • nextPage：下一页的页码
  • isFirstPage/isLastPage：是否为第一页/最后一页
  • hasPreviousPage/hasNextPage：是否存在上一页/下一页
  • navigatePages：导航分页的页码数
  • navigatepageNums：导航分页的页码，[1,2,3,4,5]
Last Updated: 12/23/2024, 4:18:13 AM

← MyBatisPlus从入门到精通 →