Mybatis笔记 + 总结(

最新推荐文章于 2024-05-10 09:14:14 发布

陳青雲

最新推荐文章于 2024-05-10 09:14:14 发布

阅读量1k

点赞数 1

分类专栏： SSM框架文章标签： mybatis java mysql

本文链接：https://blog.csdn.net/Cqy180/article/details/131223209

版权

SSM框架专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

一、简介
- 1.MyBatis历史
- 2.MyBatis特性
- 3.MyBatis下载
- 4.和其它持久化层技术对比
二、搭建MyBatis
- 开发环境
- 1.创建maven工程
- 2.创建MyBatis的核心配置文件
- 3.创建mapper接口
- 4.创建MyBatis的映射文件
- 5.通过junit测试功能
- 6.加入log4j日志功能
三、核心配置文件详解
四、MyBatis的增删改查
五、获取参数的两种方式
- 1.单个字面量类型的参数
- 2.多个字面量类型的参数
- 3.map集合类型的参数
- 4.实体类类型的参数
- 5.使用@Param表示参数
- 总结
六、各种查询功能
- 1.查询一个实体类对象
- 2.查询一个list集合
- 3.查询单个数据
- 4.查询一条数据为map集合
- 5.查询多条数据为Map集合
- - 方法一：用list集合存储查询到的map集合数据，将泛型设置为Map集合
  - 方法二：使用`@MapKey("字段名")`
- 总结
七、特殊的SQL
- 1.模糊查询
- 2.批量删除 ${}
- 3.动态设置表名 ${}
- 4.添加功能获取自增的主键
八、自定义映射
- 1.全局配置字段和属性的映射关系
- 2.resultMap处理字段和属性的映射关系
九、动态SQL
- 1.if标签
- - 问题
  - 解决方案添加恒成立条件
- 2.where标签
- 3.trim标签
- 4.choose、when、otherwise标签
- 5.foreach标签
- 6.SQL片段
十、缓存
- 1.一级缓存
- 2.二级缓存
- 3.二级缓存的相关配置
- 4.MyBatis缓存查询的顺序
- 5.整合第三方缓存EHCache（了解）
十一、逆向工程
- 1.创建逆向工程的步骤
- 2.MyBatis3奢华尊享版，是QBC风格的
- - 查询
  - 增改
十二、分页插件
- - - 常用数据分析：
- 1.分页插件的配置
- - 1.1添加依赖
  - 1.2核心配置文件配置分页插件
- 2.分页插件的使用 PageHelper.startPage
- 3.分页相关数据
- - - 方法一：直接输出
    - 方法二使用PageInfo
总结
- 所需基本的Maven坐标
- MyBatis核心配置文件
- log4j配置文件
- jdbc.properties

一、简介

1.MyBatis历史

MyBatis最初是Apache的一个开源的项目iBatis，2010年6月这个项目有Apache Software Foundation迁移到了Google Code。随着开发团队转投Google 旗下，iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到Github
iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）

2.MyBatis特性

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

3.MyBatis下载

MyBatis下载地址
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YLW3EcLe-1686797154281)(./assets/MyBatis下载.png)]

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

JDBC
- SQL 夹杂在Java代码中耦合度高，导致硬编码内伤
- 维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
- 代码冗长，开发效率低
Hibernate 和 JPA
- 操作简便，开发效率高
- 程序中的长难复杂 SQL 需要绕过框架
- 内部自动生产的 SQL，不容易做特殊优化
- 基于全映射的全自动框架，大量字段的 POJO 进行部分映射时比较困难。
- 反射操作太多，导致数据库性能下降
MyBatis
- 轻量级，性能出色
- SQL 和 Java 编码分开，功能边界清晰。Java代码专注业务、SQL语句专注数据
- 开发效率稍逊于HIbernate，但是完全能够接受

二、搭建MyBatis

开发环境

IDE：idea 2019.2
构建工具：maven 3.5.4
MySQL版本：MySQL 5.7
MyBatis版本：MyBatis 3.5.7

1.创建maven工程

打包方式：jar

引入依赖

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

2.创建MyBatis的核心配置文件

习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。
核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息
核心配置文件存放的位置是src/main/resources目录下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--设置连接数据库的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/MyBatis"/>
                <property name="username" value="root"/>
                <property name="password" value="cqy"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入映射文件-->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

3.创建mapper接口

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

package com.atguigu.mybatis.mapper;  
  
public interface UserMapper {  
	/**  
	* 添加用户信息  
	*/  
	int insertUser();  
}

4.创建MyBatis的映射文件

相关概念：ORM（Object Relationship Mapping）对象关系映射。
- 对象：Java的实体类对象
- 关系：关系型数据库
- 映射：二者之间的对应关系

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

映射文件的命名规则
- 表所对应的实体类的类名+Mapper.xml
- 例如：表t_user，映射的实体类为User，所对应的映射文件为UserMapper.xml
- 因此一个映射文件对应一个实体类，对应一张表的操作
- MyBatis映射文件用于编写SQL，访问以及操作表中的数据
- MyBatis映射文件存放的位置是src/main/resources/mappers目录下
MyBatis中可以面向接口操作数据，要保证两个一致
- mapper接口的全类名和映射文件的命名空间（namespace）保持一致
- mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cqy.mybatis.mapper.UserMapper">
    <!--int insertUser();-->
    <insert id="insertUser">
        insert into t_user values(null,'张三','123',23,'女','cqy@cqy.com')
    </insert>
    <!--
      resultType:设置结果类型，即查询数据要转换为的Java类型
      resultMap:自定义映射，处理一对多或者多对一的映射关系
      -->
    <select id="queryUserByName" resultType="com.cqy.mybatis.pojo.User">
        select * from t_user where sex='女';
    </select>
