文章目录

MyBatis
- 特性
- 下载
- 持久化层技术对比
搭建MyBatis
- 创建maven工程
- 创建MyBatis的核心配置文件
- 创建mapper接口
- 创建MyBatis的映射文件
- 测试功能
- 加入log4j日志功能
- - 加入log4j的配置文件
- 核心配置文件的完善与详解
- MyBatis的增删改查
- - 测试功能
MyBatis获取参数值
- 在IDEA中设置中配置文件的模板
- - 操作步骤
  - 操作步骤
- MyBatis获取参数值的两种方式(重点)
- - 获取单个字面量类型的参数
  - 获取多个字面量类型的参数
  - 获取map集合类型的参数
  - 获取实体类类型的参数
  - 使用@Param注解标识参数(常用)
MyBatis的各种查询功能
- 查询单个实体类对象
- 查询一个list集合
- 查询单个数据
- 查询一条数据为Map集合
- 查询多条数据为Map集合
- - 用Map的list集合接收
  - 用@MapKey注解设置键(Key)
特殊SQL的执行
- 模糊查询
- 批量删除
- 动态设置表名
- 添加功能获取自增的主键
自定义映射resultMap
- 多对一映射处理
- - 级联方式处理映射关系
  - 使用association处理映射关系
  - 分步查询
- 一对多映射处理
- - 通过collection解决
  - 分步查询
动态SQl
- if标签
- where标签
- trim标签
- choose、when、otherwise标签
- foreach标签
- - 通过数组实现批量删除
  - 通过集合实现批量添加
- sql标签
MyBatis的缓存
- 一级缓存
- - 缓存失效
- 二级缓存
- - 开启条件
  - 缓存失效
  - 相关设置
- 缓存查询的顺序
- 第三方缓存EHCache
- - 添加依赖

MyBatis

MyBatis最初是Apache的一个开源项目iBatis,2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下，iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到Github。

iBatis一词来源于"internet"和"abatis"的组合，是一个基于Java的持久层框架。iBatis提供的持久层框架包括SQLMaps和Data Access Obiects(DAO)。

特性

MyBatis是(~~支持定制化SQL、存储过程以及高级映射的优秀的~~)持久层框架(本质)
MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集
MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO(Plain Old Java Objects，普通的Java对象)映射成数据库中的记录
MyBatis是一个半自动的ORM(Object Relation Mapping)框架

下载

MyBatis官网下载地址：https://github.com/mybatis/mybatis-3

打开链接之后往下拉，找到这个地方

点进去之后，下载jar包(主体)

下载完之后，其中有mybatis的jar包已经官方文档pdf(方便学习，后续会使用到)。

或者，如果嫌上面下载的方式太麻烦，则可以采用maven依赖项式的下载，将下面代码导入依赖配置中即可。

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

持久化层技术对比

JDBC

SQL夹杂在Java代码中耦合度高，导致硬编码(将代码写死)内伤
维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
代码冗长，开发效率低

Hibernate和JPA

操作简便，开发效率高
程序中的长难复杂 SQL 需要绕过框架
内部自动生产的 SQL，不容易做特殊优化
基于全映射的全自动框架，大量字段的 POJO 进行部分映射时比较困难。
反射操作太多，导致数据库性能下降

MyBatis

轻量级，性能出色
SQL 和 Java 编码分开，功能边界清晰。Java代码专注业务、SQL语句专注数据
开发效率稍逊于HIbernate

搭建MyBatis

首先创建一个空项目，然后再下面创建一个maven工程

创建maven工程

注意，这里的打包方式要是jar方式。

下面将引入依赖(pom.xml)

<dependencies>
    <!-- Mybatis核心 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.13</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.32</version>
    </dependency>
</dependencies>

依赖引入完成后，则需要配置一下MyBatis的核心配置文件

创建MyBatis的核心配置文件

在main包下的resources路径下创建一个mybatisConfig.xml文件，然后进行配置。

这时就需要用到mybatis中的官方文档了，将其中的的配置文件直接复制过来即可。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--设置连接数据库的环境-->
    <environments 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="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

这里用到了mysql中的账号和密码需要改成自己mysql上对应的账号和密码。

创建mapper接口

该接口相当于以前的DAO，但是mapper仅仅是一个接口，不需要提供实现类。

当然，在此之前，需要在mysql中创建上述配置中的数据库，并且创建一张user表，创建代码如下。

CREATE DATABASE MyBatis;

USE Mybatis;

CREATE TABLE `t_user`(
    `id` INT NOT NULL AUTO_INCREMENT, 
    `username` VARCHAR(20), 
    `password` VARCHAR(20), 
    `age` INT, `sex` CHAR, 
    `email` VARCHAR(20), PRIMARY KEY (`id`) 
)ENGINE=INNODB CHARSET=utf8 COLLATE=utf8_general_ci;

接下来，创建User的实体类(POJO)

package code;

/**
 * @创建人 HeXin
 * @所属包 User
 * @所属项目 MyBatis
 * @创建时间 2023/3/30 20:38
 * @描述 User实体类
 */
public class User {
	private Integer id;
	private String username;
	private String password;
	private Integer age;
	private String sex;
	private String email;
	
	public User () {
	}
	
	public User (Integer id, String username, String password, Integer age, String sex, String email) {
		this.id = id;
		this.username = username;
		this.password = password;
		this.age = age;
		this.sex = sex;
		this.email = email;
	}
	
	public Integer getId () {
		return id;
	}
	
	public void setId (Integer id) {
		this.id = id;
	}
	
	public String getUsername () {
		return username;
	}
	
	public void setUsername (String username) {
		this.username = username;
	}
	
	public String getPassword () {
		return password;
	}
	
	public void setPassword (String password) {
		this.password = password;
	}
	
	public Integer getAge () {
		return age;
	}
	
	public void setAge (Integer age) {
		this.age = age;
	}
	
	public String getSex () {
		return sex;
	}
	
	public void setSex (String sex) {
		this.sex = sex;
	}
	
	public String getEmail () {
		return email;
	}
	
	public void setEmail (String email) {
		this.email = email;
	}
	
	@Override
	public String toString () {
		return "User{" +
				"id=" + id +
				", username='" + username + '\'' +
				", password='" + password + '\'' +
				", age=" + age +
				", sex='" + sex + '\'' +
				", email='" + email + '\'' +
				'}';
	}
}

创建User的mapper接口，在里面定义了一个添加用户信息的方法

package code.mapper;

/**
 * @创建人 HeXin
 * @所属包 UserMapper
 * @所属项目 MyBatis
 * @创建时间 2023/3/30 20:40
 * @描述 User类的Mapper接口
 */
