mybatis学习笔记 非常全

mybatis学习笔记

Mybatis简介

MyBatis历史

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

MyBatis特性

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

MyBatis下载

• MyBatis下载地址
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o24VsjFv-1648971704589)(D:\尚硅谷学习资料\狂神说注解和反射\images\MyBatis下载.png)]

和其它持久化层技术对比

• 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

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

创建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.cj.jdbc.Driver"/>  
				<property name="url" value="jdbc:mysql://localhost:3306/MyBatis"/>  
				<property name="username" value="root"/>  
				<property name="password" value="123456"/>  
			</dataSource>  
		</environment>  
	</environments>  
	<!--引入映射文件-->  
	<mappers>  
		<mapper resource="mappers/UserMapper.xml"/>  
	</mappers>  
</configuration>

创建mapper接口

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

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

创建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.atguigu.mybatis.mapper.UserMapper">  
	<!--int insertUser();-->  
	<insert id="insertUser">  
		insert into t_user values(null,'张三','123',23,'女')  
	</insert>  
</mapper>

通过junit测试功能

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

public class UserMapperTest {
    @Test
    public void testInsertUser() throws IOException {
        //读取MyBatis的核心配置文件
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        //获取SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //通过核心配置文件所对应的字节输入流创建工厂类SqlSessionFactory，生产SqlSession对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        //获取sqlSession，此时通过SqlSession对象所操作的sql都必须手动提交或回滚事务
        //SqlSession sqlSession = sqlSessionFactory.openSession();
	    //创建SqlSession对象，此时通过SqlSession对象所操作的sql都会自动提交  
		SqlSession sqlSession = sqlSessionFactory.openSession(true);
        //通过代理模式创建UserMapper接口的代理实现类对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配元素文件，通过调用的方法名匹配映射文件中的SQL标签，并执行标签中的SQL语句
        int result = userMapper.insertUser();
        //提交事务
        //sqlSession.commit();
        System.out.println("result:" + result);
    }
}

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

加入log4j日志功能

1. 加入依赖

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

2. 加入log4j的配置文件

   • log4j的配置文件名为log4j.xml，存放的位置是src/main/resources目录下
   • 日志的级别：FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试) 从左到右打印的内容越来越详细

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

核心配置文件详解

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

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T5IwI2CP-1648971704593)(D:\尚硅谷学习资料\狂神说注解和反射\images\mapper接口和mapper映射文件在同一包下.png)]

默认的类型别名

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kC3CK9Rc-1648971704594)(D:\尚硅谷学习资料\狂神说注解和反射\images\默认的类型别名1.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C5VG4FHU-1648971704596)(D:\尚硅谷学习资料\狂神说注解和反射\images\默认的类型别名2.png)]

1.给全类名起别名

注意：标签的位置要放对，不然会报错propertis-settings-typerAliases。。。。

其中，若alias没有写，那么默认为类名，不区分大小写

（一般来说很少会写别名）

一般用这种

2.关于引入映射文件

​ (一)package和 directory 的区别，package是一层层目录创建时应该以/为分割，即…/…/…/，而 directory 是一个文件以/为分割符，即：xx.xx.xx

（二）mybatis.xml引入映射文件的方法（可用于mapper文件很多的情况下）

注意：.mapper接口所在的包要和映射文件所在的包名一致

​ …mapper接口要和映射文件的名字一致，注意看图中的结构

方法一：

注意：上图的路径创建时是以/为分割符，创建好的时候变成了.

方法二：

3.mybatis引入propertis文件的方法

而在融合spring之后是

4.设置模板

将模板粘贴上去就ok啦

5.在开发中由于获取sqlsession的步骤是一样的且步骤较多，可将其步骤封装成一个工具类

ParameterMapper相当于之前写的dao类，而mapper相当于之前的dao类的实现类，sqlsession应该可以理解成一个connection对象

6.${}相当于jdbc中的字符串拼接，存在sql注入问题

#{}相当于jdbc 中的填充占位符，解决了sql注入问题（能用就用）

（一）获取单个字面量类型的情况

（2）多个字面量类型的情况（了解）

（3）第三种情况，由第二种情况演变而来，自己创建map，不用mabatis创建

执行流程：测试调用-接口方法调用-xml文件映射（了解）

xml中的获取参数和（2）中的一样，不过名字一定要对应上

（4）mapper的参数是一个实体类对象（常用）

如何获取？-直接用属性名获取