</mapper>

5.通过junit测试功能

SqlSession：代表Java程序和数据库之间的会话。（HttpSession是Java程序和浏览器之间的会话）
SqlSessionFactory：是“生产”SqlSession的“工厂”
工厂模式：如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产”我们需要的对象

public class MybatisTest {

    @Test
    public void testMybatis() throws IOException {
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //2.获取SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //3.获取sqlSessionFactory
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //4.获取SqlSession
        //传入参数  true设置自动提交，默认为不自动提阿娇
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取mapper接口对象,     底层使用代理模式
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //执行sql
        int i = userMapper.insertUser();
        //提交事务
        sqlSession.commit();
        System.out.println(i);
    }
}

此时需要手动提交事务，如果要自动提交事务，则在获取sqlSession对象时，使用SqlSession sqlSession = sqlSessionFactory.openSession(true);，传入一个Boolean类型的参数，值为true，这样就可以自动提交

6.加入log4j日志功能

6.1加入依赖

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

6.2 加入log4j的配置文件

log4j的配置文件名是固定的为log4j.xml，存放的位置是src/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>

6.3日志的级别

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

三、核心配置文件详解

核心配置文件中的标签必须按照固定的顺序(有的标签可以不写，但顺序一定不能乱)：

properties ：引入properties配置文件,此后可使用 ${key}方式获取value

settings :

typeAliases :为类配置简短的别名

两种方式：

<typeAlias type="具体类的全类名" alias="别名"/>:若不设置alias则别名为类名且不区分大小写
<package name="包名"/>:为包中所有类设置别名，为类名不区分大小写

typeHandlers

objectFactory

objectWrapperFactory

reflectorFactory

plugins

environments :设置连接数据库的环境

databaseIdProvider

mappers :引入映射文件

两种方式:

<mapper resource="具体位置"/>
<package name="包所在位置"/> ，必须满足
mapper接口和映射文件所在的包必须一致
mapper接口的名字和映射文件的名字必须一致

<?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配置文件,此后可使用 ${key}方式获取value -->
    <properties resource="jdbc.properties"/>

    <!-- 由于全类名非常的长，通过typeAliases可以为类配置简短的别名 -->
    <typeAliases>
        <!--
            typeAlias:设置某个具体的类的别名
            类型
                type:设置全类名
                alias:别名（可以不设置该属性，则有默认的别名为类名且不区分大小写,user/User）
         -->
<!--        <typeAlias type="com.cqy.mybatis.pojo.User" alias="u"/>-->
        <typeAlias type="com.cqy.mybatis.mapper.UserMapper"/>
        <!--
            package:以包为单位，为所有包中的类配置别名为默认别名,即别名为类名不区分大小写
            name:包名
            -->
        <package name="com.cqy.mybatis.pojo"/>
    </typeAliases>
    <!--设置连接数据库的环境-->
    <!--
        environments : 配置多个连接数据的环境
        属性:
        default : 设置默认使用的环境的id
        -->
    <environments default="development">
        <!--
            environment : 设置一个具体的连接数据库的环境
            属性
            id : 唯一标识，不能重复
        -->
        <environment id="development">
            <!--
                transactionManager:事务管理器
                属性：
                type="JDBC/MANGED":设置事务管理的方式
                属性值:
                    JDBC:表示使用JDBC中原生的事务管理器
                    MANAGED:被管理的，例如Spring
             -->
            <transactionManager type="JDBC"/>
            <!--
                dataSource: 数据源
                属性
                type="POLLED/UNPOOLED/JNDI":设置数据源的类型
                    POLLED:表示使用数据库连接池
                    UNPOOLED:表示不使用数据库连接池
                    JNDI:表示使用上下文中的数据源
             -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>

        <environment id="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>
<!--        <mapper resource="com/cqy/mybatis/mappers/UserMapper.xml"/>-->
        <!--
            以包的方式引入映射文件，必须满足两个条件
            1.mapper接口和映射文件所在的包必须一致
            2.mapper接口的名字和映射文件的名字必须一致
         -->
        <package name="com.cqy.mybatis.mapper"/>
    </mappers>
</configuration>

四、MyBatis的增删改查

添加

<!--int insertUser();-->
<insert id="insertUser">
	insert into t_user values(null,'admin','123456',23,'男','12345@qq.com')
</insert>

删除

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

修改

<!--int updateUser();-->
 <update id="updateUser">
     update t_user set username = '张三' where id = 5
 </update>

查询一个实体类对象

<!--User getUserById();-->  
<select id="getUserById" resultType="com.atguigu.mybatis.bean.User">  
	select * from t_user where id = 2  
</select>

查询集合

<!--List<User> getUserList();-->
<select id="getUserList" resultType="com.atguigu.mybatis.bean.User">
	select * from t_user
</select>