public interface UserMapper {
	/**
	    * @Description: 添加用户名信息
	    * @CreateTime: 2023/3/30 21:41
	    * @Author: HeXin
	    */
	int addUser();
}

创建MyBatis的映射文件

这里要引入一个概念，对象关系映射(ORM：Object Relationship Mapping)

其中的对象是指的实体类对象，关系是关系型数据库，映射为二者之间的对应关系。

Java概念	数据库概念
类	表
属性	列/字段
对象	记录/行

在main中的resources中创建一个mappers软件包，并在此创建一个UserMapper.xml配置文件。

查询官方文档，找到关于映射文件的配置部分，将其拷贝过来，并在其中实现插入一条用户信息的sql。

<?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="code.mapper.UserMapper">
    <!--对应方法：int addUser();-->
    <insert id="addUser">
        insert into t_user values(null,"xiaoming","123456",19,'男',"xiaoming@qq.com");
    </insert>
</mapper>

创建映射文件的注意事项(重要)：

映射文件的命名规则：表所对应的实体类的类名+Mapper.xml(如：表为t_user，映射的实体类为User，因此所对应的映射文件为UserMapper.xml)。因此一个映射文件对应一个实体类，对应一张表的操作

MyBatis映射文件用于编写SQL，访问以及操作表中的数据。MyBatis映射文件存放的位置为src/main/resources/mappers目录下。

MyBatis中可以面向接口操作数据，要保证两个一致：
1. mapper接口的全类名和映射文件的命名空间(namespace)保持一致。
2. mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致。

测试功能

在test包下创建TestMyBatis测试类，并实现测试方法

@Test
public void testMyBatis(){
    InputStream stream = null;
    try {
        //加载核心配置文件
        stream = Resources.getResourceAsStream("mybatisConfig.xml");
    } catch (IOException e) {
        e.printStackTrace();
    }
    //获取SqlSessionFactoryBuilder
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    //获取sqlSessionFactory
    SqlSessionFactory build = builder.build(stream);
    //获取SqlSession
    SqlSession sqlSession = build.openSession();
    //获取mapper接口对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    //测试功能
    int i = mapper.addUser();
    //提交事务
    sqlSession.commit();
    System.out.println("受影响行数："+i);
}

将代码中的一些参数进行解读

SqlSession：代表Java程序和数据库之间的会话。(就如同HttpSession是Java程序和浏览器之间的会话)
SqlSessionFactory：是“生产”SqlSession的“工厂”。

其中存在着工厂模式(如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产”我们需要的对象)。

注意：当测试功能实现后一定要进行事务提交，否则数据库那边会没有数据显示，因为SqlSessionFactory的openSession方法中有一个autoCommit参数，默认为false，也就是默认不自动提交事务。

若需要自动提交事务，可将其参数值改为true(此时自己写的提交事务就可以注释掉了)，当需要手动进行提交事务的时候，直接使用默认情况即可。

//获取SqlSession
SqlSession sqlSession = build.openSession(true);

加入log4j日志功能

首先要加入相对应依赖

<!-- log4j日志 -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

加入log4j的配置文件

创建一个名为log4j.xml的配置文件，其存放在main下的resources目录下

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

日记级别

FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)

从左到右打印的内容越来越详细

核心配置文件的完善与详解

这里了解一下即可，现在使用时将其拷贝过去即可，以后在ssm整合的环境中是可以没有核心配置文件的，因为核心配置文件中的所有内容都可以交给spring处理。

<?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文件，此时就可以${属性名}的方式访问属性值-->
    <properties resource="jdbc.properties"></properties>
    <settings>
        <!--将表中字段的下划线自动转换为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
    </settings>
    <typeAliases>
        <!--
			typeAlias：设置某个具体的类型的别名
			属性：
			type：需要设置别名的类型的全类名
			alias：设置此类型的别名，若不设置此属性，该类型拥有默认的别名，即类名且不区分大小写
			若设置此属性，此时该类型的别名只能使用alias所设置的值
			每个实体类就需要设置一个typeAlias，比较麻烦，所以使用频率较低
		-->
<!--        <typeAlias type="code.User" alias="User"></typeAlias>-->
        <!--以包为单位，设置该包下所有的类型都拥有默认的别名，即类名且不区分大小写-->
        <package name="code"/>
    </typeAliases>
    <!--
		environments：设置多个连接数据库的环境
		属性：
		default：设置默认使用的环境的id
	-->
    <environments default="mysql_test">
        <!--
			environment：设置具体的连接数据库的环境信息
			属性：
			id：设置环境的唯一标识，可通过environments标签中的default设置某一个环境的id，表示默认使用的环境
		-->
        <environment id="mysql_test">
            <!--
				transactionManager：设置事务管理方式
				属性：
				type：设置事务管理方式，type="JDBC|MANAGED"
				type="JDBC"：设置当前环境的事务管理都必须手动处理
				type="MANAGED"：设置事务被管理，例如spring中的AOP
			-->
            <transactionManager type="JDBC"/>
            <!--
				dataSource：设置数据源
				属性：
				type：设置数据源的类型，type="POOLED|UNPOOLED|JNDI"
				type="POOLED"：使用数据库连接池，即会将创建的连接进行缓存，下次使用可以从
				缓存中直接获取，不需要重新创建
				type="UNPOOLED"：不使用数据库连接池，即每次使用连接都需要重新创建
				type="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="mappers/UserMapper.xml"/>-->
        <!--
			以包为单位，将包下所有的映射文件引入核心配置文件
			注意：此方式必须保证mapper接口和mapper映射文件必须在相同的包下
		-->
        <package name="code.mappers"/>
    </mappers>
</configuration>

到此，目前需要用到的核心配置文件已经配置完成，下面将开始MyBatis的CRUD功能(增删改查)

MyBatis的增删改查

添加

<!--int addUser();-->
<insert id="addUser">
    insert into t_user values(null,"xiaohong","123456",19,'女',"xiaohong@qq.com");
</insert>

删除

<!--void deleteUser()-->
<delete id="deleteUser">
    delete from t_user where id=4;
</delete>

修改

<!--void updateUser()-->
<update id="updateUser">
    update t_user set username = "lihua",sex = '男' where id=6;
</update>

查询

<!--查询功能标签必须设置resultType(设置默认映射关系)或resultMap(设置自定义映射关系)-->
<!--User getUserById()-->
<select id="getUserById" resultType="User">
    select * from t_user where id=5;
</select>
<!--List<User> getUsers()-->
<select id="getUsers" resultType="User">
    select * from t_user;
</select>

测试功能