（5）使用注解的方式，也是第二第三种方法的集合（最常用）

使用@param(“”)指定key

（6）总结

二.MyBatis的各种查询功能:**

（一）若查询结果只有一条

• a>可以通过实体类对象接收

• b>可以通过list集合接收

• C>可以通过map集合接收（使用的频率最高）
  例结果: {password= 123456, sex=男， id=3, age=23, email=12345@qq. com, username=admin}

  以字段名，属性名为key，以字段值，属性值为值

  （在多表查询中没有实体类与其查询结果对应，而用map就很方便）

  

  （二）、若查询出的数据有多条

  a>可以通过实体类类型的list集合接收
  b>可以通过map类型的list集合接收

c>可以在mapper接口的方法上添加**@MapKey注解**，此时就可以将每条数据转换的map集合作为值，以某个字段作为key
注意:一定不能通过实体类对象接收，此时会抛异常TooManyResultsException

（二）MyBatis中设置了默认的类型别名

​ java. Lang. Integer–>int, integer

• int–>_ int,_ integer

  Map-- >map
  String–>string

  （三）不适合#{}之模糊查询

  例如’%#{ }%'并不会识别出来，不会赋值成功，结果是%？%，因为在单引号里面都是默认为字符串，此时${}更适合

  方案一

**方案二：**使用字符串拼接

方案三：使用较多

*

（四）不适合#{ }之批量删除

（五）mybatis处理动态设置表名

（六）mybatis中获取自增加的主键

创建班级-获取主键id->将主键id保存到班级对象上一获取班级id属性>设学生的班级id

（七）数据库与Java中属性的命名规则

数据库中两单词间用下划线连接_。

java中用驼峰命名规则

（八）解决字段名和属性名不匹配的

**方案一：**匹配不上的字段不会报错，但是赋不上值

方案二：设置全局配置，在mybatis中设置setting标签，将下划线变成驼峰，其value值为true/false，默认为false（推荐）

方案三：通过resultMap设置自定义的映射关系（还可用于处理一对多多对一的情况）

resultMap:设置自定义映射关系

id:唯一标识，不能重复*
type:设置映射关系中的类型

属性:

第二个id是主键属性

property:设置映射关系中的属性名，必须是type 属性所设置的实体类类型中的属性暑
column:设置映射关系中的字段名，必须是sql语句查询出的字段名

（九）

情况一：多对一 —>在多的实体类对象中创建 **一 **的对象

情况二：一对多>>>在一中创建多的集合即可

（一）解决多对一的方案一：通过级联属性赋值解决多对一的映射关系（最简单但不常用，了解即可）

**方案二：**通过assosiation这个标签设置

方案三：分步查询

第一步：

第二步：

优点：分步查询的优点:可以实现延迟加载,但是必须在核心配置文件中设置全局配置信息:
**lazyLoadingEnabled:**延迟加载的全局开关。当开启时，所有关联对象都会延迟加载
**aggressiveLazyLoading:**当开启时，任何方法的调用都会加载该对象的所有属性。否则， 每个属性会按需加载（默认false）
此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。 此时可通过association和collection中的fetchType属性设置当前的分步查询是否使用延迟加载，fetchType=“lazy(延迟加载) |eager(立即加载)”

开启时只会加载第一步的sql语句，第二步不会执行，只有调用了第二步的方法时才会执行第二个sql语句

（1.1）若开启了全局延迟加载，但是有一部分又不想延迟,可用fetchType属性去设置

fetchType有两个值，lazy：表示延迟加载 eager：表示立即执行

（2）处理一对多的情况

方案一：类似上面的方案二，通过collection处理

collection:处理一对多的映射关系
ofType:表示该属性所对应的集合中存储数据的类型

方案二：分步查询（一对多）

第一步：先查询部门信息

第二步：根据条件在查出需要的信息

（九）、动态SQL

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

（1）if:根据标签中test属性所对应的表达式决定标签中的内容是否需要拼接到SQL中

（2）动态sql之where标签（方式二）

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

2. 当where标签中没有内容时，此时where标签没有任何效果

3. 注意: where标签不能将其中内容后面多余的and或or去掉
   

（3）动态sql之trim标签（方式三）

1.若标签中有内容时:

（前缀后缀）prefix/suffix:将trim标签中内容前面或后面添加指定内容
（重写前缀或后缀）suffixoverrides Iprefixoverrides: 将trim标签中内容前面或后面去掉指定内容

2.若标签中没有内容时，trim标签也没有任何效果