注意：
1. 查询的标签select必须设置属性resultType或resultMap，用于设置实体类和数据库表的映射关系
  - resultType：自动映射，用于属性名和表中字段名一致的情况
  - resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况
2. 当查询的数据为多条时，不能使用实体类作为返回值，只能使用集合，否则会抛出异常TooManyResultsException；但是若查询的数据只有一条，可以使用实体类或集合作为返回值

五、获取参数的两种方式

MyBatis获取参数值的两种方式：${}和#{}
${}的本质就是字符串拼接,存在SQL注入的问题，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号，而且不能命名为纯数字
#{}的本质就是占位符赋值,占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号

1.单个字面量类型的参数

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

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

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

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

若mapper接口中的方法参数有多个时，Mybatis框架会自动将这些参数放在一个Map集合中，底层是通过ParamNameResolver类将数据封装到Map集合，一个参数值对应两个键
- 以arg0,arg1...为键，以参数为值
- 以param1,param2...为键，以参数为值

	<select id="checkLogin" resultType="user">
        select *from t_user where username=#{arg0} and password=#{arg1};
    </select>
	<select id="checkLogin" resultType="user">
        select *from t_user where username=#{param1} and password=#{param2};
    </select>

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

3.map集合类型的参数

若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号

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

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

4.实体类类型的参数

若mapper接口中的方法参数为实体类对象时此时可以使用${}和#{}，通过访问实体类对象中的属性名获取属性值，注意${}需要手动加单引号

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

@Test
    public void testAddUser() throws IOException {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User(null,"cqy","123",23,"男","cqy@cqy.com");
        mapper.addUser(user);
    }

5.使用@Param表示参数

可以通过@Param注解标识mapper接口中的方法参数，此时会将参数放在map集合中
- 以@Param注解的value属性值为键，以参数为值
- 以param1,param2…为键，以参数为值
只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号

User CheckLoginByParam(@Param("username") String username, @Param("password") String password);

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

@Test
public void checkLoginByParam() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	ParameterMapper mapper = sqlSession.getMapper(ParameterMapper.class);
	mapper.CheckLoginByParam("admin","123456");
}

总结

建议分成两种情况进行处理
1. 实体类类型的参数
2. 使用@Param标识参数

六、各种查询功能

如果查询出的数据只有一条，可以通过
1. 实体类对象接收
2. List集合接收
3. Map集合接收，结果{password=123456, sex=男, id=1, age=23, username=admin}
如果查询出的数据有多条，一定不能用实体类对象接收，会抛异常TooManyResultsException，可以通过
1. 实体类类型的LIst集合接收
2. Map类型的LIst集合接收
3. 在mapper接口的方法上添加@MapKey注解

1.查询一个实体类对象

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

@Test
    public void queryUser() throws IOException {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        String username = "张三";
        User user = mapper.getUserByUsername(username);
        System.out.println(user);
    }

2.查询一个list集合

/**
 * 查询所有用户信息
 * @return
 */
List<User> queryAllUser();

	<select id="queryAllUser" resultType="User">
        select * from t_user;
    </select>

3.查询单个数据

/**  
 * 查询用户的总记录数  
 * @return  
 * 在MyBatis中，对于Java中常用的类型都设置了类型别名  
 * 例如：java.lang.Integer-->int|integer  
 * 例如：int-->_int|_integer  
 * 例如：Map-->map,List-->list  
 */  
int getCount();

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

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

会以属性为key，属性值为value，存储到map集合中
resultType，可以为全类名，也可以为别名map不区分大小写

Map<String,Object> queryUserByIdToMap(@Param("id") String id);

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

 @Test
    public void testQueryUserByIdToMap() throws IOException {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map = mapper.queryUserByIdToMap("2");
        System.out.println(map);
    }

结果：{password=123, sex=男, id=2, age=22, email=ls@ls.com, username=李四}

注意

若某个字段的值为 null,则不会存储到map集合中，也就是说map集合中没有该字段的任何信息

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

直接查询会报错，一个map集合只能存放一条信息，有两种解决方案

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VopPmJki-1686797154284)(./assets/image-20230601224332170.png)]

方法一：用list集合存储查询到的map集合数据，将泛型设置为Map集合

将查询到的每条数据转换为一个map集合，存储到list集合中，最终以list集合的形式返回数据

    List<Map<String,Object>> queryUserAllToMap();

	<!-- 注意这里的resultType的值为 Map而不是list -->
	<select id="queryUserAllToMap" resultType="java.util.Map">
        select *from t_user;
    </select>

@Test
    public void testQueryUserAllToMap() throws IOException {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<Map<String,Object>> list= mapper.queryUserAllToMap();
        list.forEach(System.out::println);
    }

结果:

{password=123, sex=女, id=1, age=23, email=zs@zs.com, username=张三}
{password=123, sex=男, id=2, age=22, email=ls@ls.com, username=李四}
{password=123, sex=男, id=3, age=32, email=ww@ww.com, username=王五}
{password=123, sex=男, id=4, age=23, email=cqy@cqy.com, username=cqy}
{password=123, sex=男, id=5, age=23, email=cqy@cqy.com, username=cqy}

方法二：使用`@MapKey("字段名")`

将每条数据转换为一个Map集合，以注解@MapKey("")指定字段名为key，每一个Map集合为value存储，最终以map集合的形式返回数据