@Test
public void testAdd(){
    InputStream stream = null;
    try {
        //加载核心配置文件
        stream = Resources.getResourceAsStream("mybatisConfig.xml");
    } catch (IOException e) {
        e.printStackTrace();
    }
    //获取SqlSessionFactoryBuilder
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    //获取sqlSessionFactory
    SqlSessionFactory build = builder.build(stream);
    //获取SqlSession
    SqlSession sqlSession = build.openSession(true);
    //获取mapper接口对象
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    //测试功能
    int i = mapper.addUser();
    System.out.println("受影响行数："+i);
}
@Test
public void testUpdate(){
    InputStream stream = null;
    try {
        stream = Resources.getResourceAsStream("mybatisConfig.xml");
    } catch (IOException e) {
        e.printStackTrace();
    }
    SqlSessionFactory build = new SqlSessionFactoryBuilder().build(stream);
    SqlSession sqlSession = build.openSession(true);
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.updateUser();
}
@Test
public void testDelete(){
    InputStream stream = null;
    try {
        stream = Resources.getResourceAsStream("mybatisConfig.xml");
    } catch (IOException e) {
        e.printStackTrace();
    }
    SqlSessionFactory build = new SqlSessionFactoryBuilder().build(stream);
    SqlSession sqlSession = build.openSession(true);
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.deleteUser();
}
@Test
public void testSelect(){
    InputStream stream = null;
    try {
        stream = Resources.getResourceAsStream("mybatisConfig.xml");
    } catch (IOException e) {
        e.printStackTrace();
    }
    SqlSessionFactory build = new SqlSessionFactoryBuilder().build(stream);
    SqlSession sqlSession = build.openSession(true);
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    //根据id查询用户信息
    System.out.println(mapper.getUserById());
    System.out.println("--------------------------------");
    //查询所有用户信息
    List<User> users = mapper.getUsers();
    users.forEach(user -> System.out.println(user));
}

到此，MyBatis最基础的框架与功能已经实现~

MyBatis获取参数值

MyBatis获取参数值有两种方式，一种是${}，一种是#{}

${}的本质是使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，则需要手动加单引号。

#{}的本质是占位符赋值，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号。

此时，新建一个模板，重新搭建一个MyBatis框架。因为其核心配置文件每次都去官方文档拷贝实在太麻烦，所以这里使用IDEA中的代码模板功能，后续需要核心配置文件和映射文件时直接可以一键生成。

在IDEA中设置中配置文件的模板

在idea中配置核心配置文件模板

操作步骤

第一步

第二步

将简单的模板代码拷贝进模板文件主体中

<?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"></properties>
    <settings>

        <setting name="mapUnderscoreToCamelCase" value="true"/>

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

    <typeAliases>

        <package name=""/>
    </typeAliases>
    <environments default="mysql_test">

        <environment id="mysql_test">

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

在idea中配置映射文件模版

操作步骤

第一步与配置核心文件时一样，区别在于第二步

第二步

MyBatis获取参数值的两种方式(重点)

获取单个字面量类型的参数

若mapper接口中的方法参数为单个的字面量类型此时可以使用${}和#{}以任意的名称获取参数的值，注意${}需要手动加单引号。

首先，因为每次测试时都需要创建的sqlsession，存在大量一样的代码，所以将其提取出来形成一个工具类，叫做SqlSessionUtils

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

/**
 * @创建人 HeXin
 * @所属包 SqlSessionUtils
 * @所属项目 MyBatis
 * @创建时间 2023/4/1 10:08
 * @描述 获取SqlSession的工具类
 */
public class SqlSessionUtils {
	public static SqlSession getSqlSession(){
		InputStream stream = null;
		try {
			stream = Resources.getResourceAsStream("mybatisConfig.xml");
		} catch (IOException e) {
			e.printStackTrace();
		}
		SqlSessionFactory build = new SqlSessionFactoryBuilder().build(stream);
		SqlSession sqlSession = build.openSession(true);
		return sqlSession;
	}
}

下面将用代码实现这两种方式获取参数

#{}

查询代码

<!--User getUserByUsername(String username)-->
<select id="getUserByUsername" resultType="User">
    select * from t_user where username = #{username};
</select>

测试代码

@Test
public void testSingle(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.getUserByUsername("xiaohong");
    System.out.println(user);
}

测试的结果：

从测试的结果可以看出，#{}的确使用的?占位符赋值获取参数

${}

查询代码

<!--User getUserByUsername(String username)-->
<select id="getUserByUsername" resultType="User">
    select * from t_user where username = '${username}';
</select>

测试代码

@Test
public void testSingle(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.getUserByUsername("xiaohong");
    System.out.println(user);
}

测试的结果：

从测试结果可以看出，${}使用的是字符串拼接的方式进行赋值

值得注意的时，因为${}不会自动添加单引号，所以当使用${}时，一定要记得用单引号将其进行包围，否则就会报出一下异常

获取多个字面量类型的参数

若mapper接口中的方法参数为多个时此时MyBatis会自动将这些参数放在一个map集合中，以arg0,arg1…为键，以参数为值；以 param1,param2…为键，以参数为值；因此只需要通过${}和#{}访问map集合的键就可以获取相对应的值。由于上面获取单个参数已经演示过${}和#{}的使用和区别，下面就演示其中一种。

代码演示

查询代码(错误方式)

<!--User login(String username, String password)-->
<select id="login" resultType="User">
    select * from t_user where username = #{username} and password = #{password};
</select>

测试代码

@Test
public void testLogin(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.login("xiaohong", "123456");
    System.out.println(user);
}

当有多个参数时，不能像单个参数一样直接使用形参名获取，否则会报异常

上面的错误信息中不仅告诉了哪里出错，还给出了解决方案。

查询代码(正确方式)

<!--User login(String username, String password)-->
<select id="login" resultType="User">
    select * from t_user where username = #{arg0} and password = #{arg1};
</select>

测试结果

获取map集合类型的参数

若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中只需要通过${}或#{}访问map集合的键就可以获取相对应的值。此方式由获取多参数方式演变而来，相当于自己设置键来访问数据。

代码实现

查询代码

<!--User login(Map<String,Object> map)-->
<select id="login" resultType="User">
    select * from t_user where username = #{username} and password = #{password};
</select>

测试代码

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

测试结果与获取多参数的结果一样

获取实体类类型的参数

若mapper接口中的方法参数为实体类对象时

此时可以使用${}和#{}，通过访问实体类对象中的属性名获取属性值。

代码演示

向表中插入数据