（4）动态sql之choose, when, otherwise

​ 1.这是一套标签，when和other写在choose中

2. when相当于switch中的case，多个when只会执行一个，至少要有一个

​ 3. otherwise相当于switch中的default，最多只能有一个

（5）动态sql之foreach（批量删除）

• collection: 设置需要循环的数组或集合
• item: 表示数组或集合中的每-一个数据
• separator: 循环体之间的分割符
• open: foreach标签所循环的所有内容的开始符
• close: foreach标签所循环的所有内容的结束符

方式一：

方式二：使用where结合

（6）foreach之批量插入

测试

1.设置sQL片段: eid, emp_ name ，age, sex, email
2.引用sQL片段:

（十）MyBatis的缓存

1、MyBatis的一级缓存

一级缓存是SqlSession级别的，通过同一个SqISession查询的数据会被缓存， 下次查询相同的数据，就会从缓存中
直接获取，不会从数据库重新访问
使一级缓存失效的四种情况:
1)不同的SqISession对应不同的一级缓存
2)同一个Sq|Session但是查询条件不同
3)同一个SqlSession两次查询期间执行了任何一次增删改操作
4)同一个SqISession两次查询期间手动清空了缓存sqlSession.clearCache();

2、MyBatis的二级缓存

​ 二级缓存是SqISessionFactory级别，通过同一个SqISessionFactory创建的SqISession查询的结果会被缓存;此后若再次执行相同的查询语句，结果就会从缓存中获取
二级缓存开启的条件:

a>在核心配置文件中，设置全局配置属性cacheEnabled="true"，默认为true, 不需要设置

b>在映射文件中设置标签

c>二级缓存必须在SqISession关闭或提交之后有效（为了保证数据的一致性，如果还没提交或关闭就使用之前存储的数据，那是不一致的）注意：sqlSessionFactory.openSession(true)是提交事务的，并没有提交sqlSession

d>查询的数据所转换的实体类类型必须****实现序列化的接口

public class xxx implements Serializable {}

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

3、二级缓存的相关配置

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

4、MyBatis缓存查询的顺序

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

• 名字必须叫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（先进先出

MyBatis的逆向工程

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

创建逆向工程的步骤

添加依赖和插件

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

创建MyBatis的核心配置文件

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

创建逆向工程的配置文件

• 文件名必须是：generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--
    targetRuntime: 执行生成的逆向工程的版本
    MyBatis3Simple: 生成基本的CRUD（清新简洁版）
    MyBatis3: 生成带条件的CRUD（奢华尊享版）
    -->
    <context id="DB2Tables" targetRuntime="MyBatis3Simple">
        <!-- 数据库的连接信息 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis"
                        userId="root"
                        password="123456">
        </jdbcConnection>
        <!-- javaBean的生成策略-->
        <javaModelGenerator targetPackage="com.atguigu.mybatis.pojo" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- SQL映射文件的生成策略 -->
        <sqlMapGenerator targetPackage="com.atguigu.mybatis.mapper"
                         targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <!-- Mapper接口的生成策略 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.atguigu.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>

执行MBG插件的generate目标

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L10hibIm-1648971704657)(D:\尚硅谷学习资料\狂神说注解和反射\images\执行MBG插件的generate目标.png)]
• 如果出现报错：Exception getting JDBC Driver，可能是pom.xml中，数据库驱动配置错误
• dependency中的驱动[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7KVa0mGp-1648971704658)(D:\尚硅谷学习资料\狂神说注解和反射\images\dependency中的驱动.png)]
  • mybatis-generator-maven-plugin插件中的驱动[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PvjqKIdm-1648971704659)(D:\尚硅谷学习资料\狂神说注解和反射\images\插件中的驱动.png)]
  • 两者的驱动版本应该相同
• 执行结果[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UBhtSaUt-1648971704659)(D:\尚硅谷学习资料\狂神说注解和反射\images\逆向执行结果.png)]

QBC

查询

• selectByExample：按条件查询，需要传入一个example对象或者null；如果传入一个null，则表示没有条件，也就是查询所有数据
• example.createCriteria().xxx：创建条件对象，通过andXXX方法为SQL添加查询添加，每个条件之间是and关系
• example.or().xxx：将之前添加的条件通过or拼接其他条件
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rObVqMVr-1648971704660)(D:\尚硅谷学习资料\狂神说注解和反射\images\example的方法.png)]