@MapKey("id")
    Map<String,Object> queryUserAllToMapMap();

 @Test
    public void testQueryUserAllToMap() throws IOException {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map<String, Object> map = mapper.queryUserAllToMapMap();
        System.out.println(map);
    }

结果

{1={password=123, sex=女, id=1, age=23, email=zs@zs.com, username=张三}, 2={password=123, sex=男, id=2, age=22, email=ls@ls.com, username=李四}, 3={password=123, sex=男, id=3, age=32, email=ww@ww.com, username=王五}, 4={password=123, sex=男, id=4, age=23, email=cqy@cqy.com, username=cqy}, 5={password=123, sex=男, id=5, age=23, email=cqy@cqy.com, username=cqy}}

总结

将查询结果转换为map集合，用于查询结果没有对应的实体类的时候

七、特殊的SQL

1.模糊查询

三种方式：

select * from 表名 where 字段名 like '%${参数}%';
select * from 表名 where 字段名 like concat('%',#{参数},'%');
select * from 表名 where 字段名 like "%"#{参数}"%"; 最常用

List<User> fuzzyQueryUser(@Param("str") String str);

	<select id="fuzzyQueryUser" resultType="com.cqy.mybatis.pojo.User">
        <!-- select * from t_user where username like '%${str}%'; -->
        select * from t_user where username like concat('%',#{str},'%');
        <!--select * from t_user where username like "%"#{str}"%";-->
    </select>

2.批量删除 ${}

SQL语句:delete from 表名 where 字段名 in (${参数});

    int deleteMore(@Param("ids") String ids);

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

@Test
    public void del() throws IOException {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.deleteMore("4,5");
        System.out.println("执行行数" + i + "  删除成功");
    }

注意：

执行批量删除时只能使用${}，解析后的SQL语句为delete from t_user where id in (4,5);

如果使用#{}，则解析后的sql语句为delete from t_user where id in ('1,2,3')，这样是将1,2,3看做是一个整体，只有id为1,2,3的数据会被删除。

正确的语句应该是delete from t_user where id in (1,2,3)，或者delete from t_user where id in ('1','2','3')

3.动态设置表名 ${}

只能使用${}，因为#{}会默认添加单引号，而表名不能加单引号

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

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

两个重要属性

useGeneratedKeys:表示当前添加功能使用自增的主键
keyProperty:将添加的数据的自增主键为实体类类型的参数的属性赋值

作用：可以在添加完成之后获取自增的属性值

<!--
        useGeneratedKeys:表示当前添加功能使用自增的主键
        keyProperty:将添加的数据的自增主键为实体类类型的参数的属性赋值
        -->
    <insert id="insertUserById" useGeneratedKeys="true" keyProperty="id">
        insert into t_user values (null,#{username},#{password},#{age},#{sex},#{email});
    </insert>

@Test
    public void testInsertUser() throws IOException {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User(null,"cqy","123",23,"男","cqy@cqy.com");
        mapper.insertUserById(user);
        System.out.println(user);
    }

八、自定义映射

1.全局配置字段和属性的映射关系

前提

当字段名与属性名不一致，且字段名符合数据库命名规则"_"，而属性名符合Java的命名规则(驼峰命名法)

解决方案

在SQL语句中为查询字段设置别名，和属性名保持一致
当字段复合MYSQL的要求使用 “_” ，而属性复合Java的要求使用驼峰

此时可在核心配置文件中设置一个全局配置，自动将下划线映射为驼峰
例如:emp_id:empId

	<settings>
        <!-- 将下划线映射为驼峰 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

2.resultMap处理字段和属性的映射关系

总结

resultMap：设置自定义映射
常用属性：
id：表示自定义映射的唯一标识，不能重复
type：查询的数据要映射的实体类的类型

常用子标签：
id：设置主键的映射关系
property：设置映射关系中实体类中的属性名
column：设置映射关系中表中的字段名

result：设置普通字段的映射关系
property：设置映射关系中实体类中的属性名
column：设置映射关系中表中的字段名

association：处理多对一的映射关系（处理实体类类型的属性)
property:实体类类型属性
javaType:实体类类型
select:设置分步查询的SQL的唯一标识
column:将查询出的某个字段作为分步查询的SQL条件
fetchType:在开启了延迟加载的全局环境中，通过该属性设置当前的分步查询是否使用延迟加载
eager立即加载
lazy延迟加载

collection:处理一对多的映射关系(处理集合类型的属性)
property：设置映射关系中实体类中的属性名
ofType：用于设置list集合中存储数据的类型

	<resultMap id="empResultMap" type="emp">
        <id column="emp_id" property="empId"/>
        <result column="emp_name" property="empName"/>
        <result column="age" property="age"/>
        <result column="gender" property="gender"/>
    </resultMap>
 <!-- 使用自定义映射，解决字段名与属性名不匹配的问题 -->
    <select id="queryEmpById" resultMap="empResultMap">
        select *from t_emp where emp_id=#{empId}
    </select>

2.1 处理多对一的映射关系

2.1.1 级联方式处理映射关系

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

查询结果:Emp{empId=1, empName='张三', age='20', gender='男', dept=Dept{deptId='1', deptName='A'}}

2.1.2 使用association处理映射关系

 	<resultMap id="empAndDeptResultMapAss" type="emp">
        <id column="emp_id" property="empId"/>
        <result column="emp_name" property="empName"/>
        <result column="age" property="age"/>
        <result column="gender" property="gender"/>
        <!--
			association:处理多对一的的映射关系，准确点，处理实体类类型的属性
            property:属性
            javaType:对应的实体类
        -->
        <association property="dept" javaType="dept">
            <id column="dept_id" property="deptId"/>
            <result column="dept_name" property="deptName"/>
        </association>
    </resultMap>

查询结果:Emp{empId=1, empName='张三', age='20', gender='男', dept=Dept{deptId='1', deptName='A'}}

2.1.3 分步查询

还是使用association标签，但是使用属性有变化

property:设置需要处理映射关系的属性的属性名
select:下一步SQL语句的唯一标识
column:将查询出的某一个字段作为分步查询的SQL的条件

第一步查询员工信息

<!--Emp getEmpAndDeptByStepOne(@Param("empId")Integer empId);-->
<!-- 分步查询 -->
    <resultMap id="empAndDeptResultMapByStep" type="emp">
        <id column="emp_id" property="empId"/>
        <result column="emp_name" property="empName"/>
        <result column="age" property="age"/>
        <result column="gender" property="gender"/>
        <!--
            property:设置需要处理映射关系的属性的属性名
            select:设置下一步SQL语句的唯一标识
            column:将查询出的某一个字段作为分步查询的SQL的条件
        -->
        <association property="dept"
                     select="com.cqy.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
                     column="dept_id">
        </association>
    </resultMap>
    <select id="getEmpAndDeptByStepOne" resultMap="empAndDeptResultMapByStep">
        select *from t_emp where emp_id=#{empId};
    </select>

第二步查询部门信息

	<!--Dept getEmpAndDeptByStepTwo(@Param("deptId")Integer deptId);-->
	<select id="getEmpAndDeptByStepTwo" resultType="com.cqy.mybatis.pojo.Dept">
        select *from t_dept where dept_id=#{deptId};
    </select>

2.2 处理一对多的映射关系

2.2.1 使用`collection`标签

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

	<resultMap id="deptAndEmpByDeptId" type="dept">
        <id column="dept_id" property="deptId"/>
        <result column="dept_name" property="deptName"/>
        <!-- ofType:用于设置list集合中存储数据的类型 -->
        <collection property="emps" ofType="emp">
            <id column="emp_id" property="empId"/>
            <result column="emp_name" property="empName"/>
            <result column="age" property="age"/>
            <result column="gender" property="gender"/>
        </collection>
    </resultMap>
    <select id="getDeptAndEmpByDeptId" resultMap="deptAndEmpByDeptId">
        select *from t_dept
            left join t_emp te
                on t_dept.dept_id = te.dept_id
        where te.dept_id = #{deptId};
    </select>

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

结果:

Dept{deptId=1, deptName=‘A’, emps=[Emp{empId=1, empName=‘张三’, age=‘20’, gender=‘男’, dept=null}, Emp{empId=4, empName=‘赵六’, age=‘23’, gender=‘女’, dept=null}]}

2.2.2 分步查询

第一步，查询部门信息

	<!-- Dept getDeptAndEmpByStepOne(@Param("deptId")Integer deptId); -->
<!-- 分步查询实现一对多的映射关系 -->
    <resultMap id="deptAndEmpByStep" type="dept">
        <id column="dept_id" property="deptId"/>
        <result column="dept_name" property="deptName"/>
        <collection property="emps"
                    select="com.cqy.mybatis.mapper.EmpMapper.getDeptAndEmpByStepTwo"
                    column="dept_id">
        </collection>
    </resultMap>
    <select id="getDeptAndEmpByStepOne" resultMap="deptAndEmpByStep">
        select *from t_dept where dept_id=#{deptId};
    </select>

第二步，根据部门Id查询员工

	<!-- List<Emp> getDeptAndEmpByStepTwo(@Param("deptId")Integer deptId); -->
	<select id="getDeptAndEmpByStepTwo" resultType="com.cqy.mybatis.pojo.Emp">
        select *from t_emp where dept_id=#{deptId};
    </select>

分步查询的优点，延迟加载

优点：按需求加载SQL语句，节省内存开销

必须进行全局配置，才能实现这个优点

		<!-- 开启延迟加载 -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!-- 按需加载 默认值就为false，写出来明确-->
        <setting name="aggressiveLazyLoading" value="false"/>

与lazyLoadingEnabled和aggressiveLazyLoading这两个标签有关，只是aggressiveLazyLoading的默认值就为false为开启了按需加载，所以可以不用配置

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

此时若某个需求需要关闭延时加载也就是要进行完整查询

可通过association和collection中的 fetchType 属性设置当前的分步查询是否使用延迟加载
两个属性值：
- lazy 延迟加载
- eager 立即加载

举例
@Test
 public void testGetEmpAndDeptByStep() throws IOException {
     SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
     EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
     Emp emp = mapper.getEmpAndDeptByStepOne(1);
     System.out.println(emp.getEmpName());
 }
未开启延迟加载

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UqZLA1RZ-1686797154285)(./assets/image-20230603174400416.png)]

