MyBatis

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

2. MyBatis下载

⭐地址

GitHub - mybatis/mybatis-3: MyBatis SQL mapper framework for Java

3.和其它持久化层技术的对比

①JDBC

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

②Hibernate与JPA

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

③MyBatis

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

二、搭建MyBatis

1.开发环境

MySOL不同版本注意事项：

	MySOL 5	MySOL 8
驱动类	使用jdbc5驱动驱动类：com.mysql.jdbc.Driver	使用jdbc8驱动驱动类：com.mysql.cj.jdbc.Driver
连接地址url	jdbc:mysql://localhost:3306/数据库名称	jdbc:mysql://localhost:3306/数据库名称?serverTimezone=UTC

2.创建maven工程

①打包方式

jar包

②引入依赖


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
 
    <groupId>com.atguigu.mybatisgroupId>
    <artifactId>mybatis_helloWorldartifactId>
    <version>1.0-SNAPSHOTversion>
    <packaging>jarpackaging>
 
    <properties>
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
    properties>
    <dependencies>
        
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatis-springartifactId>
            <version>2.0.4version>
        dependency>
        
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.22version>
        dependency>
    dependencies>
 
project>

创建User类


package com.atguigu.mybatis.pojo;
 
public class User {
    private Integer id;
    private String user_name;
    private String password;
    private Integer age;
    private String gender;
    private String email;
 
    public User() {
    }
 
