1、简介

---

1.1、什么是 MyBatis？

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

MyBatis本是apache的一个开源项目iBatis，2010年这个项目由apache software foundation迁移到了google code，并且改名为MyBatis。2013年11月迁移到Github。

1.2、持久化

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
• 内存:断电即失
• 数据库(Jdbc), io文件持久化。
• 生活:冷藏.罐头。

为什么需要需要持久化?

• 有一些对象，不能让他丢掉。
• 内存太贵了

1.3、持久层

Dao层，Service层，Controller层...

• 完成持久化工作的代码块
• 层界限十分明显。

1.4、为什么需要Mybatis

• 帮助程序猿将数据存入到数据库中。
• 方便
• 传统的JDBC代码太复杂了。简化。框架。自动化。
• 不用Mybatis也可以。 更容易上手。技术没有高低之分
• 优点:简单
  • 易学
  • 灵活
  • sq|和代码的分离,提高了可维护性。
  • 提供映射标签，支持对象与数据库的orm字段关系映射
  • 提供对象关系映射标签，支持对象关系组建维护
  • 提供xml标签,支持编写动态sql。

重要的一点:使用的人多!

2、第一个Mybatis程序

---

思路：搭建环境-->导入Mybatis-->编写代码-->测试

2.1、搭建环境

创建SQL表：

CREATE TABLE `user`  (
  `id` int(0) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT 'null',
  `pwd` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;


INSERT INTO `user` VALUES (1, '老大', '123456');
INSERT INTO `user` VALUES (2, '李二', '123456');
INSERT INTO `user` VALUES (3, '张三', '123456');
INSERT INTO `user` VALUES (4, '李四', '123456');

新建一个maven项目

导入依赖

<dependencies>  
    <dependency>        
	    <groupId>mysql</groupId>  
	    <artifactId>mysql-connector-java</artifactId>  
	    <version>8.0.29</version>  
    </dependency>  
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->  
    <dependency>  
        <groupId>org.mybatis</groupId>  
        <artifactId>mybatis</artifactId>  
        <version>3.5.10</version>  
    </dependency>  
    <dependency>        
	    <groupId>junit</groupId>  
        <artifactId>junit</artifactId>  
        <version>3.8.1</version>  
    </dependency>  
</dependencies>

编写Mybatis的核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE configuration  
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
        "http://mybatis.org/dtd/mybatis-3-config.dtd">  
<configuration>  
  
    <environments default="development">  
        <environment id="development">  
            <transactionManager type="JDBC"/>  
            <dataSource type="POOLED">  
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>  
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8&amp;serverTimezone=UTC&amp;useSSL=false"/>  
                <property name="username" value="root"/>  
                <property name="password" value="123456"/>  
            </dataSource>        </environment>    </environments>  
</configuration>

2.2、第一个mybati程序

编写Mybatis工具类

public class MybatisUtil {  
    private static SqlSessionFactory sqlSessionFactory;  
    static {  
        try{  
            String resource = "mybatis-config.xml";  
            InputStream inputStream = Resources.getResourceAsStream(resource);  
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
        }catch (IOException e){  
            e.printStackTrace();  
        }  
    }  
      
    public SqlSession getSqlSession(){  
        return sqlSessionFactory.openSession();  
    }  
}

编写代码

@Test  
public void t(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);  
    List<User> userList = mapper.getUserList();  
    for (User user : userList) {  
        System.out.println(user);  
    }  
    sqlSession.close();  
}

2.3、比较容易出现的问题

1、全局配置文件没有注册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>  
  
    <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?characterEncoding=utf-8&amp;serverTimezone=UTC&amp;useSSL=true"/>  
                <property name="username" value="root"/>  
                <property name="password" value="123456"/>  
            </dataSource>
		</environment>    
	</environments>    
	<mappers>        
		<mapper resource="com/zh/mapper/UserMapper.xml"></mapper>  
    </mappers>
</configuration>

2、mapper映射文件

<?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.zh.mapper.UserMapper">  一个命名空间对应一个dao类
    <select id="getUserList" resultType="com.zh.pojo.User">  //id对应方法。返回结果对实体类对象
        select * from mybatis.user  
    </select>  
</mapper>

3、资源文件导出问题，由于maven项目的约定大于配置，默认只会导出resources目录的文件，但是在mybatis项目中，mapper推荐把映射配置文件放在和dao类同一级目录，会导致加载不到配置文件，所以要进行设置

<build>  
    <resources>
		<resource>
			<directory>src/main/resources</directory>  
            <includes>                
	            <include>**/*.properties</include>  
                <include>**/*.xml</include>  
            </includes>           
            <filtering>true</filtering>  
        </resource>
        
        <resource>
            <directory>src/main/java</directory>  
            <includes>               
	             <include>**/*.properties</include>  
                 <include>**/*.xml</include>  
            </includes>            
            <filtering>true</filtering>  
		</resource>    
	</resources>
</build>

3、CRUD

---