开启延时加载

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rkEEVxrz-1686797154286)(./assets/image-20230603174317936.png)]

效果显著

九、动态SQL

1.if标签

if标签可以通过 test 属性中的表达式进行条件判断，判断是否执行标签中的内容
- test属性中的表达式与实体类中的属性值相匹配

	<select id="getEmpByCondition" resultType="com.cqy.mybatis.pojo.Emp">
        select *from t_emp where 1=1
        <if test="empName != null and empName != ''">
            and emp_name=#{empName}
        </if>
        <if test="age != null and age != ''">
            and age=#{age}
        </if>
        <if test="gender != null and gender != ''">
            and gender=#{gender}
        </if>
    </select>

问题

当where后的首个条件判断不成立，则会出现 where and 连在一起的情况，SQL语句报错

解决方案添加恒成立条件

在where后面添加一个恒成立条件1=1
这个恒成立条件并不会影响查询的结果
- 这个1=1可以用来拼接and语句，例如：当empName为null时
- 如果不加上恒成立条件，则SQL语句为select * from t_emp where and age = ? and sex = ? and email = ?，此时where会与and连用，SQL语句会报错
- 如果加上一个恒成立条件，则SQL语句为select * from t_emp where 1= 1 and age = ? and sex = ? and email = ?，此时不报错