<!--int addUser(User user)-->
<insert id="addUser">
    insert intot_user values(null,#{username},#{password},#{age},#{sex},#{email})
</insert>

测试代码

@Test
public void testAdd(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    int i = mapper.addUser(new User(null, "xiaoming", "123456", 19, "男", "xiaoming@qq.com"));
    System.out.println(i);
}

测试结果

使用@Param注解标识参数(常用)

此方式可以将第一种(获取单个参数)、第二种(获取多个参数)、第三种(获取map类型)方式整合成一种方式，都可以使用@Param进行实现获取参数。

此时，会将这些参数放在map集合中，以@Param注解的value属性值为键，以参数为值；以param1,param2…为键，以参数为值；只需要通过${}和#{}访问map集合的键就可以获取相对应的值。

代码演示

查询代码

<!--User login(@Param("username")String username, @Param("password")String password)-->
<select id="login" resultType="User">
    select * from t_user where username = #{username} and password = #{password};
</select>

测试代码

@Test
public void testLogin(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.login("xiaohong", "123456");
    System.out.println(user);
}

测试结果

MyBatis的各种查询功能

共分为五种查询情况：查询单个实体类对象、查询一个list集合、查询单个数据、查询一条数据为map集合，查询多条数据为map集合。下面将逐个进行学习

查询单个实体类对象

这种查询情况已经实现过很多次了，这里就不多赘述，直接上代码

/**
	* @Description:根据id查询用户信息
	* @CreateTime: 2023/4/1 12:00
	* @Author: HeXin
	*/
User getUserById(@Param("id") Integer id);

查询语句

<!--User getUserById(Integer id);-->
<select id="getUserById" resultType="User">
    select * from t_user where id = #{id};
</select>

测试代码

@Test
public void testGetUser(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    User user = mapper.getUserById(5);
    System.out.println(user);
}

测试结果

查询一个list集合

这种情况可以包含第一种情况，因为list集合中可以不包含任何数据，也可以只包含一条数据。

/**
	* @Description: 查询所有用户信息
	* @CreateTime: 2023/4/1 12:10
	* @Author: HeXin
	*/
List<User> getUsers();

查询语句

<!--List<User> getUsers();-->
<select id="getUsers" resultType="User">
    select * from t_user;
</select>

测试代码

@Test
public void testGetUsers(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    List<User> users = mapper.getUsers();
    users.forEach(user -> System.out.println(user));
}

测试结果

查询单个数据

单个数据，一般是指单行单列的数据，如一张表上的总记录数、统计总共的金额等等。

下面将以查询用户信息的总记录数为例进行学习

代码演示

/**
	* @Description: 查询用户的总记录数
	* @CreateTime: 2023/4/1 14:48
	* @Author: HeXin
	*/
Integer getCount();

查询语句(MyBatis设置的有默认的类型别名，所以这里的resultType设置为全类名或别名都行。)

<!--Integer getCount();-->
<select id="getCount" resultType="Integer">
    select count(*) from t_user;
</select>

测试代码

@Test
public void testGetCount(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    Integer count = mapper.getCount();
    System.out.println("总记录数："+count);
}

测试结果为

通过查找官方文档，我们可以得知，MyBatis设置的默认全类名有以下这些

查询一条数据为Map集合

就是将查询到的一条数据存储到Map集合中。

代码演示

/**
    * @Description: 根据id查询用户信息为一个map集合
    * @CreateTime: 2023/4/1 15:07
    * @Author: HeXin
    */
Map<String,Object> getUserByIdToMap(@Param("id") Integer id);

查询语句

<!--Map<String,Object> getUserByIdToMap(@Param("id") Integer id);-->
<select id="getUserByIdToMap" resultType="map">
    select * from t_user where id = #{id};
</select>

测试代码

@Test
public void testGetUserToMap(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    Map<String, Object> userMap = mapper.getUserByIdToMap(6);
    System.out.println(userMap);
}

测试结果

查询多条数据为Map集合

将查询到的多个数据都存储在Map集合中。这种方式以后的使用频率是很高的，因为map可以转换成json对象然后将数据传递给前端。注意，这里的多条数据不能只用一个Map来接收，应该用一个Map的LIst集合来接收(或者用@MapKey设置一个键(Key)，此时就可以将每条数据转换的Map集合作为值，以某个字段的值作为主键，放在同一个Map集合中)，否则就会报异常(此异常与用一个参数接收多条数据时的异常一样)

代码演示

用Map的list集合接收

/**
    * @Description: 查询所有用户信息为Map集合
    * @CreateTime: 2023/4/1 15:18
    * @Author: HeXin
    */
List<Map<String,Object>> getUsersToMap();

查询语句

<!--Map<String,Object> getUsersToMap();-->
<select id="getUsersToMap" resultType="map">
    select * from t_user;
</select>

测试代码

@Test
public void testGetUsersToMap() {
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    List<Map<String, Object>> users = mapper.getUsersToMap();
    users.forEach(user-> System.out.println(user));
}

测试结果

用@MapKey注解设置键(Key)

/**
    * @Description: 查询所有用户信息为Map集合
    * @CreateTime: 2023/4/1 15:18
    * @Author: HeXin
    */
@MapKey("id")
Map<Integer,Object> getUsersToMap();

查询语句

<!--Map<String,Object> getUsersToMap();-->
<select id="getUsersToMap" resultType="map">
    select * from t_user;
</select>

测试代码

@Test
public void testGetUsersToMap() {
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    Map<Integer, Object> users = mapper.getUsersToMap();
    users.forEach((id,user)-> System.out.println("key="+id+" "+user));
}

测试结果

到此，MyBatis中的各种查询功能已经学习完毕。

特殊SQL的执行

模糊查询

这里就存在一个问题，因为#{}是占位符赋值，所以会将sql语句中的单引号部分内容替换成问号，并且会自动加上单引号，导致查询失败，所以这个时候有三种解决办法，下面进行学习

以根据用户名模糊查询为例

/**
    * @Description: 根据用户名进行模糊查询
    * @CreateTime: 2023/4/1 15:52
    * @Author: HeXin
    */
List<User> getUserByLike(@Param("username")String username);

使用${}获取参数值

<!--List<User> getUserByLike(@Param("username")String username)-->
<select id="getUserByLike" resultType="User">
    select * from t_user where username like '%${username}%'
</select>

使用#{}与SQL中concat字符串拼接函数结合使用它

<!--List<User> getUserByLike(@Param("username")String username)-->
<select id="getUserByLike" resultType="User">
    select * from t_user where username like concat('%',#{username},'%')
</select>

使用"%“#{}”%"去拼接其中的内容(最常用的方式)

<!--List<User> getUserByLike(@Param("username")String username)-->
<select id="getUserByLike" resultType="User">
    select * from t_user where username like "%"#{username}"%"
</select>

测试代码

@Test
public void testGetUserByLike(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
    List<User> user = mapper.getUserByLike("xiao");
    user.forEach(u-> System.out.println(u));
}

测试结果

批量删除

/**
    * @Description: 批量删除
    * @CreateTime: 2023/4/1 16:11
    * @Author: HeXin
    */
int deleteMore(@Param("ids") String ids);

SQL语句

<!--int deleteMore(@Param("ids"),String ids);-->
<delete id="deleteMore">
    delete from t_user where id in(${ids})
</delete>

测试代码

@Test
public void testDeleteMore(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
    int i = mapper.deleteMore("5,6,7");
    System.out.println("受影响行数："+i);
}

测试结果

动态设置表名

根据表名来查询数据，当然，这里也应该使用${}来获取参数

/**
    * @Description: 查询指定表中的数据
    * @CreateTime: 2023/4/1 16:29
    * @Author: HeXin
    */
List<User> getUserByTableName(@Param("tableName") String tableName);

查询语句

<!--List<User> getUserByTableName(@Param("tableName") String tableName);-->
<select id="getUserByTableName" resultType="User">
    select * from ${tableName};
</select>

测试代码

@Test
public void testGetUserByTableName(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
    List<User> users = mapper.getUserByTableName("t_user");
    users.forEach(user-> System.out.println(user));
}

测试结果

添加功能获取自增的主键

这是没有添加获取自增主键的添加用户信息打印结果，很显然，其id值为null

因为增删改有统一的返回值是受影响的行数，
因此只能将获取的自增的主键放在传输的参数user对象的某个属性中。

/**
    * @Description: 添加用户信息
    * @CreateTime: 2023/4/1 17:14
    * @Author: HeXin
    */
void addUser(User user);

添加语句

<!--void addUser();-->
<!--
        useGeneratedKeys：设置使用自增的主键
        keyProperty：因为增删改有统一的返回值是受影响的行数，
        因此只能将获取的自增的主键放在传输的参数user对象的某个属性中
    -->
<insert id="addUser" useGeneratedKeys="true" keyProperty="id">
    insert into t_user values(null,#{username},#{password},#{age},#{sex},#{email});
</insert>

测试代码

@Test
public void testAddUser(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
    User user = new User(null,"WLM","1122334",18,"女","wlm@sina.com");
    mapper.addUser(user);
    System.out.println(user);
}

测试结果

这次添加，其id值就不是null了。

自定义映射resultMap

resultMap：设置自定义映射

这里将会用到多对一或一对多的关系，所以需要再创建两张表。

CREATE TABLE `t_emp`( 
    `eid` INT NOT NULL AUTO_INCREMENT, 
    `emp_name` VARCHAR(20), 
    `age` INT, 
    `sex` CHAR, 
    `email` VARCHAR(20),
    `did` INT,
    PRIMARY KEY (`eid`) 
) ENGINE=INNODB CHARSET=utf8 COLLATE=utf8_general_ci;

CREATE TABLE `t_dept`( 
    `did` INT NOT NULL AUTO_INCREMENT, 
    `dept_name` VARCHAR(20), 
    PRIMARY KEY (`did`) 
) ENGINE=INNODB CHARSET=utf8 COLLATE=utf8_general_ci;

向表中插入数据

t_emp

INSERT INTO `mybatis`.`t_emp` (`eid`, `emp_name`, `age`, `sex`, `email`, `did`) 
VALUES ('1', 'xiaoming', '18', '男', 'xiaoming@qq.com', '1'); 
INSERT INTO `mybatis`.`t_emp` (`eid`, `emp_name`, `age`, `sex`, `email`, `did`) 
VALUES ('2', 'xiaohong', '19', '女', 'xiaohong@qq.com', '1'); 
INSERT INTO `mybatis`.`t_emp` (`eid`, `emp_name`, `age`, `sex`, `email`, `did`) 
VALUES ('3', 'lihua', '22', '男', 'lihua@sina.com', '2'); 
INSERT INTO `mybatis`.`t_emp` (`eid`, `emp_name`, `age`, `sex`, `email`, `did`) 
VALUES ('4', 'wangqiang', '21', '男', 'liuqiang@163.com', '3');

t_dept

INSERT INTO `mybatis`.`t_dept` (`did`, `dept_name`) VALUES ('1', 'A'); 
INSERT INTO `mybatis`.`t_dept` (`did`, `dept_name`) VALUES ('2', 'B'); 
INSERT INTO `mybatis`.`t_dept` (`did`, `dept_name`) VALUES ('3', 'C');

对应的，创建两个表的实体类

package POJO;

/**
 * @创建人 HeXin
 * @所属包 Emp
 * @所属项目 MyBatis
 * @创建时间 2023/4/1 18:00
 * @描述
 */
public class Emp {
	private Integer eid;
	private String empName;
	private Integer age;
	private String sex;
	private String email;
	private Dept dept;
	
	public Dept getDept () {
		return dept;
	}
	
	public void setDept (Dept dept) {
		this.dept = dept;
	}
	
	public Emp (Integer eid, String empName, Integer age, String sex, String email) {
		this.eid = eid;
		this.empName = empName;
		this.age = age;
		this.sex = sex;
		this.email = email;
	}
	
	public Emp () {
	}
	
	public Integer getEid () {
		return eid;
	}
	
	public void setEid (Integer eid) {
		this.eid = eid;
	}
	
	public String getEmpName () {
		return empName;
	}
	
	public void setEmpName (String empName) {
		this.empName = empName;
	}
	
	public Integer getAge () {
		return age;
	}
	
	public void setAge (Integer age) {
		this.age = age;
	}
	
	public String getSex () {
		return sex;
	}
	
	public void setSex (String sex) {
		this.sex = sex;
	}
	
	public String getEmail () {
		return email;
	}
	
	public void setEmail (String email) {
		this.email = email;
	}
	
	@Override
	public String  toString () {
		return "Emp{" +
				"eid=" + eid +
				", empName='" + empName + '\'' +
				", age=" + age +
				", sex='" + sex + '\'' +
				", email='" + email + '\'' +
				", dept=" + dept +
				'}';
	}
}

package POJO;

import java.util.List;

/**
 * @创建人 HeXin
 * @所属包 Dept
 * @所属项目 MyBatis
 * @创建时间 2023/4/1 18:02
 * @描述
 */
public class Dept {
	private Integer did;
	private String deptName;
	private List<Emp> emps;
	
	public List<Emp> getEmps () {
		return emps;
	}
	
	public void setEmps (List<Emp> emps) {
		this.emps = emps;
	}
	
	public Dept (Integer did, String deptName) {
		this.did = did;
		this.deptName = deptName;
	}
	
	public Dept () {
	}
	
	public Integer getDid () {
		return did;
	}
	
	public void setDid (Integer did) {
		this.did = did;
	}
	
	public String getDeptName () {
		return deptName;
	}
	
	public void setDeptName (String deptName) {
		this.deptName = deptName;
	}
	
	@Override
	public String toString () {
		return "Dept{" +
				"did=" + did +
				", deptName='" + deptName + '\'' +
				", emps=" + emps +
				'}';
	}
}

若字段名与实体类中的属性名不一致，则通过查询语句查询数据的时候，是无法查到的，这是因为字段名有自己的风格要求(下划线)，属性名也有风格要求(驼峰)。解决此问题共有三个办法：

给查询的时候给字段名起别名，将别名设置为驼峰风格的。(实现起来比较麻烦，尤其是当字段名很多的时候，非常消耗时间)。

通过设置MyBatis核心配置文件，设置全局变量，将下划线自动映射为驼峰。该配置已经在完善核心配置文件时已经涉及到了。

<!--设置全局变量-->
<settings>
    <!--将表中字段的下划线自动转换为驼峰-->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

通过resultMap设置自定义的映射关系

<!--
    resultMap：设置自定义映射
    属性：
    id：表示自定义映射的唯一标识
    type：查询的数据要映射的实体类的类型
    子标签：
    id：设置主键的映射关系
    result：设置普通字段的映射关系
    association：设置多对一的映射关系
    collection：设置一对多的映射关系
    属性：
    property：设置映射关系中实体类中的属性名
    column：设置映射关系中表中的字段名
    -->
<resultMap id="userMap" type="User">
    <id property="id" column="id"></id>
    <result property="userName" column="user_name"></result>
    <result property="password" column="password"></result>
    <result property="age" column="age"></result>
    <result property="sex" column="sex"></result>
</resultMap>
<!--List<Emp> getEmps-->
<select id="getEmps" resultMap="userMap">
    select * from t_emp;
</select>

多对一映射处理

一共有三种处理方式。通过查询员工信息及其对应部门信息为例。

/**
    * @Description: 查询员工及其对应部门信息
    * @CreateTime: 2023/4/2 10:33
    * @Author: HeXin
    */
Emp getEmpAndDept(@Param("eid") Integer eid);

级联方式处理映射关系

查询语句

<resultMap id="empAndDeptResultMap" 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>
<!--Emp getEmpAndDept(@Param("eid") Integer eid);-->
<select id="getEmpAndDept" resultMap="empAndDeptResultMap">
    select * from t_emp left join t_dept on t_emp.did = t_dept.did where t_emp.eid = #{eid};
</select>

使用association处理映射关系

查询语句

<resultMap id="empAndDeptResultMap" type="Emp">
    <id property="eid" column="eid"></id>
    <result property="empName" column="emp_name"/>
    <result property="age" column="age"></result>
    <result property="sex" column="sex"></result>
    <result property="email" column="email"></result>
    <!--
		association：处理多对一的映射关系
		property：需要处理多对的映射关系的属性名
		javaType：该属性的类型
	-->
    <association property="dept" javaType="Dept">
        <id property="did" column="did"></id>
        <result property="deptName" column="dept_name"/>
    </association>
</resultMap>
<!--Emp getEmpAndDept(@Param("eid") Integer eid);-->
<select id="getEmpAndDept" resultMap="empAndDeptResultMap">
    select * from t_emp left join t_dept on t_emp.did = t_dept.did where t_emp.eid = #{eid};
</select>

分步查询

先查询员工的信息

/**
    * @Description: 查询员工信息
    * @CreateTime: 2023/4/2 11:32
    * @Author: HeXin
    */
Emp getEmpByStep(@Param("eid") int eid);

查询语句

<resultMap id="empDeptStepMap" type="Emp">
    <id column="eid" property="eid"></id>
    <result column="empName" property="emp_name"></result>
    <result column="age" property="age"></result>
    <result column="sex" property="sex"></result>
    <result column="email" property="email"></result>
    <!--
    select：设置分步查询，查询某个属性的值的sql的标识（namespace.sqlId或mapper接口的全类名.方法名）
    column：将sql以及查询结果中的某个字段设置为分步查询的条件
    -->
    <association property="dept"
                 select="mappers.DeptMapper.getEmpDeptByStep" 					 					 column="did">
    </association>
</resultMap>
<!--Emp getEmpByStep(@Param("eid") int eid);-->
<select id="getEmpByStep" resultMap="empDeptStepMap">
    select * from t_emp where eid = #{eid}
</select>

再根据员工所对应的部门id查询部门信息

/**
    * @Description: 查询员工信息
    * @CreateTime: 2023/4/2 11:32
    * @Author: HeXin
    */
Dept getEmpDeptByStep(@Param("did") int did);

查询语句

<!--Dept getEmpDeptByStep(@Param("did") int did);-->
<select id="getEmpDeptByStep" resultType="Dept">
    select * from t_dept where did = #{did}
</select>

测试代码

@Test
public void testGetEmpAndDept(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
    Emp emp = mapper.getEmpAndDept(1);
    System.out.println(emp);
}

测试结果

分布查询的好处是延迟加载(懒加载，对某种信息推迟加载，这样的技术也就帮助我们实现了 “按需查询” 的机制)，而延迟加载默认在MyBatis中不开启的。

如果需要开启延迟加载，则需要在核心配置文件的全局设置中设置这两个属性

lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载(默认是关闭的:false)
aggressiveLazyLoading：当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载(默认是开启的:true)

<!--设置MyBatis全局配置-->
<settings>
    <!--开启延迟加载-->
    <setting name="lazyLoadingEnabled" value="true"/>
</settings>

当开启延迟加载之后，可以通过修改association中的fetchType属性的值来手动控制延迟加载的效果

fetchType=“lazy”：延迟加载
fetchType=“eager”：立即加载

一对多映射处理

通过查询部门及其员工信息为例。

/**
    * @Description:获取部门及其员工信息
    * @CreateTime: 2023/4/2 11:54
    * @Author: HeXin
    */
Dept getDeptAndEmp(@Param("did") Integer did);

通过collection解决

<resultMap id="deptAndEmpResultMap" type="Dept">
    <id property="did" column="did"/>
    <result property="deptName" column="dept_name"/>
    <!--
collection：处理一对多的映射关系
ofType：表示该属性所对应的集合中存储数据的类型
-->
    <collection property="emps" ofType="Emp">
        <id property="eid" column="eid"/>
        <result property="empName" column="emp_name"/>
        <result property="age" column="age"/>
        <result property="sex" column="sex"/>
        <result property="email" column="email"/>
    </collection>
</resultMap>
<!--Dept getDeptAndEmp(@Param("id") Integer id);-->
<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>

分步查询

第一步

先根据did查询部门信息

/**
    * @Description: 分布查询第一步：查询部门信息
    * @CreateTime: 2023/4/2 14:52
    * @Author: HeXin
    */
Dept getDeptAndEmpByStepOne(@Param("did") Integer did);

查询语句

<resultMap id="deptAndEmpByStepOneResultMap" type="Dept">
    <id property="did" column="did"/>
    <result property="deptName" column="dept_name"/>
    <collection property="emps"
                select="mappers.EmpMapper.getDeptAndEmpByStepTwo"
                column="did"
                fetchType="lazy"></collection>
</resultMap>
<!--Dept getDeptAndEmpByStepOne(@Param("did") Integer did);-->
<select id="getDeptAndEmpByStepOne" resultMap="deptAndEmpByStepOneResultMap">
    select * from t_dept where did = #{did};
</select>

第二步

根据did查询员工信息

/**
    * @Description: 根据did查询员工信息
    * @CreateTime: 2023/4/2 11:54
    * @Author: HeXin
    */
List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did);

查询语句

<!--List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did);-->
<select id="getDeptAndEmpByStepTwo" resultType="Emp">
    select * from t_emp where did = #{did};
</select>

测试代码

@Test
public void testGetDeptAndEmpByStep(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
    Dept dept = mapper.getDeptAndEmpByStepOne(1);
    System.out.println("部门名称："+dept.getDeptName());
    System.out.println("部门id："+dept.getDid());
    List<Emp> emps = dept.getEmps();
    System.out.println("部门员工：");
    emps.forEach(emp -> System.out.println(emp));
}

测试结果

从运行的日志中可以发现，当代码只查询部门的id和名称的时候，只执行了第一句sql语句。而当查询员工信息的时候，两条sql语句才同时执行。

动态SQl

Mybatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能，它存在的意义是为了解决拼接SQL语句字符串时的痛点问题。

下面以根据多条件查询用户信息为例进行演示学习。

/**
    * @Description: 多条件查询
    * @CreateTime: 2023/4/2 15:23
    * @Author: HeXin
    */
List<Emp> getEmpByCondition(Emp emp);

测试代码

@Test
public void testGetEmpByCondition(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    List<Emp> emps = mapper.getEmpByCondition(new Emp(null,"",19,"女","xiaohong@qq.com"));
    emps.forEach(emp-> System.out.println(emp));
}

if标签

使用的是xml中的if标签进行sql语句的拼接来解决这个问题。

查询语句

<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp where true
    <if test="empName != null and empName != ''">
        emp_name = #{empName}
    </if>
    <if test="age != null and age !=''">
        and age = #{age}
    </if>
    <if test="age != null and age !=''">
        and sex = #{sex}
    </if>
    <if test="age != null and age !=''">
        and email = #{email}
    </if>
</select>

where后面加上的true(或者恒等式)是为了防止某些条件不成立之后，where后面直接接上and导致sql语句出错，加上之后也不会影响查询结果

如上面报错信息，就是因为empName为空字符串，导致where直接与and相连而报错。所以在使用if标签的时候要格外注意这个问题，但下面的where标签就能很好的解决这个问题

where标签

where标签会自动识别是否需要生成where关键字，并且也会自动屏蔽掉内容前多余的and

<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp
    <where>
        <if test="empName != null and empName != ''">
            emp_name = #{empName}
        </if>
        <if test="age != null and age !=''">
            and age = #{age}
        </if>
        <if test="age != null and age !=''">
            and sex = #{sex}
        </if>
        <if test="age != null and age !=''">
            and email = #{email}
        </if>
    </where>
</select>

按照上面的情况，执行结果会报错，因为empName为空且未加恒等式导致where与and直接相连。

真的是这样吗？看一下运行结果

结果没有报错，而是直接将员工的信息顺利输出，通过观察日志可以发现，sql’语句中自动添加了where，并且去除了内容前多余的and。

当然，这里只是自动生成where，如果将查询的所有条件都变成null或者空字符串，结果又会怎样呢？

观察运行结果和日志发现，这次的sql语句中没有where关键字，所以sql语句就变成了查询全部员工信息。

注意：where标签不能将其中内容后面多余的and或or去除，只能将内容前多余的and或or去除

trim标签

trim标签中包含四个属性：

prefix：将trim标签中内容前面添加指定内容
suffix：将trim标签中内容后面添加指定内容
prefixOverrides：将trim标签中内容前面去除指定内容
suffixOverrides：：将trim标签中内容后面去除指定内容

由此可以看出，该标签能很好解决where与and的兼容问题

<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
    select * from t_emp
    <trim prefix="where" prefixOverrides="and|or">
        <if test="empName != null and empName != ''">
            emp_name = #{empName}
        </if>
        <if test="age != null and age !=''">
            and age = #{age}
        </if>
        <if test="age != null and age !=''">
            and sex = #{sex}
        </if>
        <if test="age != null and age !=''">
            and email = #{email}
        </if>
    </trim>
</select>

这里只给出了内容前面加and或or关键字。同理，如果在内容后面加上and或or关键字，则将prefixOverrides改为suffixOverrides即可。

choose、when、otherwise标签

这里看起来是三个标签，实则是一套标签，需要组合使用，其作用相当于Java中的if…else…

when标签至少有一个，而otherwise标签之多只能有一个

<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" 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>
            <when test="empName != null and empName != ''">
                email = #{email}
            </when>
            <otherwise>
                did = 2
            </otherwise>
        </choose>
    </where>
</select>

从代码中看出，其内容中并没有加and，因为该标签如果有一个choose条件成立，则其他条件就会被忽略，所以sql语句中有且最多只有一个成立条件，所以不需要加and关键字

foreach标签

foreach标签相当于Java中的for循环，下面将以批量删除和批量添加为例进行演示

foreach标签中有五个常用的属性：

collection：表示的是循环体(集合或数组)
item：循环体中的个体
separator：循环个体之间以separator设置的属性值值分开
open：foreach标签所循环的所有内容的开始符，循环从open设置的属性值开始。
close：foreach标签所循环的所有内容的结束符，循环从close设置的属性值结束。

通过数组实现批量删除

其中，批量删除有两种写法，一种是id in (删除的id集合或数组)，另一种是id = id or id…

/**
    * @Description: 通过数组实现批量删除
    * @CreateTime: 2023/4/2 16:33
    * @Author: HeXin
    */
int deleteMoreArray(@Param("eids") Integer[] eids);

删除语句

第一种

<!--int deleteMoreArray(@Param("eids") Integer[] eids);-->
<delete id="deleteMoreArray">
    delete from t_emp where eid in
    <foreach collection="eids" item="eid" separator="," open="(" close=")">
        #{eid}
    </foreach>
</delete>

第二种

<!--int deleteMoreArray(@Param("eids") Integer[] eids);-->
<delete id="deleteMoreArray">
    delete from t_emp where
    <foreach collection="eids" item="eid" separator="or">
        eid = #{eid}
    </foreach>
</delete>

通过集合实现批量添加

/**
    * @Description:通过集合实现批量添加
    * @CreateTime: 2023/4/2 16:55
    * @Author: HeXin
    */
int insertMoreByList(@Param("emps") List<Emp> emps);

插入语句

<!--int insertMoreByList(@Param("emps") List<Emp> emps);-->
<insert id="insertMoreByList">
    insert into t_emp values
    <foreach collection="emps" item="emp" separator=",">
        (null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},1)
    </foreach>