    public User(Integer id, String user_name, String password, Integer age, String gender, String email) {
        this.id = id;
        this.user_name = user_name;
        this.password = password;
        this.age = age;
        this.gender = gender;
        this.email = email;
    }
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getUser_name() {
        return user_name;
    }
 
    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }
 
    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 getGender() {
        return gender;
    }
 
    public void setGender(String gender) {
        this.gender = gender;
    }
 
    public String getEmail() {
        return email;
    }
 
    public void setEmail(String email) {
        this.email = email;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", user_name='" + user_name + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

③创建MyBatis的核心配置文件

习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。
核心配置文件主要用：配置连接数据库的环境 & MyBatis的全局配置信息
核心配置文件存放的位置是src/main/resources目录下


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.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm?ServerTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="${password}"/>
            dataSource>
        environment>
    environments>
 
    
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    mappers>
configuration>

④创建mapper接口

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


package com.atguigu.mybatis.mapper;
 
public interface UserMapper {
    //添加功能
    int insertUser();
}

⑤创建MyBatis的映射文件（写sql语句）

映射文件的命名规则：表所对应的实体类的类名+Mapper.xml
一个映射文件对应一个实体类，对应一张表的操作
MyBatis映射文件用于编写SQL，访问以及操作表中的数据
MyBatis映射文件存放的位置是src/main/resources/mappers目录下
MyBatis中可以面向接口操作数据，要保证两个一致：

a>mapper接口的全类名和映射文件的命名空间（namespace）保持一致
b>mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致


mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.atguigu.mybatis.mapper.UserMapper">
    
    
    <insert id="insertUser">
        insert into t_user values (1,'admin','123456',23,'男','12345@qq.com')
    insert>
mapper>

⑥测试


package com.atguigu.mybatis.test;
 
import com.atguigu.mybatis.mapper.UserMapper;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import org.apache.ibatis.io.Resources;
 
import java.io.IOException;
import java.io.InputStream;
 
public class MybatisTest {
    @Test
    public void testInsert() throws IOException {
        //获取核心配置文件的输入流
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //获取SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //获取sql的会话对象SqlSession，是Mybatis提供的操作数据库的对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行sql语句，获取UserMapper的代理实现类对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        //调用mapper接口中的方法，实现添加用户的功能
        int i = mapper.insertUser();
        sqlSession.commit();
        System.out.println(i);
        sqlSession.close();
    }
}

⑦功能优化


package com.atguigu.mybatis.test;
 
import com.atguigu.mybatis.mapper.UserMapper;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import org.apache.ibatis.io.Resources;
 
import java.io.IOException;
import java.io.InputStream;
 
public class MybatisTest {
    @Test
    public void testInsert() throws IOException {
        //获取核心配置文件的输入流
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //获取SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //获取sql的会话对象SqlSession(不会自动提交事务)，是Mybatis提供的操作数据库的对象
        //SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取sql的会话对象SqlSession(自动提交事务)，是Mybatis提供的操作数据库的对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //方式一
//        //执行sql语句，获取UserMapper的代理实现类对象
//        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
//        //调用mapper接口中的方法，实现添加用户的功能
//        int i = mapper.insertUser();
        //方式二
        //提供sql以及唯一标识找到sql并执行，唯一标识是namespace.sqlId
        int i = sqlSession.insert("com.atguigu.mybatis.mapper.UserMapper.insertUser");
        //提交事务
        //sqlSession.commit();
        System.out.println(i);
        sqlSession.close();
    }
}

⑧加入log4j日志功能

Ⅰ.加入依赖


<dependency>
    <groupId>log4jgroupId>
    <artifactId>log4jartifactId>
    <version>1.2.12version>
dependency>

Ⅱ.加入log4j的配置文件


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>

控制台输出：


DEBUG 07-23 13:48:44,169 ==>  Preparing: insert into t_user values (1,'admin','123456',23,'男','12345@qq.com')  (BaseJdbcLogger.java:143) 
DEBUG 07-23 13:48:44,197 ==> Parameters:  (BaseJdbcLogger.java:143) 
DEBUG 07-23 13:48:44,202 <==    Updates: 1 (BaseJdbcLogger.java:143) 
1
 
进程已结束，退出代码为 0

⑨log4j日志的级别

FATAL(致命) > ERROR(错误) > WARN(警告) > INFO(信息) > DEBUG(调试)
从左到右打印的内容越来越详细

😊文件目录结构

⑩测试修改、删除和查询功能

为方便测试，创建SqlSessionUtil 类：


package com.atguigu.mybatis.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;
 
public class SqlSessionUtil {
    public static SqlSession getSqlSession(){
        SqlSession sqlSession = null;
        try {
            //获取核心配置文件的输入流
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            //获取sqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            //获取SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
            //获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sqlSession;
    }
}

⚪修改功能：

UserMapper.xml：


<update id="updateUser">
    update t_user set user_name='root',password='123' where id=1;
update>

测试代码：


@Test
public void testUpdate(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.updateUser();
    sqlSession.close();
}

⚪删除功能：

UserMapper.xml：


<delete id="deleteUser">
    delete from t_user where id=1
delete>

测试代码：


@Test
public void testDelete(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.deleteUser();
    sqlSession.close();
}

⚪查询功能：

⭐resultType：设置结果类型，即查询的数据要转换为的Java类型
⭐resultMap ：自定义映射，处理多对一或一对多的映射关系

（1）根据用户id查询用户信息

UserMapper.xml：


<select id="getUserById" resultType="com.atguigu.mybatis.pojo.User">
    select * from t_user where id=1
select>

测试代码：


@Test
public void testGetUserById(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.getUserById();
    System.out.println(user);
}

（2）查询所有用户信息

UserMapper.xml：


<select id="getAllUser" resultType="com.atguigu.mybatis.pojo.User">
    select * from t_user
select>

测试代码：


@Test
public void testGetAllUser(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List allUser = mapper.getAllUser();
    allUser.forEach(System.out::println);
}

🐟UserMapper接口

三、Mybatis核心配置文件

1.environments

配置数据库的环境

default：设置默认使用的环境的id

⚪environment

设置一个具体的连接数据库的环境

id：设置环境的唯一标识，不能重复

⚪transactionManager

设置事务管理器

type：设置事务管理的方式

type=“JDBC / MANAGED”

JDBC：表示使用JDBC中原生的事务管理方式
MANAGED：被管理，例如Spring

⚪dataSource

设置数据源

type：设置数据源的类型

type="POOLED / UNPOLLED / JNDI"

POOLED：表示使用数据库连接池
UNPOLLED：表示不使用数据库连接池
JNDI：表示使用上下文中的数据源

2.properties

创建配置文件

配置文件内容：


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

mybatis-config.xml中修改:

3.typeAliases

设置类型别名，即为某一个具体的类型设置一个别名，在Mybatis的范围中，就可以使用别名表示一个具体的类型


<typeAliases>
    <typeAlias type="com.atguigu.mybatis.pojo.User" alias="abc">typeAlias>
typeAliases>

type：设置需要起别名的类型
alias：设置某个类型的别名，不设置时当前类型默认别名为类名，且不区分大小写
通过包设置类型别名，指定包下所有的类型将全部拥有默认的别名

🐟Mybatis核心配置文件中的标签必须按照指定的顺序配置

properties？，settings？，typeAliases？，typeHandlers？，objectFactory？，objectWrapperFactory？，reflectorFactory？，plugins？，environments？，databaseIdProvider？，mappers？

4.mappers

⭐以包的方式引入映射文件，但是必须满足两个条件：

①mapper接口和映射文件所在的包必须一致（mapper接口文件在mapper包下，mapper接口映射文件在mappers包下，因此mapper接口和映射文件加载完成后在同一个包下）

②mapper接口的名字和映射文件的名字必须一致


    
    <mappers>
        <package name="com.atguigu.mybatis.mapper"/>
    mappers>

5.在idea中能够创建mybatis核心配置文件和映射文件的模板

①核心配置文件


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="com.atguigu.mybatis.pojo"/>
    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>

②映射文件


mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="">
 
mapper>

三、获取参数值的两种方式

MyBatis获取参数值的两种方式：${} 和 #{}
${}的本质：字符串拼接
#{}的本质：占位符赋值
${}使用字符串拼接的方式拼接sql。若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号
#{}使用占位符赋值的方式拼接sql。此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号

1.mapper接口方法的参数是单个字面量类型的参数

①字面量

例如int a = 1; 这个1就是字面量，a是变量名

字面量（literal）用于表达源代码中一个固定值的表示法（notation），整数、浮点数以及字符串等等

字面量就是没有用标识符封装起来的量，是“值”的原始状态。

可以使用 ${} 和 #{} 以任意的名称获取参数值（建议使用有意义的）

注意：${}需要加单引号

②例：根据用户名查询用户信息


public interface UserMapper {
    //根据用户名查询用户信息
    User getUserByUserName(String user_name);
}

UserMapper.xml


mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.atguigu.mybatis.mapper.UserMapper">
    <select id="getUserByUserName" resultType="com.atguigu.mybatis.pojo.User">
        
        select * from t_user where user_name = '${user_name}'
    select>
mapper>

测试


public class ParameterTest {
    @Test
    public void testGetUserByUserName(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserByUserName("admin");
        System.out.println(user);
    }
}

2.多个字面量类型的参数

若mapper接口中的方法参数为多个

此时MyBatis会自动将这些参数放在一个map集合中

以arg0,arg1...为键，以参数为值
以 param1,param2...为键，以参数为值

因此只需要通过${}和#{}访问map集合的键，就可以获取相对应的值

注意：${}需要手动加单引号

⭐验证登录


    <select id="checkLogin" resultType="com.atguigu.mybatis.pojo.User">
        
        select * from t_user where user_name = #{param1} and password = #{param2}
    select>

测试


@Test
public void testCheckLogin(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.checkLogin("admin","123456");
    System.out.println(user);
}

3.map集合类型的参数

如果mapper接口中的方法需要的参数是多个时，需要手动创建map集合，将这些数据放在 map中

只需要通过${}和#{}访问map集合的键就可以获取相对应的值

注意${}需要手动加单引号

⭐验证登录（以map集合作为参数）


    <select id="checkLoginByMap" resultType="com.atguigu.mybatis.pojo.User">
        select * from t_user where user_name=#{user_name} and password=#{password}
    select>

测试


@Test
public void testCheckLoginByMap(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    Map map = new HashMap<>();
    map.put("user_name","admin");
    map.put("password","123456");
    User user = mapper.checkLoginByMap(map);
    System.out.println(user);
}

4.实体类类型的参数

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

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

注意：${}需要手动加单引号

⭐添加用户信息


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

测试


@Test
public void testInsertUser(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    Map map = new HashMap<>();
    User user = new User(null,"root","123456",33,"女","123456@qq.com");
    mapper.insertUser(user);
}

5.使用@Param标识参数

① @Param注解

命名参数

可以通过@Param注解标识mapper接口中的方法参数

此时，mybatis会将这些参数放在map集合中，

情况一：以@Param注解的value属性值为键，以参数为值；
情况二：以 param1,param2...为键，以参数为值；

只需要通过${}和#{}访问map集合的键就可以获取相对应的值

注意：${}需要手动加单引号

②查询用户信息


    <select id="checkLoginByParam" resultType="com.atguigu.mybatis.pojo.User">
        select * from t_user where user_name=#{user_name} and password=#{password}
    select>

测试


@Test
public void testCheckLoginByParam(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.checkLoginByParam("admin", "123456");
    System.out.println(user);
}

四、Mybatis的各种查询功能

1.查询一个实体类对象


    <select id="getUserById" resultType="com.atguigu.mybatis.pojo.User">
        select * from t_user where id=#{id}
    select>


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

2.查询一个list集合


//查询所有的用户信息
List getAllUser();

当查询的数据为多条时，不能使用实体类作为返回值

否则会抛出异常 TooManyResultsException；

但是若查询的数据只有一条，可以使用实体类或集合（list）作为返回值


    <select id="getAllUser" resultType="com.atguigu.mybatis.pojo.User">
        select * from t_user
    select>


@Test
public void testGetAllUser(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    List user = mapper.getAllUser();
    user.forEach(System.out::println);
}

3.查询单个数据


//查询用户的总数量
Integer getCount();


    <select id="getCount" resultType="java.lang.Integer">
        select count(*) from t_user
    select>


@Test
public void testGetCount(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    Integer count = mapper.getCount();
    System.out.println(count);
}

⭐Mybatis提供的类型别名

常用类型别名：

Integer：Integer、int
int：_int、integer
Map：map
String：string

4.查询一条数据为map集合


//通过id查询一个用户，以map方式获取
Map getUserByIdToMap(@Param("id") Integer id);


    <select id="getUserByIdToMap" resultType="map">
        select * from t_user where id = #{id}
    select>


@Test
public void testGetUserByIdToMap(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    Map map = mapper.getUserByIdToMap(1);
    System.out.println(map);
}

如果值为NULL，则查询结果不会显示

5.查询多条数据为map集合


//查询所有的用户信息为map集合
Map getAllUserToMap();

直接查询会报错，需要把查询出来的结果放在能够存储map集合的list集合中

解决方案一：放在list集合中

将表中的数据以map集合的方式查询，一条数据对应一个map；

若有多条数据，就会产生多个map集合，此时可以将这些map放在一个list集合中获取


//查询所有的用户信息为map集合
List> getAllUserToMap();


    <select id="getAllUserToMap" resultType="map">
        select * from t_user
    select>


@Test
public void testGetAllUserToMap(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
    List> allUserToMap = mapper.getAllUserToMap();
    System.out.println(allUserToMap);
}

解决方案二：使用@MapKey注解

将表中的数据以map集合的方式查询，一条数据对应一个map；

若有多条数据，就会产生多个map集合，并且最终要以一个map的方式返回数据，此时通过@MapKey注解设置map集合的键，值是每条数据所对应的 map集合


//查询所有的用户信息为map集合
@MapKey("id")
Map getAllUserToMap();


    @Test
    public void testGetAllUserToMap(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
//        List> allUserToMap = mapper.getAllUserToMap();
        Map allUserToMap = mapper.getAllUserToMap();
        System.out.println(allUserToMap);
    }

查询结果：


DEBUG 07-25 12:31:16,444 ==>  Preparing: select * from t_user  (BaseJdbcLogger.java:143) 
DEBUG 07-25 12:31:16,475 ==> Parameters:  (BaseJdbcLogger.java:143) 
DEBUG 07-25 12:31:16,498 <==      Total: 2 (BaseJdbcLogger.java:143) 
{1={password=123456, gender=男, user_name=admin, id=1, age=20, email=123456@qq.com}, 2={password=123456, gender=女, user_name=root, id=2, age=33, email=123456@qq.com}}
 
进程已结束，退出代码为 0

五、特殊SQL的执行

1.模糊查询


//根据用户名进行模糊查询
List getUserByLike(@Param("mohu") String mohu);


<select id="getUserByLike" resultType="user">
    
    
    
    
    
    select * from t_user where user_name like "%"#{mohu}"%"
select>


@Test
public void testGetUserByLike(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    SpecialSQLMapper mapper = sqlSession.getMapper(SpecialSQLMapper.class);
    List list = mapper.getUserByLike("a");
    list.forEach(System.out::println);
}

2.批量删除


//批量删除
void deleteMoreUser(@Param("ids") String ids);


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


@Test
public void testDeleteMoreUser(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    SpecialSQLMapper mapper = sqlSession.getMapper(SpecialSQLMapper.class);
    mapper.deleteMoreUser("1,2");
}

3.动态设置表名

只能使用${}


//动态设置表名，查询用户信息
List getUserList(@Param("tableName") String tableName);


    <select id="getUserList" resultType="user">
        select * from ${tableName}
    select>


@Test
public void testGetUserList(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    SpecialSQLMapper mapper = sqlSession.getMapper(SpecialSQLMapper.class);
    List user = mapper.getUserList("t_user");
    user.forEach(System.out::println);
}

4.添加功能获取自增的主键


//添加用户信息并获取自增的主键
void insertUser(User user);

因为增删改的返回值固定，只能是受影响的行数

⚪useGeneratedKeys

当前添加功能使用自增的主键

⚪keyProperty

将添加的数据的自增主键为实体类类型的参数的属性赋值


    <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
        insert into t_user values (null,#{user_name},#{password},#{age},#{gender},#{email})
    insert>


@Test
public void testInsertUser(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    SpecialSQLMapper mapper = sqlSession.getMapper(SpecialSQLMapper.class);
    User user = new User(null,"Tom","142356",25,"男","142356@123.com");
    mapper.insertUser(user);
    System.out.println(user);
}

六、自定义映射resultMap

⭐准备工作

实体类和表的创建


package com.atguigu.mybatis.pojo;
 
public class Emp {
    private Integer empId;
    private String empName;
    private Integer age;
    private String gender;
 
    public Emp() {
    }
 
    public Emp(Integer empId, String empName, Integer age, String gender) {
        this.empId = empId;
        this.empName = empName;
        this.age = age;
        this.gender = gender;
    }
 
    public Integer getEmpId() {
        return empId;
    }
 
    public void setEmpId(Integer empId) {
        this.empId = empId;
    }
 
    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 getGender() {
        return gender;
    }
 
    public void setGender(String gender) {
        this.gender = gender;
    }
 
    @Override
    public String toString() {
        return "Emp{" +
                "empId=" + empId +
                ", empName='" + empName + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}


package com.atguigu.mybatis.pojo;
 
public class Dept {
    private Integer deptId;
    private String deptName;
 
    public Dept() {
    }
 
    public Dept(Integer deptId, String deptName) {
        this.deptId = deptId;
        this.deptName = deptName;
    }
 
    public Integer getDeptId() {
        return deptId;
    }
 
    public void setDeptId(Integer deptId) {
        this.deptId = deptId;
    }
 
    public String getDeptName() {
        return deptName;
    }
 
    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }
 
    @Override
    public String toString() {
        return "Dept{" +
                "deptId=" + deptId +
                ", deptName='" + deptName + '\'' +
                '}';
    }
}

例：根据id查询员工信息


public class EmpMapper {
    //根据id查询员工信息
    Emp getEmpByEmpId(@Param("empId") Integer empId);
}


<mapper namespace="com.atguigu.mybatis.mapper.EmpMapper">
    <select id="getEmpByEmpId" resultType="Emp">
        select * from t_emp where emp_id=#{empId}
    select>
mapper>


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

字段和属性不一致时的查询结果

解决方式一：为查询的字段设置别名，和属性名保持一致


    <select id="getEmpByEmpId" resultType="Emp">
        select emp_id empId,emp_name empName,age,gender from t_emp where emp_id=#{empId}
    select>

解决方式二：当字段复合MySQL的要求使用_，而属性复合Java的要求使用驼峰，此时可以在MyBatis的核心配置文件中设置一个全局配置，可以自动将下划线映射为驼峰


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

1.resultMap处理字段和属性的映射关系（字段和属性不一致）

若字段名和实体类中的属性名不一致，则可以通过resultMap设置自定义映射

resultMap：设置自定义映射

属性：

id：表示自定义映射的唯一标识
type：查询的数据要映射的实体类的类型

子标签：

id：设置主键和实体类种属性的映射关系
result：设置普通字段和实体类种属性的映射关系
association：设置多对一的映射关系（处理实体类类型的属性）
collection：设置一对多的映射关系

属性：

property：设置映射关系中实体类中的属性名，必须是处理的实体类类型中的属性名
column：设置映射关系中表中的字段名，必须是sql查询出的某个字段


    <resultMap id="empResultMap" type="Emp">
        <id column="emp_id" property="empId">id>
        <result column="emp_name" property="empName">result>
        <result column="age" property="age">result>
        <result column="gender" property="gender">result>
    resultMap>
 
    <select id="getEmpByEmpId" resultMap="empResultMap">
        select * from t_emp where emp_id=#{empId}
    select>

2.多对一映射处理

⭐获取员工以及所对应的部门信息


//获取员工以及所对应的部门信息
Emp getEmpAndDeptByEmpId(@Param("empId") Integer empId);

①级联方式处理映射关系


    <resultMap id="empAndDeptResultMap" type="Emp">
        <id column="emp_id" property="empId">id>
        <result column="emp_name" property="empName">result>
        <result column="age" property="age">result>
        <result column="gender" property="gender">result>
        <result column="dept_id" property="dept.deptId">result>
        <result column="dept_name" property="dept.deptName">result>
    resultMap>
 
    <select id="getEmpAndDeptByEmpId" resultMap="empAndDeptResultMap">
        select t_emp.*,t_dept.* from t_emp
            left join t_dept
            on t_emp.dept_id = t_dept.dept_id
        where t_emp.emp_id=#{empId}
    select>

测试：


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

②使用association处理映射关系


<resultMap id="empAndDeptResultMap" type="Emp">
    <id column="emp_id" property="empId">id>
    <result column="emp_name" property="empName">result>
    <result column="age" property="age">result>
    <result column="gender" property="gender">result>
    <association property="dept" javaType="Dept">
        <id column="dept_id" property="deptId">id>
        <result column="dept_name" property="deptName">result>
    association>
resultMap>

association：处理多对一的映射关系（处理实体类类型的属性）
property：设置需要处理映射关系的属性的属性名
javaType：设置要处理的属性的类型

③ 分步查询


import com.atguigu.mybatis.pojo.Dept;
import org.apache.ibatis.annotations.Param;
 
public interface DeptMapper {
    //通过分步查询查询员工以及所对应的部门信息的第二步
    Dept getEmpAndDeptByStepTwo(@Param("deptId") Integer deptId);
}


mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.atguigu.mybatis.mapper.DeptMapper">
    <select id="getEmpAndDeptByStepTwo" resultType="Dept">
        select * from t_dept where dept_id=#{deptId}
    select>
mapper>

EmpMapper：

property：设置需要处理映射关系的属性的属性名
select：设置分步查询的sql的唯一标识
column：将查询出的某个字段作为分步查询的sql的条件
fetchType：在开启了延迟加载的环境中，通过该属性设置当前的分步查询是否使用延迟加载
fetchType=“eager（延迟加载）/lazy（立即加载）”


//通过分步查询查询员工以及所对应的部门信息的第一步
Emp getEmpAndDeptByStepOne(@Param("empId") Integer empId);


    <resultMap id="empAndDeptByStepResultMap" type="Emp">
        <id column="emp_id" property="empId">id>
        <result column="emp_name" property="empName">result>
        <result column="age" property="age">result>
        <result column="gender" property="gender">result>
        <association property="dept" fetchType="eager"
                     select="com.atguigu.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
                     column="dept_id">
        association>
    resultMap>
 
    <select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap">
        select * from t_emp where emp_id=#{empId}
    select>


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

3.一对多映射处理


//查询部门以及部门中的员工信息
Dept getDetptAndEmpByDeptId(@Param("deptId") Integer deptId);

①collection

collection：处理一对多的映射关系（处理集合类型的属性）

ofType：设置集合类型的属性中存储的数据类型


    <resultMap id="deptAndEmpResultMap" type="Dept">
        <id column="dept_id" property="deptId">id>
        <result column="dept_name" property="deptName">result>
        <collection property="emps" ofType="Emp">
            <id column="emp_id" property="empId">id>
            <result column="emp_name" property="empName">result>
            <result column="age" property="age">result>
            <result column="gender" property="gender">result>
        collection>
    resultMap>
 
    <select id="getDeptAndEmpByDeptId" resultMap="deptAndEmpResultMap">
        select * 
        from t_dept
        left join t_emp
        on t_dept.dept_id = t_emp.dept_id
        where t_dept.dept_id = #{deptId}
    select>


@Test
public void testGetDeptAndEmpByDeptId(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
    Dept dept = mapper.getDeptAndEmpByDeptId(1);
    System.out.println(dept);
}

输出结果：


DEBUG 07-28 13:54:49,919 ==>  Preparing: select * from t_dept left join t_emp on t_dept.dept_id = t_emp.dept_id where t_dept.dept_id = ?  (BaseJdbcLogger.java:143) 
DEBUG 07-28 13:54:49,949 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:143) 
DEBUG 07-28 13:54:49,970 <==      Total: 2 (BaseJdbcLogger.java:143) 
Dept{deptId=1, deptName='A', emps=[Emp{empId=1, empName='Tom', age=20, gender='男', dept=null}, Emp{empId=4, empName='Jeny', age=25, gender='男', dept=null}]}
 
进程已结束，退出代码为 0

②分步查询

DeptMapper：


//通过分步查询查询部门以及部门中的员工信息的第一步
Dept getDeptAndEmpByStepOne(@Param("deptId") Integer deptId);


    <resultMap id="deptAndEmpResultMapByStep" type="Dept">
        <id column="dept_id" property="deptId">id>
        <result column="dept_name" property="deptName">result>
        <collection property="emps"
                    select="com.atguigu.mybatis.mapper.EmpMapper.getDeptAndEmpByStepTwo"
                    column="dept_id">collection>
    resultMap>
 
    <select id="getDeptAndEmpByStepOne" resultMap="deptAndEmpResultMapByStep">
        select * from t_dept where dept_id = #{deptId}
    select>

EmpMapper：


//通过分步查询查询部门以及部门中的员工信息的第二步
List getDeptAndEmpByStepTwo(@Param("deptId")Integer deptId);


    <select id="getDeptAndEmpByStepTwo" resultType="Emp">
        select * from t_emp where dept_id = #{deptId}
    select>

⭐分步查询的优点

可以实现延迟加载

但是必须在核心配置文件中设置全局配置信息：

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

此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。

此时可通过association和 collection中的fetchType属性设置当前的分步查询是否使用延迟加载

fetchType="lazy(延迟加载) / eager(立即加载)"


<settings>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
    
    <setting name="lazyLoadingEnabled" value="true"/>
    
    <setting name="aggressiveLazyLoading" value="false"/>
settings>

七、Mybatis动态SQL

Mybatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能

意义：解决拼接SQL语句字符串时的痛点问题。

1.if

if标签可通过test属性的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之，标签中的内容不会执行


public interface dynamicSQLMapper {
    //根据条件查询员工信息
    List 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="gender != null and gender != ''">
            and gender = #{gender}
        if>
    select>


@Test
public void testGetEmpByCondition(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    dynamicSQLMapper mapper = sqlSession.getMapper(dynamicSQLMapper.class);
    Emp emp = new Emp(null,"Tom",20,"男");
    List list = mapper.getEmpByCondition(emp);
    list.forEach(System.out::println);

2.where

where和if一般结合使用：

若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字
若where标签中有条件成立，则会自动生成where关键字
会将条件最前方多余的and去掉

注意：where标签不能去掉条件最后多余的and


    <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="gender != null and gender != ''">
                and gender = #{gender}
            if>
        where>
    select>

3.trim

trim用于去掉或添加标签中的内容

常用属性：

prefix：在标签中内容的前面添加某些内容
prefixOverrides：在标签中内容的前面去掉某些内容
suffix：在标签中内容的后面添加某些内容
suffixOverrides：在标签中内容的后面去掉某些内容


    <select id="getEmpByCondition" resultType="Emp">
        select * from t_emp
        <trim prefix="where" suffixOverrides="and">
            <if test="empName != null and empName != ''">
                emp_name = #{empName} and
            if>
            <if test="age != null and age != ''">
                age = #{age} and
            if>
            <if test="gender != null and gender != ''">
                gender = #{gender}
            if>
        trim>
    select>

4.choose、when、otherwise

choose、when、otherwise相当于if...else if..else

when至少设置一个，otherwise最多设置一个


//使用choose查询员工信息
List getEmpByChoose(Emp emp);


    <select id="getEmpByChoose" 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="gender != null and gender != ''">
                    gender = #{gender}
                when>
            choose>
        where>
    select>


@Test
public void testGetEmpByChoose(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    dynamicSQLMapper mapper = sqlSession.getMapper(dynamicSQLMapper.class);
    Emp emp = new Emp(null,"",null,"");
    List list = mapper.getEmpByChoose(emp);
    list.forEach(System.out::println);
}

5.foreach

collection：设置要循环的数组或集合
item：用一个字符串表示数组或集合中的每一个数据
separator：设置每次循环的数据之间的分隔符
open：循环的所有内容以什么开始
close：循环的所有内容以什么结束

批量添加


//批量添加员工信息
void insertMoreEmp(@Param("emps") List emps);


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


@Test
public void testInsertMoreEmp(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    dynamicSQLMapper mapper = sqlSession.getMapper(dynamicSQLMapper.class);
    Emp emp1 = new Emp(null,"小明1",20,"男");
    Emp emp2 = new Emp(null,"小明2",20,"男");
    Emp emp3 = new Emp(null,"小明3",20,"男");
    List list = Arrays.asList(emp1, emp2, emp3);
    mapper.insertMoreEmp(list);
}

批量删除


//批量删除
void deleteMoreEmp(@Param("empIds") Integer[] empIds);

方式一：


    <delete id="deleteMoreEmp">
        delete
        from t_emp
        where emp_id in (
            <foreach collection="empIds" item="empId" separator=",">
                #{empId}
            foreach>
            );
    delete>

方式二：


    <delete id="deleteMoreEmp">
        delete
        from t_emp
        where emp_id in
            <foreach collection="empIds" item="empId" separator="," open="(" close=")">
                #{empId}
            foreach>
    delete>

方式三：


    <delete id="deleteMoreEmp">
        delete
        from t_emp
        where
        <foreach collection="empIds" item="empId" separator="or">
            emp_id = #{empId}
        foreach>
    delete>

测试：


@Test
public void testDeleteMoreEmp(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    dynamicSQLMapper mapper = sqlSession.getMapper(dynamicSQLMapper.class);
    Integer[] empIds = new Integer[]{6,7};
    mapper.deleteMoreEmp(empIds);
}

6.SQL片段

sql片段，可以记录一段公共sql片段，在使用的地方通过include标签进行引用

八、MyBatis的缓存

1.MyBatis的一级缓存

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

MyBatis的一级缓存默认开启


//根据员工id查询员工信息
Emp getEmpById(@Param("empId") Integer empId);


    <select id="getEmpById" resultType="Emp">
        select * from t_emp where emp_id = #{empId}
    select>


@Test
public void testGetEmpById(){
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
    Emp emp1 = mapper.getEmpById(1);
    System.out.println(emp1);
    Emp emp2 = mapper.getEmpById(1);
    System.out.println(emp2);
    SqlSession sqlSession1 = SqlSessionUtil.getSqlSession();
    CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
    Emp emp3 = mapper1.getEmpById(1);
    System.out.println(emp3);
}

查询结果：可以看出，同一个SqlSession查询的数据会被缓存，查询语句只执行一次


DEBUG 07-29 11:56:46,274 ==>  Preparing: select * from t_emp where emp_id = ?  (BaseJdbcLogger.java:143) 
DEBUG 07-29 11:56:46,304 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:143) 
DEBUG 07-29 11:56:46,325 <==      Total: 1 (BaseJdbcLogger.java:143) 
Emp{empId=1, empName='Tom', age=20, gender='男'}
Emp{empId=1, empName='Tom', age=20, gender='男'}
DEBUG 07-29 11:56:46,369 ==>  Preparing: select * from t_emp where emp_id = ?  (BaseJdbcLogger.java:143) 
DEBUG 07-29 11:56:46,370 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:143) 
DEBUG 07-29 11:56:46,372 <==      Total: 1 (BaseJdbcLogger.java:143) 
Emp{empId=1, empName='Tom', age=20, gender='男'}
 
进程已结束，退出代码为 0

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

不同的SqlSession对应不同的一级缓存
同一个SqlSession但是查询条件不同
同一个SqlSession两次查询期间执行了任何一次增删改操作(增删改会改变数据库中原有的数据，因此需要重新查询)
同一个SqlSession两次查询期间手动清空了缓存（sqlSession.clearCache()）

2.MyBatis的二级缓存

二级缓存是SqlSessionFactory级别

通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取

⭐二级缓存开启的条件

在核心配置文件中，设置全局配置属性cacheEnabled="true"，默认为true，不需要设置
在映射文件中设置标签
二级缓存必须在SqlSession关闭或提交之后有效
查询的数据所转换的实体类类型必须实现序列化的接口


@Test
public void testCache() throws IOException {
    //测试二级缓存不可以使用工具类
    InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
    CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
    Emp emp1 = mapper1.getEmpById(1);
    System.out.println(emp1);
    sqlSession1.close();
    SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
    CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
    Emp emp2 = mapper2.getEmpById(1);
    System.out.println(emp2);
    sqlSession2.close();
}

⭐使二级缓存失效的情况

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

3.二级缓存的相关配置

在mapper配置文件中添加的cache标签可以设置一些属性：

①eviction属性：缓存回收策略，默认为 LRU。

LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。
FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。
SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。

②flushInterval属性：刷新间隔，单位毫秒

默认情况是不设置，即没有刷新间隔，缓存仅仅调用语句时刷新

③size属性：引用数目

正整数

代表缓存最多可以存储多少个对象，太大容易导致内存溢出

④readOnly：只读， true/false

true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是 false。

4.MyBatis缓存查询的顺序

先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用。
如果二级缓存没有命中，再查询一级缓存
如果一级缓存也没有命中，则查询数据库
SqlSession关闭之后，一级缓存中的数据会写入二级缓存

5.整合第三方缓存EHCache

①添加依赖


<dependency>
    <groupId>org.mybatis.cachesgroupId>
    <artifactId>mybatis-ehcacheartifactId>
    <version>1.2.2version>
dependency>
<dependency>
    <groupId>ch.qos.logbackgroupId>
    <artifactId>logback-classicartifactId>
    <version>1.2.3version>
dependency>

②各jar包功能

③创建EHCache的配置文件ehcache.xml


<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    
    <diskStore path="E:\atguigu\ehcache"/>
    <defaultCache
            maxElementsInMemory="1000"
            maxElementsOnDisk="10000000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    defaultCache>
ehcache>

④设置二级缓存的类型

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

⑤加入logback日志

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


<configuration debug="true">
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger]
[%msg]%npattern>
encoder>
appender>
<root level="DEBUG">
<appender-ref ref="STDOUT" />
root>
<logger name="com.atguigu.mybatis.mapper" level="DEBUG"/>
configuration>

⑥EHCache配置文件说明

九、MyBatis的逆向工程

正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表。 Hibernate是支持正向工程的。

逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成如下资源：

Java实体类
Mapper接口
Mapper映射文件

1.创建逆向工程的步骤

①添加依赖和插件


    
    <build>
    
    <plugins>
        
        <plugin>
            <groupId>org.mybatis.generatorgroupId>
            <artifactId>mybatis-generator-maven-pluginartifactId>
            <version>1.3.0version>
            
            <dependencies>
                
                <dependency>
                    <groupId>org.mybatis.generatorgroupId>
                    <artifactId>mybatis-generator-coreartifactId>
                    <version>1.3.2version>
                dependency>
                
                <dependency>
                    <groupId>mysqlgroupId>
                    <artifactId>mysql-connector-javaartifactId>
                    <version>8.0.22version>
                dependency>
            dependencies>
        plugin>
    plugins>
 build>

②创建MyBatis的核心配置文件


configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
    
    <properties resource="jdbc.properties"/>
 
    
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        
        <setting name="lazyLoadingEnabled" value="true"/>
        
        <setting name="aggressiveLazyLoading" value="false"/>
    settings>
    
    <typeAliases>
        
        <package name="com.atguigu.mybatis.pojo"/>
    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="com.atguigu.mybatis.mapper"/>
    mappers>
configuration>

③创建逆向工程的配置文件

文件名必须是：generatorConfig.xml


generatorConfiguration
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
<context id="DB2Tables" targetRuntime="MyBatis3">
<jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/mybatis?
serverTimezone=UTC"
userId="root"
password="123456">
jdbcConnection>
<javaModelGenerator targetPackage="com.atguigu.mybatis.pojo"
targetProject=".\src\main\java">
<property name="enableSubPackages" value="true" />
<property name="trimStrings" value="true" />
javaModelGenerator>
<sqlMapGenerator targetPackage="com.atguigu.mybatis.mapper"
targetProject=".\src\main\resources">
<property name="enableSubPackages" value="true" />
sqlMapGenerator>
<javaClientGenerator type="XMLMAPPER"
targetPackage="com.atguigu.mybatis.mapper" targetProject=".\src\main\java">
<property name="enableSubPackages" value="true" />
javaClientGenerator>
<table tableName="t_emp" domainObjectName="Emp"/>
<table tableName="t_dept" domainObjectName="Dept"/>
context>
generatorConfiguration>

④执行MBG插件的generate目标

⑤效果

2.QBC查询


    @Test
    public void testMBG(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
//        Emp emp = mapper.selectByPrimaryKey(1);  根据主键id查询数据
//        System.out.println(emp);
//        List list = mapper.selectByExample(null); 根据条件查询，五条件即查询所有数据
//        list.forEach(System.out::println);
        //根据条件查询
        EmpExample example = new EmpExample();
        example.createCriteria().andEmpNameEqualTo("Tom").andAgeGreaterThanOrEqualTo(15);
        example.or().andGenderEqualTo("男");
        List list = mapper.selectByExample(example);
        list.forEach(System.out::println);
    }

十、分页插件

limit index,pageSize

index：当前页的起始索引，index = (pageNum-1) * pageSize
pageSize：每页显示的条数
pageNum：当前页的页码
count：总记录数
totalPage：总页数 totalPage = count / pageSize;


if(count % pageSize != 0){
 
       totalPage += 1;
}
 
pageSize=4，pageNum=1，index=0 limit 0,4
 
pageSize=4，pageNum=3，index=8 limit 8,4   
 
pageSize=4，pageNum=6，index=20 limit 8,4

首页上一页 2 3 4 5 6 下一页末页

1.分页插件的使用步骤

①添加依赖


<dependency>
<groupId>com.github.pagehelpergroupId>
<artifactId>pagehelperartifactId>
<version>5.2.0version>
dependency>

②配置分页插件

在MyBatis的核心配置文件中配置插件


<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor">plugin>
plugins>

2.分页插件的使用

在查询功能之前使用PageHelper.startPage(int pageNum, int pageSize)开启分页功能
pageNum：当前页的页码
pageSize：每页显示的条数
在查询获取list集合之后，使用PageInfo pageInfo = new PageInfo<>(List list, int navigatePages)获取分页相关数据
list：分页之后的数据
navigatePages：导航分页的页码数

😵分页相关数据

PageInfo{

pageNum=8, pageSize=4, size=2,

startRow=29, endRow=30, total=30,

pages=8, list = Page{count=true, pageNum=8, pageSize=4, startRow=28, endRow=32, total=30,

pages=8, reasonable=false, pageSizeZero=false},

prePage（上一页页码）=7, nextPage（下一页页码）=0,

isFirstPage=false, isLastPage=true, hasPreviousPage=true, hasNextPage=false,

navigatePages=5, navigateFirstPage4, navigateLastPage8, navigatepageNums=[4, 5, 6, 7, 8] }

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

相关阅读:
SAP物料分类账的简单理解
 .NET应用如何防止被反编译
 Maven 官网查找依赖包
 nodejs midway+typeorm搭建后台方案
 ChatGPT在虚拟旅游和文化体验中的潜在作用如何？
ElasticSearch集群搭建及启动异常的问题
 MySQL 流程控制的详细讲解
 代码审查单
 IDEA配置
 【安鸾靶场】实战渗透
原文地址：https://blog.csdn.net/m0_52982868/article/details/125902508