2.where标签

where和if结合使用,可以很好的解决上面发生的问题，会自动判断当前情况，是否需要添加where或者是否需要去掉字段名前面多余的and/or

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

	<select id="getEmpByCondition" resultType="com.cqy.mybatis.pojo.Emp">
        select *from t_emp
        <where>
            <if test="empName != null and empName != ''">
                and emp_name=#{empName}
            </if>
            <if test="age != null and age != ''">
                and age=#{age}
            </if>
            <if test="gender != null and gender != ''">
                and gender=#{gender}
            </if>
        </where>
    </select>

3.trim标签

相当于where标签的加强版，有更强的可控制性，一共有四个属性供选择：

prefix：前缀，在标签内容前面添加指定内容
prefixOverrides：在标签内容前面删除指定内容
suffix：后缀，在标签内容后面删除指定内容
suffixOverrides：在标签内容后面删除指定内容

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

4.choose、when、otherwise标签

choose、when、otherwise相当于if...else if..else
when相当于if...else if...至少要有一个
otherwise相当于else...至多只有一个

 	<select id="getEmpByCondition" resultType="com.cqy.mybatis.pojo.Emp">
         select *from t_emp
        <where>
            <choose>
                <when test="empName != null and empName != ''">
                    and emp_name=#{empName}
                </when>
                <when test="age != null and age != ''">
                    and age=#{age}
                </when>
                <when test="gender != null and gender != ''">
                    and gender=#{gender}
                </when>
            </choose>
        </where>
    </select>

5.foreach标签

属性：

collection：设置要循环的数组或集合
item：表示集合或数组中的每一个数据
separator：设置循环体之间的分隔符，分隔符前后默认有一个空格，如,
open：设置foreach标签中的内容的开始符
close：设置foreach标签中的内容的结束符

批量添加

    void insertMoreEmp(@Param("emps") List<Emp> emps);

	<!-- 注意在foreach中获取参数时，不能直接使用属性名，要以单个集合对象.属性名去获取属性 -->
	<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(true);
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        Emp emp1 = new Emp(null, "小明", 23, "男");
        Emp emp2 = new Emp(null, "小红", 20, "男");
        Emp emp3 = new Emp(null, "小布", 20, "男");
        List<Emp> list = Arrays.asList(emp1, emp2, emp3);
        mapper.insertMoreEmp(list);
    }

快速生成list集合的方法Arrays.asList(数组)

批量删除

    void DelMoreEmp(@Param("empIds")int[] empIds);

	方式一：推荐使用
	<delete id="DelMoreEmp">
        delete from t_emp where emp_id in
        <foreach collection="empIds" item="empId" separator="," open="(" close=")">
            #{empId}
        </foreach>
    </delete>
	方式2：
	<delete id="DelMoreEmp">
        delete from t_emp where emp_id in
        (
        <foreach collection="empIds" item="empId" separator=",">
            #{empId}
        </foreach>
        )
    </delete>
	方式三：
	<delete id="DelMoreEmp">
        delete from t_emp where emp_id in
        <foreach collection="empIds" item="empId" separator="or">
            emp_id = #{empId}
        </foreach>
    </delete>

 @Test
    public void testDelMoreEmp() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        int[] empIds = {5, 6, 7};
        mapper.DelMoreEmp(empIds);
    }

6.SQL片段

使用Sql片段的原因

*在传入数据库中还需要转换为每个字段，影响性能，使用Sql片段免去*的转换过程，提高性能

通过<sql>标签记录一段公共sql片段，在使用的地方通过<include>标签进行引入
<include>
- 属性 refid:是sql片段的id值

	<!-- 记录SQL片段 -->
	<sql id="empColumns">
        emp_id,emp_name,age,gender,dept_id
    </sql>

	<select id="getEmpByCondition" resultType="com.cqy.mybatis.pojo.Emp">
		<!-- 引入SQL片段 -->
        select <include refid="empColumns"></include>from t_emp
        <where>
            <choose>
                <when test="empName != null and empName != ''">
                    and emp_name=#{empName}
                </when>
                <when test="age != null and age != ''">
                    and age=#{age}
                </when>
                <when test="gender != null and gender != ''">
                    and gender=#{gender}
                </when>
            </choose>
        </where>
    </select>