namespace：namespace中的包名要和Dao/mapper接口的包名一致!

数据的增删改需要手动提交数据！！！

• **#{}是预编译处理，mybatis在处理#{}时，会将其替换成"?"，再调用PreparedStatement的set方法来赋值。
• ${}是拼接字符串，将接收到的参数的内容不加任何修饰的拼接在SQL语句中，会引发SQL注入问题

select

• id:就是对应的namespace中的方法名;
• resultType: Sq|语句执行的返回值
• parameterType :参数类型（可以是对象）
  1.编写接口

User getUserById(int id);

2.编写对应的mapper中的sq|语，属性可以直接调用

<select id="getUserById" resultType="com.zh.pojo.User">  
    select * from user where id=#{id}  
</select>

3.测试

public void t2(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);  
    User user = mapper.getUserById(1);  
    System.out.println(user);  
    sqlSession.commit();  
    sqlSession.close();  
}

Insert

int addUser(User user);

<insert id="addUser" parameterType="com.zh.pojo.User" >  
    insert into user(id,name,pwd) value (#{id},#{name},#{pwd})  
</insert>


@Test  
public void t3(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);  
    int num = mapper.addUser(new User(5, "张三", "123321"));  
    System.out.println(num);  
    sqlSession.commit();  
    sqlSession.close();  
}

update

int updateUser(User user);


<update id="updateUser" parameterType="com.zh.pojo.User">  
    update user set name = #{name},pwd=#{pwd}where id=#{id};  
</update>


@Test  
public void t4(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);  
    int num = mapper.updateUser(new User(5, "哈哈哈哈", "123321"));  
    System.out.println(num);  
    sqlSession.commit();  
    sqlSession.close();  
}

Delete

int delUser(int id);

<delete id="delUser" parameterType="int">  
    delete from user where id=#{id}  
</delete>

@Test  
public void t5(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);  
    int i = mapper.delUser(5);  
    System.out.println(i);  
    sqlSession.commit();  
    sqlSession.close();  
}

4、配置解析

---

configuration（配置）

• properties（属性）
• settings（设置）
• typeAliases（类型别名）
• typeHandlers（类型处理器）
• objectFactory（对象工厂）
• plugins（插件）
• environments（环境配置）
  • environment（环境变量）
    • transactionManager（事务管理器）
    • dataSource（数据源）
• databaseIdProvider（数据库厂商标识）
• mappers（映射器）

configuration 配置文件中，对标签的顺序有规定：

The content of element type "configuration" must match "(properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?)".

4.1、properties（属性）

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。例如：

<properties resource="org/mybatis/example/config.properties">
  <property name="username" value="dev_user"/>
  <property name="password" value="F2Fa3!33TYyg"/>
</properties>

设置好的属性可以在整个配置文件中用来替换需要动态配置的属性值。比如:

<dataSource type="POOLED">
  <property name="driver" value="${driver}"/>
  <property name="url" value="${url}"/>
  <property name="username" value="${username}"/>
  <property name="password" value="${password}"/>
</dataSource>

这个例子中的 username 和 password 将会由 properties 元素中设置的相应值来替换。 driver 和 url 属性将会由 config.properties 文件中对应的值来替换。这样就为配置提供了诸多灵活选择。

也可以在 SqlSessionFactoryBuilder.build() 方法中传入属性值。例如：

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, props);

SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, environment, props);

如果一个属性在不只一个地方进行了配置，那么，MyBatis 将按照下面的顺序来加载：

• 首先读取在 properties 元素体内指定的属性。
• 然后根据 properties 元素中的 resource 属性读取类路径下属性文件，或根据 url 属性指定的路径读取属性文件，并覆盖之前读取过的同名属性。
• 最后读取作为方法参数传递的属性，并覆盖之前读取过的同名属性。

因此，通过方法参数传递的属性具有最高优先级，resource/url 属性中指定的配置文件次之，最低优先级的则是 properties 元素中指定的属性。

4.2、settings（设置）

设置名	描述	有效值	默认值
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存	true / false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。	true / false	false
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J / LOG4J / LOG4J2 / JDK_LOGGING / COMMONS_LOGGING / STDOUT_LOGGING / NO_LOGGING	未设置

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

4.3、typeAliases（类型别名）

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。例如

<typeAliases>
  <typeAlias alias="Author" type="domain.blog.Author"/>
  <typeAlias alias="Blog" type="domain.blog.Blog"/>
  <typeAlias alias="Comment" type="domain.blog.Comment"/>
  <typeAlias alias="Post" type="domain.blog.Post"/>
  <typeAlias alias="Section" type="domain.blog.Section"/>
  <typeAlias alias="Tag" type="domain.blog.Tag"/>
</typeAliases>

当这样配置时，Blog 可以用在任何使用 domain.blog.Blog 的地方。

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如：

<typeAliases>
  <package name="domain.blog"/>
</typeAliases>

每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author 的别名为 author；若有注解，则别名为其注解值。见下面的例子：

@Alias("author")
public class Author {
    ...
}