</insert>

sql标签

sql标签叫做sql片段，可以将常用的sql片段进行记录，后续需要使用的时候，直接引入使用即可。

接着使用trim标签，根据多条件查询用户信息为例继续演示

查询的方法还是一样，这里就不赘述了。

查询语句

<sql id="empColumns">eid,emp_name,sex,email,dept</sql>
<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
    select <include refid="empColumns"/> from t_emp
    <trim prefix="where" prefixOverrides="and|or">
        <if test="empName != null and empName != ''">
            emp_name = #{empName}
        </if>
        <if test="age != null and age !=''">
            and age = #{age}
        </if>
        <if test="age != null and age !=''">
            and sex = #{sex}
        </if>
        <if test="age != null and age !=''">
            and email = #{email}
        </if>
    </trim>
</select>

引用时使用到了include标签，其中的refid属性表示的是引用sql片段的id

MyBatis的缓存

缓存是指，将当前查询出来的数据进行一个记录，等到下一次再来查询相同的数据时，会直接去缓存中去拿取，而不再去数据库中拿去。这样的好处时，提高了查询的效率，当然，坏处就是，当在服务器中修改了这些数据中的内容，如果不及时更新或删除缓存，会导致再次查询时出现数据的修改的情况不能及时响应。

MyBatis中的缓存分为一级缓存和二级缓存，其中一级缓存是默认开启的。两者的级别不同，也就是两者的范围不一样。