十、缓存

1.一级缓存

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

使一级缓存失效的四种情况：
1. 不同的SqlSession对应不同的一级缓存
2. 同一个SqlSession但是查询条件不同
3. 同一个SqlSession两次查询期间执行了任何一次增删改操作，会自动清空缓存
4. 同一个SqlSession两次查询期间手动清空了缓存
  - sqlSession.clearCache();清空当前缓存

2.二级缓存

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

二级缓存开启的条件
1. 在核心配置文件中，设置全局配置属性，在<settings>标签中配置<setting name="cacheEnabled" value="true"/>，默认为true，所以不需要设置
2. 在映射文件中设置标签<cache />
3. 二级缓存必须在SqlSession关闭或提交之后有效 SQLSession.close();
4. 查询的数据所转换的实体类类型必须实现序列化的接口 implements Serializable
使二级缓存失效的情况：两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效

3.二级缓存的相关配置

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

eviction属性：缓存回收策略
- LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。
- FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。
- SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
- WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
- 默认的是 LRU
flushInterval属性：刷新间隔，单位毫秒
- 默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句（增删改）时刷新
size属性：引用数目，正整数
- 代表缓存最多可以存储多少个对象，太大容易导致内存溢出, 所以一般不会设置,使用默认
readOnly属性：只读
- true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
- false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false

4.MyBatis缓存查询的顺序

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

5.整合第三方缓存EHCache（了解）

添加依赖

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

各个jar包的功能

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

创建EHCache的配置文件ehcache.xml

名字必须叫ehcache.xml

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

设置二级缓存的类型

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

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

加入logback日志

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

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

EHCache配置文件说明

属性名	是否必须	作用
maxElementsInMemory	是	在内存中缓存的element的最大数目
maxElementsOnDisk	是	在磁盘上缓存的element的最大数目，若是0表示无穷大
eternal	是	设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds、timeToLiveSeconds判断
overflowToDisk	是	设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
timeToIdleSeconds	否	当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
timeToLiveSeconds	否	缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
diskSpoolBufferSizeMB	否	DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区
diskPersistent	否	在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false
diskExpiryThreadIntervalSeconds	否	磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
memoryStoreEvictionPolicy	否	当内存缓存达到最大，有新的element加入的时候，移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出

十一、逆向工程

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

1.创建逆向工程的步骤

注意事项，再次执行逆向工程时需要删除上次逆向工程生成的所有文件，否则生成内容会后缀在文件中

1.1 添加Maven依赖和插件坐标

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

1.2 创建mybatis配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--引入properties配置文件,此后可使用 方式获取value -->
    <properties resource="jdbc.properties"/>

    <settings>
        <!-- 将下划线映射为驼峰 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- 开启延迟加载 -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!-- 按需加载 默认值就为false，写出来明确-->
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>
    <!-- 由于全类名非常的长，通过typeAliases可以为类配置简短的别名 -->
    <typeAliases>
        <package name="修改1"/>
    </typeAliases>
    <!--设置连接数据库的环境-->
    <environments default="development">
        <!--
            environment : 设置一个具体的连接数据库的环境
            属性
            id : 唯一标识，不能重复
        -->
        <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>

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

文件名必须是：generatorConfig.xml
targetRuntime: 执行生成的逆向工程的版本，共有两个版本：
- MyBatis3Simple: 生成基本的CRUD（清新简洁版）
- MyBatis3: 生成带条件的CRUD（奢华尊享版）

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

1.4 执行MBG插件的generate目标

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mj1R5Dh7-1686797154288)(./assets/image-20230605111321172.png)]

2.MyBatis3奢华尊享版，是QBC风格的

即可以生成带条件的Sql方法

查询

selectByExample：按条件查询，需要传入一个example对象或者null；如果传入一个null，则表示没有条件，也就是查询所有数据
example.createCriteria().xxx：创建条件对象，通过andXXX方法为SQL添加查询添加，每个条件之间是and关系
example.or().xxx：将之前添加的条件通过or拼接其他条件

 @Test
    public void demo1() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        //1
        EmpExample empExample = new EmpExample();
        //2.调用createCriteria方法后面的方法见名知意
        empExample.createCriteria().andAgeEqualTo(20);
        List<Emp> list = mapper.selectByExample(empExample);
        list.forEach(System.out::println);
    }

增改

updateByPrimaryKey：通过主键进行数据修改，如果某一个值为null，也会将对应的字段改为null
mapper.updateByPrimaryKey(new Emp(1,"admin",22,null,"456@qq.com",3));
updateByPrimaryKeySelective()：通过主键进行选择性数据修改，如果某个值为null，则不修改这个字段
mapper.updateByPrimaryKeySelective(new Emp(2,"admin2",22,null,"456@qq.com",3));

十二、分页插件

常用数据分析：

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

1.分页插件的配置

1.1添加依赖

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

1.2核心配置文件配置分页插件

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

PageInterceptor是拦截器，在查询功能之前，然后加入limit关键字，实现分页

2.分页插件的使用 PageHelper.startPage

在查询功能之前使用PageHelper.startPage(int pageNum, int pageSize)开启分页功能
- pageNum：当前页的页码
- pageSize：每页显示的条数