4.4、环境配置(environments)

MyBatis可以配置成适应多种环境

通过 default="development" 来选择环境

<environments default="development">  //通过选择环境id选择环境
    <environment id="development">  
        <transactionManager type="JDBC"/>  //默认事务处理
	        <dataSource type="POOLED">     //默认使用连接池
            <property name="driver" value="${driver}"/>  
            <property name="url" value="${url}"/>  
            <property name="username" value="${username}"/>  
            <property name="password" value="${password}"/>  
        </dataSource>    
	</environment>


	<environment id="Test">  
        <transactionManager type="JDBC"/>  
        <dataSource type="POOLED">  
            <property name="driver" value="${driver}"/>  
            <property name="url" value="${url}"/>  
            <property name="username" value="${username}"/>  
            <property name="password" value="${password}"/>  
	</dataSource>
</environment></environments>

注意一些关键点:

• 默认使用的环境 ID（比如：default="development"）。
• 每个 environment 元素定义的环境 ID（比如：id="development"）。
• 事务管理器的配置（比如：type="JDBC"）。
• 数据源的配置（比如：type="POOLED"）。

默认环境和环境 ID 顾名思义。 环境可以随意命名，但务必保证默认的环境 ID 要匹配其中一个环境 ID。

事务管理器（transactionManager）

在 MyBatis 中有两种类型的事务管理器（也就是 type="JDBC|MANAGED"）：

• JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
• MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。例如:

提示 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

这两种事务管理器类型都不需要设置任何属性。它们其实是类型别名，换句话说，你可以用 TransactionFactory 接口实现类的全限定名或类型别名代替它们

尽管可以配置多个环境，但每个SqlSessionFactory实例只能选择-种环境。
学会使用配置多套运行环境!
Mybatis默认的事务管理器就是JDBC，连接池: POOLED

4.5、mappers（映射器）

既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要来定义 SQL 映射语句了。 但首先，我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面，Java 并没有提供一个很好的解决方案，所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 形式的 URL），或类名和包名等。例如：

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

<!-- 使用完全限定资源定位符（URL） -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>

<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

<!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

4.6、其他配置

• typeHandlers (类型处理器)
• objectFactory (对象工厂)
• plugins插件
  • mybatis-generator-core
  • mybatis-plus
  • 通用mappe

4.7、生命周期和作用域

生命周期，和作用域，是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder:

• 一旦创建了SqlSessionFactory, 就不再需要它了
• 局部变量

SqlSessionFactor

• 说白了就是可以想象为:数据库连接池
• SqlSessionFactory 一-旦被创建就应该在应用的运行期间一直存在,没有任何理由丢弃它或重新创建另一个实例。
• 因此SqISessionFactory的最佳作用域是应用作用域。
• 最简单的就是使用单例模式或者静态单例模式。

SqISession

• 连接到连接池的一个请求!
• SqISession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用** 域。
• 用完之后需要赶紧关闭，否则资源被占用

5、处理字段与属性名不一样的问题

---

实体类中的字段：id name password
数据库中的字段：id name pwd

执行查询语句

User{id=1, name='老大', password='null'}
User{id=2, name='李二', password='null'}
User{id=3, name='张三', password='null'}

会发现，字段名不一样，导致查询到的字段值为空

原始解决办法：select id,name,pwd as password from user

User{id=1, name='老大', password='123456'}
User{id=2, name='李二', password='123456'}
User{id=3, name='张三', password='123456'}

显示使用resultMap

<mapper namespace="com.zh.mapper.UserMapper">  
    <select id="getUserList" resultMap="resUser">  
        select * from user  
    </select>  
    <resultMap id="resUser" type="User">  
        <result column="id" property="id"/>  
        <result column="name" property="name"/>  
        <result column="pwd" property="password"/>  
    </resultMap>
</mapper>

结果

User{id=1, name='老大', password='123456'}
User{id=2, name='李二', password='123456'}
User{id=3, name='张三', password='123456'}

官方文档：

<!-- SQL 映射 XML 中 -->
<select id="selectUsers" resultType="User">
  select id, username, hashedPassword
  from some_table
  where id = #{id}
</select>

在这些情况下，MyBatis 会在幕后自动创建一个 ResultMap，再根据属性名来映射列到 JavaBean 的属性上。如果列名和属性名不能匹配上，可以在 SELECT 语句中设置列别名（这是一个基本的 SQL 特性）来完成匹配。比如：

<select id="selectUsers" resultType="User">
  select
    user_id             as "id",
    user_name           as "userName",
    hashed_password     as "hashedPassword"
  from some_table
  where id = #{id}
</select>

在学习了上面的知识后，你会发现上面的例子没有一个需要显式配置 ResultMap，这就是 ResultMap 的优秀之处——你完全可以不用显式地配置它们。 虽然上面的例子不用显式配置 ResultMap。 但为了讲解，我们来看看如果在刚刚的示例中，显式使用外部的 resultMap 会怎样，这也是解决列名不匹配的另外一种方式。