一级缓存

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

下面以根据员工id查询员工信息为例

/**
    * @Description: 根据员工id获取员工信息
    * @CreateTime: 2023/4/2 20:56
    * @Author: HeXin
    */
Emp getEmpById(@Param("eid") Integer eid);

查询语句

<!--Emp getEmpById(@Param("eid") Integer eid);-->
<select id="getEmpById" resultType="Emp">
    select * from t_emp where eid = #{eid};
</select>

下面将通过不同的测试代码来测试其范围：

测试代码1

@Test
public void testGetEmpById(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    //第一次获取员工信息
    CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
    Emp emp = mapper.getEmpById(2);
    System.out.println(emp);

    //第二次获取员工信息
    Emp emp1 = mapper.getEmpById(2);
    System.out.println(emp1);
}

运行结果

从运行结果中可以看到，虽然我们用同一个mapper生成了两个相同的员工信息时，但是SQL语句只执行了一次。

测试代码2

@Test
public void testGetEmpById(){
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    //第一次获取员工信息
    CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
    Emp emp = mapper.getEmpById(2);
    System.out.println(emp);

    //第二次获取员工信息
    CacheMapper mapper1 = sqlSession.getMapper(CacheMapper.class);
    Emp emp1 = mapper1.getEmpById(2);
    System.out.println(emp1);
}