@Test
    public void demo2() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        //查询功能开始之前开启分页功能
        PageHelper.startPage(1,4);
        List<Emp> list = mapper.selectByExample(null);
        list.forEach(System.out::println);

    }

3.分页相关数据

方法一：直接输出

 @Test
    public void demo2() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        Page<Object> page = PageHelper.startPage(2, 4);
        //在不使用逆向工程时，可自定义将这个方法的返回值设置为Page类型，因为Page类继承了ArrayList
        List<Emp> list = mapper.selectByExample(null);
//        list.forEach(System.out::println);
        System.out.println(page);
    }

分页相关数据：

Page{count=true, pageNum=2, pageSize=4, startRow=4, endRow=8, total=6, pages=2, reasonable=false, pageSizeZero=false}

[Emp{empId=5, empName=‘赵六’, age=23, gender=‘女’, deptId=1}, Emp{empId=8, empName=‘null’, age=null, gender=‘null’, deptId=null}]

方法二使用PageInfo

相对于直接获取，这种方式内容更加丰富，数据更加全面

在查询获取list集合之后，使用PageInfo<T> pageInfo = new PageInfo<>(List<T> list, intnavigatePages)获取分页相关数据
- list：分页之后的数据
- navigatePages：
  - 表示示分页导航连续显示的页数。具体来说，当页面需要显示多页数据时，分页导航会显示当前页码的前navigatePages页和后navigatePages页，总计2 * navigatePages + 1个页面链接。
  - navigatePages属性可以控制分页导航中显示的页面链接数量，从而提高页面的可用性和易用性。
  - 默认情况下，navigatePages的值为8，这意味着在分页导航中最多显示17个页面链接。

 @Test
    public void demo3() {
        SqlSession sqlSession = SqlSessionUtil.getSqlSession(true);
        EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
        PageHelper.startPage(1,4);
        List<Emp> list = mapper.selectByExample(null);
        PageInfo<Emp> pageInfo = new PageInfo<>(list, 5);
        System.out.println(pageInfo);
    }

数据

PageInfo{pageNum=2, pageSize=4, size=2, startRow=5, endRow=6, total=6, pages=2,

list=Page{count=true, pageNum=2, pageSize=4, startRow=4, endRow=8, total=6, pages=2, reasonable=false, pageSizeZero=false}

[Emp{empId=5, empName=‘赵六’, age=23, gender=‘女’, deptId=1}, Emp{empId=8, empName=‘null’, age=null, gender=‘null’, deptId=null}], prePage=1, nextPage=0, isFirstPage=false, isLastPage=true, hasPreviousPage=true, hasNextPage=false, navigatePages=5, navigateFirstPage=1, navigateLastPage=2, navigatepageNums=[1, 2]}

PageInfo返回数据详细描述

pageNum：当前页码。
pageSize：每页显示的条数。
size：当前页的实际条数，等同于结果集的大小。
startRow：当前页第一条数据的行号，从 1 开始计数。
endRow：当前页最后一条数据的行号。
total：查询结果总条数。
pages：查询结果总页数。
list：查询结果集合。
prePage：上一页页码。
nextPage：下一页页码。
isFirstPage：当前是否为第一页。
isLastPage：当前是否为最后一页。
hasPreviousPage：当前是否有上一页。
hasNextPage：当前是否有下一页。
navigatePages：导航页码数。
navigatepageNums：所有导航页的页码集合。

注意

以上属性中，pageNum、pageSize、total 和 list 是必须要有的属性，其它属性都是可选的。其中，list 属性存储了查询结果集合。查询结果的每一条记录都被封装成一个 Java 对象，并包含在 list 属性中。
PageInfo 类是 MyBatis 分页查询的一个常用类，提供了对分页查询结果的封装和操作，能够极大地简化分页查询的代码编写，并提高代码的可读性和可维护性

总结

所需基本的Maven坐标

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

        <!-- 3.log4j日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    	<!-- 4.分页插件 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.2.0</version>
        </dependency>
    </dependencies>

MyBatis核心配置文件

标签顺序：properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?

<?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>
    <!--1.引入properties配置文件,此后可使用 方式获取value -->
    <properties resource="jdbc.properties"/>

    <!-- 2.全局配置 -->
    <settings>
        <!-- 将下划线映射为驼峰 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- 开启延迟加载 -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!-- 按需加载 默认值就为false，写出来明确-->
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>
    <!-- 3.由于全类名非常的长，通过typeAliases可以为类配置简短的别名 -->
    <typeAliases>
        <package name="com.cqy.mybatis.pojo"/>
    </typeAliases>
    <!-- 4.分页插件相关配置 -->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor"/>
    </plugins>
    <!-- 5.设置连接数据库的环境-->
    <environments default="development">
        <!--
            environment : 设置一个具体的连接数据库的环境
            属性
            id : 唯一标识，不能重复
        -->
        <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>

    <!-- 6.引入映射文件-->
    <mappers>
        <package name="com.cqy.mybatis.mapper"/>
    </mappers>
</configuration>

log4j配置文件

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

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=密码

陳青雲

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Mybatis笔记 + 总结(

一、简介二、搭建框架三、核心配置文件四、增删改查五、获取参数六、各种查询七、特殊的SQL八、自定义映射九、动态SQL十、缓存十一、逆向工程十二、分页插件总结
复制链接

扫一扫

专栏目录