<resultMap id="userResultMap" type="User">
  <id property="id" column="user_id" />
  <result property="username" column="user_name"/>
  <result property="password" column="hashed_password"/>
</resultMap>

然后在引用它的语句中设置 resultMap 属性就行了（注意我们去掉了 resultType 属性）。比如:

<select id="selectUsers" resultMap="userResultMap">
  select user_id, user_name, hashed_password
  from some_table
  where id = #{id}
</select>

6、日志

---

6.1、日志工厂

1、标准日志工厂

<settings>  
    <setting name="logImpl" value="STDOUT_LOGGING"/>  
</settings>

Logging initialized using 'class org.apache.ibatis.logging.stdout.StdOutImpl' adapter.
PooledDataSource forcefully closed/removed all connections.
PooledDataSource forcefully closed/removed all connections.
PooledDataSource forcefully closed/removed all connections.
PooledDataSource forcefully closed/removed all connections.
Opening JDBC Connection
Created connection 359742806.
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@15713d56]
==>  Preparing: select * from user
==> Parameters: 
<==    Columns: id, name, pwd
<==        Row: 1, 老大, 123456
<==        Row: 2, 李二, 123456
<==        Row: 3, 张三, 123456
<==        Row: 5, 张三, 123321
<==        Row: 6, 哈哈哈哈, 123321
<==        Row: 7, 张三, 123321
<==      Total: 6
User{id=1, name='老大', password='123456'}
User{id=2, name='李二', password='123456'}
User{id=3, name='张三', password='123456'}
User{id=5, name='张三', password='123321'}
User{id=6, name='哈哈哈哈', password='123321'}
User{id=7, name='张三', password='123321'}
Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@15713d56]
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@15713d56]
Returned connection 359742806 to pool.

4.2 Log4j

什么是Log4j?

• Log4j是Apache的一一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、GUl组件
• 我们也可以控制每-条日志的输出格式;
• 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
• 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1、导入log4j包

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

2、配置文件

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码  
log4j.rootLogger=DEBUG,console,file  
  
#控制台输出的相关设置  
log4j.appender.console = org.apache.log4j.ConsoleAppender  
log4j.appender.console.Target = System.out  
log4j.appender.console.Threshold=DEBUG  
log4j.appender.console.layout = org.apache.log4j.PatternLayout  
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n  
  
#文件输出的相关设置  
log4j.appender.file = org.apache.log4j.RollingFileAppender  
log4j.appender.file.File=./log/logFile.log  
log4j.appender.file.MaxFileSize=10mb  
log4j.appender.file.Threshold=DEBUG  
log4j.appender.file.layout=org.apache.log4j.PatternLayout  
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n  
  
#日志输出级别  
log4j.logger.org.mybatis=DEBUG  
log4j.logger.java.sql=DEBUG  
log4j.logger.java.sql.Statement=DEBUG  
log4j.logger.java.sql.ResultSet=DEBUG  
log4j.logger.java.sql.PreparedStatement=DEBUG

3、代码中运用

private static Logger logger=Logger.getLogger(MapperTest.class);  
@Test  
public void test01(){  
    logger.debug("debug");  
    logger.info("info");  
    logger.warn("warn");  
    logger.error("error");  
}

文件中：
[DEBUG][22-08-19][com.zh.mapper.MapperTest]debug  
[INFO][22-08-19][com.zh.mapper.MapperTest]info  
[WARN][22-08-19][com.zh.mapper.MapperTest]warn  
[ERROR][22-08-19][com.zh.mapper.MapperTest]error

7、分页

---

1、SQL语句 limit

2、RowBounds

@Test  
public void Test01(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    List<User> userList = sqlSession.selectList("com.zh.mapper.UserMapper.getUserList", null, new RowBounds(0, 2));  
    for (User user : userList) {  
        System.out.println(user);  
    }  
    sqlSession.close();  
}

3、MyBatis 分页插件 PageHelper

8、使用注解开发

---

1、注解执行SQL

接口方法上注解

public interface UserMapper {  
    @Select("select * from user")  
    List<User> getUserList();  
}

全局配置文件中去配置mapper

<mappers>  
    <mapper class="zh.mapper.UserMapper"/>  
</mappers>

2、多参数SQL语句

多参数SQL语句会出现问题

@Select("select * from user where id=#{id} and name=#{name}")
List<User> getUserList(int id,String name);

@Test  
public void t(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);  
    Map map = new HashMap();  
    List<User> userList = mapper.getUserList(1,"老大");  
    for (User user : userList) {  
        System.out.println(user);  
    }  
    sqlSession.close();  
}

报错
Cause: org.apache.ibatis.binding.BindingException: Parameter 'id' not found. Available parameters are [arg1, arg0, param1, param2]

解决办法：