运行结果

当使用不同的mapper生成两个相同的员工信息时，但SQL语句仍然只执行了一次。

测试代码3

@Test
public void testGetEmpById(){
    //第一次获取员工信息
    SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
    Emp emp = mapper.getEmpById(2);
    System.out.println(emp);

    //第二次获取员工信息
    SqlSession sqlSession1 = SqlSessionUtils.getSqlSession();
    CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
    Emp emp1 = mapper1.getEmpById(2);
    System.out.println(emp1);
}

运行结果

当使用不同的SqlSession生成不同的mapper而创建的两个相同的员工数据时，SQL语句执行了两次。

通过上面的三个测试样例，可以得知，一级缓存的范围是在SqlSession内的，只要是同一个SqlSession，在查询相同数据时都会从缓存中拿取数据。

缓存失效

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

不同的SqlSession对应不同的一级缓存
同一个SqlSesion但是其查询条件不同
同一个SqlSession两次查询期间执行了任意一次增删改操作
同一个SqlSession两次查询期间手动清空了缓存(清空缓存方法：SqlSession.clearCache())

二级缓存

二级缓存是SqlSessionFactory级别，通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取。二次缓存需要手动开启，且二级缓存的范围比一级缓存大。

开启条件

在核心配置文件中，设置全局配置属性cacheEnabled=“true”(默认是true，不需要设置)
在映射文件中设置标签<cache/>
二级缓存必须在SqlSession关闭(SqlSession.close()方法)或提交(SqlSession.commit()方法)之后有效
查询的数据所转换的实体类类型必须实现序列化的接口

代码演示

准备工作：Emp完善实现Serializable的接口，在映射文件中加入<cache/>标签。(开启二级缓存)

测试代码

@Test
public void testTwoCache(){
    InputStream stream = null;
    try {
        stream = Resources.getResourceAsStream("mybatisConfig.xml");
    } catch (IOException e) {
        e.printStackTrace();
    }
    SqlSessionFactory build = new SqlSessionFactoryBuilder().build(stream);
    //第一次查询
    SqlSession sqlSession = build.openSession(true);
    CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
    System.out.println(mapper.getEmpById(1));
    sqlSession.close();

    //第二次查询
    SqlSession sqlSession1 = build.openSession(true);
    CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
    System.out.println(mapper1.getEmpById(1));
    sqlSession1.close();

}

测试结果

要像实现此效果，一定要按照开启条件正确开启二级缓存。

缓存失效

两次查询之间执行任意一次的增删改，会使一级和二级缓存同时失效。

缓存查询的顺序

先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以直接拿来使用
如果二级缓存没有命中，再查询一级缓存
如果一级缓存也没有命中，则查询数据库
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>