@Test public void testMBG() throws IOException {
	InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
	SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
	SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	EmpExample example = new EmpExample();
	//名字为张三，且年龄大于等于20
	example.createCriteria().andEmpNameEqualTo("张三").andAgeGreaterThanOrEqualTo(20);
	//或者did不为空
	example.or().andDidIsNotNull();
	List<Emp> emps = mapper.selectByExample(example);
	emps.forEach(System.out::println);
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0nTo4Mxq-1648971704661)(D:\尚硅谷学习资料\狂神说注解和反射\images\example测试结果.png)]

增改

• updateByPrimaryKey：通过主键进行数据修改，如果某一个值为null，也会将对应的字段改为null
• mapper.updateByPrimaryKey(new Emp(1,"admin",22,null,"456@qq.com",3));
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pTT5R9Lc-1648971704662)(D:\尚硅谷学习资料\狂神说注解和反射\images\增删改测试结果1.png)]
• updateByPrimaryKeySelective()：通过主键进行选择性数据修改，如果某个值为null，则不修改这个字段
• mapper.updateByPrimaryKeySelective(new Emp(2,"admin2",22,null,"456@qq.com",3));
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e12snVHu-1648971704663)(D:\尚硅谷学习资料\狂神说注解和反射\images\增删改测试结果2.png)]

分页插件

分页插件使用步骤

添加依赖

<!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>5.2.0</version>
</dependency>

配置分页插件

• 在MyBatis的核心配置文件（mybatis-config.xml）中配置插件
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gf3As3kc-1648971704664)(D:\尚硅谷学习资料\狂神说注解和反射\images\配置分页插件.png)]

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

分页插件的使用

开启分页功能

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

@Test
public void testPageHelper() throws IOException {
	InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
	SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
	SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	//访问第一页，每页四条数据
	PageHelper.startPage(1,4);
	List<Emp> emps = mapper.selectByExample(null);
	emps.forEach(System.out::println);
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vn46Dmz7-1648971704665)(D:\尚硅谷学习资料\狂神说注解和反射\images\分页测试结果.png)]

分页相关数据

方法一：直接输出

@Test
public void testPageHelper() throws IOException {
	InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
	SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
	SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	//访问第一页，每页四条数据
	Page<Object> page = PageHelper.startPage(1, 4);
	List<Emp> emps = mapper.selectByExample(null);
	//在查询到List集合后，打印分页数据
	System.out.println(page);
}

• 分页相关数据：

  Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=8, pages=2, reasonable=false, pageSizeZero=false}[Emp{eid=1, empName='admin', age=22, sex='男', email='456@qq.com', did=3}, Emp{eid=2, empName='admin2', age=22, sex='男', email='456@qq.com', did=3}, Emp{eid=3, empName='王五', age=12, sex='女', email='123@qq.com', did=3}, Emp{eid=4, empName='赵六', age=32, sex='男', email='123@qq.com', did=1}]
  

方法二使用PageInfo

• 在查询获取list集合之后，使用PageInfo<T> pageInfo = new PageInfo<>(List<T> list, intnavigatePages)获取分页相关数据
• list：分页之后的数据
  • navigatePages：导航分页的页码数

@Test
public void testPageHelper() throws IOException {
	InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
	SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
	SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
	SqlSession sqlSession = sqlSessionFactory.openSession(true);
	EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
	PageHelper.startPage(1, 4);
	List<Emp> emps = mapper.selectByExample(null);
	PageInfo<Emp> page = new PageInfo<>(emps,5);
	System.out.println(page);
}

• 分页相关数据：

  PageInfo{
  pageNum=1, pageSize=4, size=4, startRow=1, endRow=4, total=8, pages=2, 
  list=Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=8, pages=2, reasonable=false, pageSizeZero=false}[Emp{eid=1, empName='admin', age=22, sex='男', email='456@qq.com', did=3}, Emp{eid=2, empName='admin2', age=22, sex='男', email='456@qq.com', did=3}, Emp{eid=3, empName='王五', age=12, sex='女', email='123@qq.com', did=3}, Emp{eid=4, empName='赵六', age=32, sex='男', email='123@qq.com', did=1}], 
  prePage=0, nextPage=2, isFirstPage=true, isLastPage=false, hasPreviousPage=false, hasNextPage=true, navigatePages=5, navigateFirstPage=1, navigateLastPage=2, navigatepageNums=[1, 2]}
  

• 其中list中的数据等同于方法一中直接输出的page数据

常用数据：

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