1、map传参
严格来说，map适用几乎所有场景，但是我们用得不多。原因有两个：首先，map是一个键值对应的集合，使用者要通过阅读它的键，才能明了其作用；其次，使用map不能限定其传递的数据类型，因此业务性质不强，可读性差，使用者要读懂代码才能知道需要传递什么参数给它，所以不推荐用这种方式传递多个参数。

@Select("select * from user where id=#{id} and name=#{name}")  
List<User> getUserList(Map<String,Object> map);

@Test  
public void t(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);  
    Map<String,Object> map = new HashMap();  
    map.put("id","1");  
    map.put("name","老大");  
    List<User> userList = mapper.getUserList(map);  
    for (User user : userList) {  
        System.out.println(user);  
    }  
    sqlSession.close();  
}

User{id=1, name='老大', password='null'}

2、使用注解传递多个参数
MyBatis为开发者提供了一个注解@Param（org.apache.ibatis.annotations.Param），可以通过它去定义映射器的参数名称，使用它可以得到更好的可读性　　这个时候需要修改映射文件的代码，此时并不需要给出parameterType属性，让MyBatis自动探索便可以了

@Select("select * from user where id=#{id} and name=#{name}")  
List<User> getUserList(@Param("id") int id,@Param("name") String name);

@Test  
public void t(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);  
    Map<String,Object> map = new HashMap();  
    List<User> userList = mapper.getUserList(1,"老大");  
    for (User user : userList) {  
        System.out.println(user);  
    }  
    sqlSession.close();  
}

Preparing: select * from user where id=? and name=?
==> Parameters: 1(Integer), 老大(String)
<==    Columns: id, name, pwd
<==        Row: 1, 老大, 123456

3、使用JavaBean传参
在 mapperx.xml 配置中知道参数类型即可，对象属性可以直接引用

9、多表查询

---

多对一本质上还是处理字段名和列名不一致的问题

9.1、多对一

9.1.1、通过子查询的方式

接口

//子查询  
List<Student> getStuList1();

mapper

<!--子查询-->  
<select id="getStuList1" resultMap="StudentTeacher01">  
    select * from student  
</select>  
<resultMap id="StudentTeacher01" type="Student">  
    <result property="id" column="id"/>  
    <result property="name" column="name"/>  
    <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"></association>  
</resultMap>  
<select id="getTeacher" resultType="Teacher">  
    select * from teacher where id=#{id}  
</select>

查询结果

Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@22f31dec]
==>  Preparing: select * from student
==> Parameters: 
<==    Columns: id, name, tid
<==        Row: 1, 张三, 1
====>  Preparing: select * from teacher where id=?
====> Parameters: 1(Integer)
<====    Columns: id, name
<====        Row: 1, 李老师
<====      Total: 1
<==        Row: 2, 李四, 1
<==        Row: 3, 王五, 2
====>  Preparing: select * from teacher where id=?
====> Parameters: 2(Integer)
<====    Columns: id, name
<====        Row: 2, 王老师
<====      Total: 1
<==      Total: 3
Student{id=1, name='张三', teacher=Teachar{id=1, name='李老师'}}
Student{id=2, name='李四', teacher=Teachar{id=1, name='李老师'}}
Student{id=3, name='王五', teacher=Teachar{id=2, name='王老师'}}

9.1.2、通过连表查询

接口

//联表查询  
List<Student> getStuList2();

mapper

<!--联表查询-->  
<select id="getStuList2" resultMap="StudentTeacher02">  
    select s.id as sid,s.name as sname,t.id as tid,t.name as tname from student as s join teacher t on t.id = s.tid  
</select>  
<resultMap id="StudentTeacher02" type="Student">  
    <result property="id" column="sid"/>  
    <result property="name" column="sname"/>  
    <association property="teacher" javaType="Teacher">  
        <result property="id" column="tid"/>  
        <result property="name" column="tname"/>  
    </association></resultMap>

查询结果

Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@22f31dec]
==>  Preparing: select s.id as sid,s.name as sname,t.id as tid,t.name as tname from student as s join teacher t on t.id = s.tid
==> Parameters: 
<==    Columns: sid, sname, tid, tname
<==        Row: 1, 张三, 1, 李老师
<==        Row: 2, 李四, 1, 李老师
<==        Row: 3, 王五, 2, 王老师
<==      Total: 3
Student{id=1, name='张三', teacher=Teachar{id=1, name='李老师'}}
Student{id=2, name='李四', teacher=Teachar{id=1, name='李老师'}}
Student{id=3, name='王五', teacher=Teachar{id=2, name='王老师'}}
Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@22f31dec]
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@22f31dec]
Returned connection 586358252 to pool.

9.2、一对多

9.2.1、子查询

接口

//子查询  
Teacher getTeacher2(@Param("tid") int id);

mapper

<select id="getTeacher2" resultMap="TeacherStudent02">  
    select * from teacher where id=#{tid}  
</select>  
  
<resultMap id="TeacherStudent02" type="Teacher">  
    <result property="id" column="id"/>  
    <result property="name" column="name"/>  
    <collection property="students" column="id" select="getStudents" ofType="Student">  
  
    </collection></resultMap>  
  
<select id="getStudents" resultType="Student">  
    select * from student where tid=#{id}  
</select>

结果

Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@76a2ddf3]
==>  Preparing: select * from teacher where id=?
==> Parameters: 1(Integer)
<==    Columns: id, name
<==        Row: 1, 李老师
====>  Preparing: select * from student where tid=?
====> Parameters: 1(Integer)
<====    Columns: id, name, tid
<====        Row: 1, 张三, 1
<====        Row: 2, 李四, 1
<====      Total: 2
<==      Total: 1
Teacher{id=1, name='李老师', students=[Student{id=1, name='张三', teacher=null}, Student{id=2, name='李四', teacher=null}]}
Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@76a2ddf3]

9.2.2、连接查询

接口

//查询一个老师的所有信息包括老师所有学生  
//连接查询  
Teacher getTeacher1(@Param("tid") int id);

mapper

<select id="getTeacher1" resultMap="TeacherStudent01">  
    select t.id as tid,t.name as tname,s.name as sname from teacher t join student s on t.id = s.tid where tid=#{tid}  
</select>  
  
<resultMap id="TeacherStudent01" type="Teacher">  
    <result property="id" column="tid"/>  
    <result property="name" column="tname"/>  
    <collection property="students" ofType="Student">  
        <result property="name" column="sname"/>  
    </collection></resultMap>

结果：

Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@76a2ddf3]
==>  Preparing: select t.id as tid,t.name as tname,s.name as sname from teacher t join student s on t.id = s.tid where tid=?
==> Parameters: 1(Integer)
<==    Columns: tid, tname, sname
<==        Row: 1, 李老师, 张三
<==        Row: 1, 李老师, 李四
<==      Total: 2
Teacher{id=1, name='李老师', students=[Student{id=0, name='张三', teacher=null}, Student{id=0, name='李四', teacher=null}]}
Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@76a2ddf3]

总结：

1.关联- association 多对一
2.集合- collection 一对多
3. javaType & ofType
1. JavaType用来指定实体类中属性的类型
2. ofType用来指定映射到List或者集合中的pojo类型，泛型中的约束类型!

注意点:

• 保证SQL的可读性，尽量保证通俗易懂
• 注意一对多和多对一-中,属性名和字段的问题!
• 如果问题不好排查错误，可以使用日志，建议使用Log4j
  面试高频
• Mysql 引擎
• InnoDB 底层原理
• 索引
• 索引优化

10、动态SQL

---

10.1、if

List<Blog> getBlogsIF(Map<String,Object> map);

<select id="getBlogsIF" resultType="Blog">  
    select * from Blog where 1=1  
<if test="title != null">  
    and title=#{title}  
</if>  
<if test="author != null">  
    and author=#{author}  
</if>  
</select>

@org.junit.Test  
public void T(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);  
    Map<String,Object> map = new HashMap<>();  
    //map.put("title","水浒传");  
    map.put("author","罗贯中");  
    List<Blog> blogs = mapper.getBlogsIF(map);  
    for (Blog blog : blogs) {  
        System.out.println(blog);  
    }  
    sqlSession.close();  
}

上例的where1=1在开发中不用，因为不安全
那么问题来了，去掉where1=1之后SQL语句会变成这样

<select id="getBlogsIF" resultType="Blog">  
    select * from Blog where
<if test="title != null">  
	title=#{title}  
</if>  
<if test="author != null">  
    and author=#{author}  
</if>  
</select>

存在一个问题，如果只查询第二个条件，SQL语句会拼接成：select * from Blog where and author=#{author}
这显然是错误的

10.2、 trim、where、set

where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

<select id="getBlogsIF" resultType="Blog">  
    select * from Blog  
    <where>  
        <if test="title != null">  
            title=#{title}  
        </if>  
        <if test="author != null">  
            and author=#{author}  
        </if>  
    </where>  
</select>

SqlSession sqlSession = MybatisUtil.getSqlSession();  
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);  
Map<String,Object> map = new HashMap<>();  
//map.put("title","水浒传");  
map.put("author","罗贯中");  
List<Blog> blogs = mapper.getBlogsIF(map);  
for (Blog blog : blogs) {  
    System.out.println(blog);  
}  
sqlSession.close();

Preparing: select * from Blog WHERE author=?
==> Parameters: 罗贯中(String)
<==    Columns: id, title, author, createTime, views
<==        Row: db33c88052974b58b26001467597133a, 三国演义, 罗贯中, 2022-08-04 18:55:31, 300
<==      Total: 1

set元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）

int updateBlog(Map<String,Object> map);


<update id="updateBlog" parameterType="map">  
    update blog  
    <set>  
        <if test="author != null">  
            author=#{author},  
        </if>  
        <if test="title != null">  
            title=#{title}  
        </if>  
    </set>  
    where id=#{id}  
</update>


@org.junit.Test  
public void T2(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);  
    Map<String,Object> map = new HashMap<>();  
    //map.put("title","水浒传");  
    map.put("author","罗贯中");  
    map.put("id","04f9dc6b550e4c7983ee77d66dd838f1");  
    int i = mapper.updateBlog(map);  
    sqlSession.close();  
}


Preparing: update blog SET author=? where id=?
==> Parameters: 罗贯中(String), 04f9dc6b550e4c7983ee77d66dd838f1(String)

可以看到，set标签自动加上了set关键字和去除了 author=#{author}, 的逗号以连接后面的where

Mybatis具有实现动态SQL的能力，但是在拼凑SQL语句的时候，稍有不注意则会画蛇添足，此时可以通过 trim 标签来进行修剪。trim 是“修剪”的意思，其基本格式如下：

<trim prefix="" suffix=""  prefixOverrides="" suffixOverrides="">

	......

</trim>

属性名	作用
prefix	给sql增加前缀
suffix	给sql增加后缀
prefixOverrides	去掉sql前面多余的关键字或者字符
suffixOverrides	去掉sql后面多余的关键字或者字符

where 元素等价的自定义 trim 元素为：

<trim prefix="WHERE" prefixOverrides="AND |OR ">
  ...
</trim>

来看看与 set 元素等价的自定义 trim 元素吧：

<trim prefix="SET" suffixOverrides=",">
  ...
</trim>

10.3、choose，when，otherwise

List<Blog> getBlogsChoose(Map<String,Object> map);


<select id="getBlogsChoose" resultType="Blog">  
    select * from blog  
    <where>  
        <choose>  
            <when test="title != null">  
                title=#{title}  
            </when>  
            <when test="author != null">  
                author=#{author}  
            </when>  
            <otherwise>  
  
            </otherwise>  
        </choose>  
    </where>  
</select>


@org.junit.Test  
public void T3(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);  
    Map<String,Object> map = new HashMap<>();  
    map.put("title","水浒传");  
    //map.put("author","罗贯中");  
    List<Blog> blogsChoose = mapper.getBlogsChoose(map);  
  
    sqlSession.close();  
}


Preparing: select * from blog WHERE title=?
==> Parameters: 水浒传(String)
<==    Columns: id, title, author, createTime, views
<==        Row: 04f9dc6b550e4c7983ee77d66dd838f1, 水浒传, 施耐庵, 2022-08-10 18:56:18, 10

choose 只选择一个条件

10.4、foreach

List<Blog> getBlogsForeach(@Param("titles") List<String> titleList);


<select id="getBlogsForeach" parameterType="arraylist" resultType="Blog">  
    select * from blog  
    <where>  
        <foreach collection="titles" open="(" close=")" item="title" separator=" or ">  
            title=#{title}  
        </foreach>  
    </where>  
</select>


@org.junit.Test  
public void T4(){  
    SqlSession sqlSession = MybatisUtil.getSqlSession();  
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);  
    List list = new ArrayList();  
    list.add("红楼梦");  
    list.add("西游记");  
    List blogsForeach = mapper.getBlogsForeach(list);  
    for (Object foreach : blogsForeach) {  
        System.out.println(foreach);  
    }  
    sqlSession.close();  
}


Preparing: select * from blog WHERE ( title=? or title=? )
==> Parameters: 红楼梦(String), 西游记(String)
<==    Columns: id, title, author, createTime, views
<==        Row: 3762dbf8b25847458e4417b5c9787b62, 红楼梦, 曹雪芹, 2022-07-30 18:54:57, 100
<==        Row: a064b30ced414ee78b1b1523c6342f88, 西游记, 吴承恩, 2022-08-11 18:54:27, 30
<==      Total: 2

11、缓存

11.1、简介

1.什么是缓存 Cache ?

• 存在内存中的临时数据。
• 将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。

2.为什么使用缓存?

• 减少和数据库的交互次数,减少系统开销，提高系统效率。

3.什么样的数据能使用缓存?

• 经常查询并且不经常改变的数据。

11.2、Mybatis缓存

• MyBatis包含-个非常强大的查询缓存特性,它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率
• MyBatis系统中默认定义了两级缓存: 一级缓存和二级缓存
  • 默认情况下，只有一级缓存开启。(SqlSession级别的缓存， 也称为本地缓存)
  • 二级缓存需要手动开启和配置， 他是基于namespace级别的缓存。
  • 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

11.3、测试一级缓存

一级缓存仅仅对一个会话中的数据进行缓存（即sqlsession打开和关闭期间）

map.put("title","水浒传");  
//map.put("author","罗贯中");  
List<Blog> blogsChoose1 = mapper.getBlogsChoose(map);  
List<Blog> blogsChoose2 = mapper.getBlogsChoose(map);  
  
System.out.println(blogsChoose1.hashCode());  
System.out.println(blogsChoose2.hashCode());  
sqlSession.close();


Created connection 962944318.
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@39655d3e]
==>  Preparing: select * from blog WHERE title=?
==> Parameters: 水浒传(String)
<==    Columns: id, title, author, createTime, views
<==        Row: 04f9dc6b550e4c7983ee77d66dd838f1, 水浒传, 施耐庵, 2022-08-10 18:56:18, 10
<==      Total: 1
264394960
264394960
Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@39655d3e]
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@39655d3e]
Returned connection 962944318 to pool.

可以通过日志看到，输出的hashcode一样，证明是同一个对象，并且只执行了一次SQL
改变参数看看：

Map<String,Object> map1 = new HashMap<>();  
map1.put("title","水浒传");  
List<Blog> blogsChoose1 = mapper.getBlogsChoose(map1);  
  
Map<String,Object> map2 = new HashMap<>();  
map2.put("title","西游记");  
List<Blog> blogsChoose2 = mapper.getBlogsChoose(map2);  
  
System.out.println(blogsChoose1.hashCode());  
System.out.println(blogsChoose2.hashCode());  
sqlSession.close();

Created connection 962944318.
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@39655d3e]
==>  Preparing: select * from blog WHERE title=?
==> Parameters: 水浒传(String)
<==    Columns: id, title, author, createTime, views
<==        Row: 04f9dc6b550e4c7983ee77d66dd838f1, 水浒传, 施耐庵, 2022-08-10 18:56:18, 10
<==      Total: 1
==>  Preparing: select * from blog WHERE title=?
==> Parameters: 西游记(String)
<==    Columns: id, title, author, createTime, views
<==        Row: a064b30ced414ee78b1b1523c6342f88, 西游记, 吴承恩, 2022-08-11 18:54:27, 30
<==      Total: 1
1878413745
769132178
Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@39655d3e]
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@39655d3e]
Returned connection 962944318 to pool.

执行了两次SQL语句，hashcode也不一样

对表的任何数据进行增删改都会导致清除缓存，即使是不相关的数据

小结: 一级缓存默认是开启的，只在一次SqISession中有效， 也就是拿到连接到关闭连接这个区间段!

11.4、二级缓存

• 二级缓存也叫全局缓存，- -级缓存作用域太低了，所以诞生了二级缓存
• 基于namespace级别的缓存，-个名称空间，对应一个二级缓存;
• 工作机制
  • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中;
  • 如果当前会话关闭了，这个会话对应的一级缓存就没了;但是我们想要的是，会话关闭了，一级缓存中的数据被保存到* 级缓存中;
  • 新的会话查询信息，就可以从二级缓存中获取内容;
  • 不同的mapper查出的数据会放在自己对应的缓存(map) 中

开启步骤
1、开启全局缓存

<!--  显示的开启全局缓存      -->  
<setting name="cacheEnabled" value="true"/>

2、在要使用二级缓存的mapper中开启

<!--在当前mapper配置中开启缓存-->  
<cache/>

基本上就是这样。这个简单语句的效果如下:

• 映射语句文件中的所有 select 语句的结果将会被缓存。
• 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
• 缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
• 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
• 缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
• 缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

提示 缓存只作用于 cache 标签所在的映射文件中的语句。如果你混合使用 Java API 和 XML 映射文件你需要使用 @CacheNamespaceRef 注解指定缓存作用域。

这些属性可以自定义修改：

<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

可用的清除策略有：

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

默认的清除策略是 LRU。

readOnly（只读）属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提升。
而可读写的缓存会（通过序列化）返回缓存对象的拷贝。 速度上会慢一些，但是更安全，因此默认值是 false。

提示 二级缓存是事务性的。这意味着，当 SqlSession 完成并提交时，或是完成并回滚，但没有执行 flushCache=true 的 insert/delete/update 语句时，缓存会获得更新。

3、测试

Map<String,Object> map = new HashMap<>();  
map.put("title","水浒传");  
  
SqlSession sqlSession1 = MybatisUtil.getSqlSession();  
BlogMapper mapper1 = sqlSession1.getMapper(BlogMapper.class);  
  
List<Blog> blogsChoose1 = mapper1.getBlogsChoose(map);  
System.out.println(blogsChoose1.hashCode());  
sqlSession1.close();  
  
System.out.println("====================================");  
  
SqlSession sqlSession2 = MybatisUtil.getSqlSession();  
BlogMapper mapper2 = sqlSession2.getMapper(BlogMapper.class);  
List<Blog> blogsChoose2 = mapper2.getBlogsChoose(map);  
System.out.println(blogsChoose2.hashCode());  
sqlSession2.close();



Opening JDBC Connection
Created connection 1444440224.
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@561868a0]
==>  Preparing: select * from blog WHERE title=?
==> Parameters: 水浒传(String)
<==    Columns: id, title, author, createTime, views
<==        Row: 04f9dc6b550e4c7983ee77d66dd838f1, 水浒传, 施耐庵, 2022-08-10 18:56:18, 10
<==      Total: 1
790094636
Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@561868a0]
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@561868a0]
Returned connection 1444440224 to pool.
====================================
Cache Hit Ratio [com.zh.dao.BlogMapper]: 0.5
790094636

11.5、自定义缓存

略