Mybatis使用详解(下)

shstart7

已于 2022-04-05 10:23:25 修改

阅读量205

点赞数 1

于 2021-05-29 20:20:57 首次发布

本文链接：https://blog.csdn.net/qq_46312987/article/details/117390521

版权

MySQL 同时被 2 个专栏收录

13 篇文章 7 订阅

订阅专栏

Mybatis

3 篇文章 0 订阅

订阅专栏

第四章-Mybatis缓存

1.概述

Mybatis包含一个非常强大的查询缓存特性，它可以非常方便的配置和定制，缓存可以极大的提升查询效率
Mybatis系统中默认定义了两级缓存 一级缓存和二级缓存
默认情况下只有一级缓存(SqlSession级别的缓存，也成为本地缓存)开启
二级缓存需要手动开启和配置，它是基于namespace级别的缓存
为了提高扩展性，Mybatis定义了缓存接口Cache，我们可以通过实现Cache接口来自定义二级缓存
先去查找二级缓存，然后在找一级缓存
缓存都实现了Cache接口，缓存的本质就是一个Map

2.一级缓存(基于session)

2.1概述

也叫本地缓存，以数据库的一次会话(session)期间查询到的数据会放在本地缓存中，以后如果需要获取相同的数据，直接从缓存中拿

一级缓存是一直开启的

2.2一级缓存体验

//实际上这行代码就将员工id为1的这条数据存入了缓存中
Employee emp1 = mapper.getEmpById(1);
System.out.println(empById);

//同一个Session 再次查找同一条数据，且中间没有对表的操作，从缓存中拿数据
Employee emp2 = mapper.getEmpById(1);
System.out.println(empById1); 

//打印true
System.out.println(emp1 == emp2);


//两次相同的查询，经过控制台的打印，发现只发送了一次SQL查询，并且发现 emp1和emp2是同一个对象
这就是Mybatis的一级缓存

2.3一级缓存失效的情况

session不同无法共享一级缓存
两次查询之间只要对表有任何的增删改操作第二次查询就会发新的SQL
手动清除一级缓存(session.clearCache())

3.二级缓存(基于当前Mapper文件)

3.1概述及工作原理

1、当一个session查出了数据时，这时Mybatis自动的就将这个数据放进了当前session的一级缓存中
2、只有当这个Session提交或者关闭时，这个Session中的一级缓存中的数据才会放进当前Mapper的二级缓存中。

3.2开启二级缓存配置

1、将我们的实体类实现Serializable接口

2、主配置文件

<settings>
    <!--只控制二级缓存-->
    <setting name="cacheEnabled" value="true"/>
</settings>

3、Mapper.xml文件配置

在哪个mapper文件里配置了cache标签，哪个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="dao.EmployeeMapper">
<cache 
    eviction="LRU"
    flushInterval="60000" 
    readOnly="false" 
    size="1024">
</cache>
</mapper>

属性详解：

eviction：缓存的回收策略

LRU(默认)：最近最少使用的，移除最长时间不被使用的对象
FIFO: 先进先出，按对象进入缓存的顺序来移除他们
SOFT：软引用
WEAK ：弱引用

flushInterval: 缓存的刷新间隔

即缓存多长时间清空一次，默认不清空，可以设置一个毫秒值进行清空

readOnly: 是否只读

true: 只读，Mybatis认为所有从缓存中获取数据的操作都是只读操作，不会修改数据，Mybatis为了加快获取数据的速度，直接将数据在缓存中的引用交给用户，不安全，但是速度快
false(默认)：非只读，Mybatis觉得获取的数据可能会被修改，使用序列化与反序列化的技术克隆一份新的数据给你，这就要求实体类必须实现序列化接口(Serializable),保证缓存的安全性，但是查询速度慢

size: 缓存存放多少元素

type：指定自定义缓存的全类名

3.3测试二级缓存

 EmployeeMapper mapper1 = session1.getMapper(EmployeeMapper.class);
 EmployeeMapper mapper2 = session2.getMapper(EmployeeMapper.class);
	

//将数据放入sqlSession1的一级缓存中
 Employee empById1 = mapper1.getEmpById(1);


//关闭session1或者提交，将数据放入二级缓存中
----注意 如果session1不提交或者不关闭 那么一级缓存中的数据是不会放入二级缓存中的---------
  session1.close();
// sqlSession1.commit();

 //session2也查询这条数据 从二级缓存中拿
Employee empById2 = mapper2.getEmpById(1);

//true
System.out.println(empById2 == empById1);

4.与缓存有关的配置

1、在主配置文件中的设置只能关闭二级缓存

表示关闭二级缓存

<settings>
    <!--只控制二级缓存-->
    <setting name="cacheEnabled" value="true"/>
</settings>

2、每个select标签的useCache属性

表示此次查询是否可以使用缓存(不管缓存中是否有数据)

true表示本次查询可以使用缓存(一二级都可以)

false表示本次查询不使用二级缓存，可以使用一级缓存

<select id="getEmpByConditionIF" resultMap="rem" useCache="true">

3、每个增删改查标签的flushCache属性

为true时增删改查操作后会将缓存中的数据清空，一二级缓存的数据都会被清空，
为false时增删改查操作后不会删除缓存中的数据

增删改此属性默认为true,查询时false 所以每次进行增删改操作时缓存中的数据就被清空了

4、调用session的clearCache()方法

session.clearCache() 只能清除当前session的一级缓存

5、localCacheScope本地缓存作用域

可以关闭一级缓存

默认是SESSION，即一级缓存数据都保存在当前SESSION中。

设置为STATEMENT时可以禁用一级缓存

5.缓存的工作原理(图解)

在这里插入图片描述

6.整合第三方缓存

Mybatis规定了Cache接口，所有缓存都必须实现此接口 我们就可以实现此接口，然后重写方法自定义缓存，并且可以整合第三方缓存！！！

package org.apache.ibatis.cache;

import java.util.concurrent.locks.ReadWriteLock;

public interface Cache {
    String getId();

    void putObject(Object var1, Object var2);

    Object getObject(Object var1);

    Object removeObject(Object var1);

    void clear();

    int getSize();

    ReadWriteLock getReadWriteLock();
}

整合EhCache

参考

在这里插入图片描述

第五章-Mybatis运行原理

四大对象

Executor

增删改查执行器

StatementHandler

获取连接处理SQL语句的预编译以及设置预编译参数等功能

ParameterHandler

StatementHanler设置预编译参数时，借助ParameterHandler，使用的是TypeHandler真正设置预编译参数

typeHandler.setParameter()

ResultSetHandler

处理查询出的结果，使用的是TypeHandler真正的处理和封装结果

typeHandler.getResult()

TypeHandler

在整个过程中，进行数据库类型和javaBean类型的映射，处理预编译参数和封装结果

5.1获取SqlSessionFactory对象

SqlSessionFactory是一个接口，最终返回的是接口的实现类对象DefaultSqlSessionFactory

将所有的配置文件信息全部解析，保存在Configuration对象中，返回包含了Configuration对象的DefaultSqlSessionFactory对象中

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

几个Configuration中重要的对象

MapperStatement：一个MapperStatement表示一个增删改查标签的所有信息

5.2获取SqlSession对象

创建并返回了一个DefaultSqlSession对象，包含了新创建的Executor对象和上一步的Configuration对象

SqlSession也是一个接口，返回的是DefaultSqlSession(实现了SqlSession接口)对象，包含了上一步的Configuration对象和包装的Executor对象

SqlSession sqlSession = sqlSessionFactory.openSession();

Sqlsession中常用的方法

void commit();  //提交事务

void rollback();  //回滚
 
void close();    //关闭session

void clearCache();  //清除一级缓存
 
<T> T getMapper(Class<T> var1); //获取对应Mapper接口的代理实现类对象

5.3获取接口的代理对象(MapperProxy)

最终返回了一个Mapper接口的代理对象(JDK动态代理)包含了我们的sqlSession对象

EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);

5.4执行增删改查方法

1、先执行代理对象的invoke方法，判断当前方法是否是Object类的方法，

2、将我们的当前方法method包装成一个MapperMethod，调用MapperMethod的execute方法，传入sqlSession和方法的参数，

3、判断这些方法的类型(增删改查) ，并将我们传入的参数进行转换(参数处理见第三章参数处理过程) ，

4、调用sqlSession中的增删改查方法，传入Statement(sql语句对象)和parameter(处理后的参数)

5、通过Configuration对象获取MapperStatement对象，并使用execute执行增删改查方法，出入这个MapperStatement对象和参数等，

6、通过MapperStatement获取一个BoundSql对象，这个BoundSql对象表示增删改查标签的所有信息(包括SQL语句),(如果是查询方法，先去缓存中查，先二级后一级)

7、最终调用的是SimpleExccutor/Reuse…进行执行方法，如果是查询，查询后将数据放在一级缓存中，

8、创建了一个StatementHandler（这个过程也创建了ParamterHandler和ResultSetHandler），可以创建出Statement对象(整个过程就是获取一个连接，然后预编译sqL,通过连接获取一个Statement对象)，默认获取的是PreparedStatement对象，再次使用插件拦截器链对PreparedStatement进行包装,然后通过ParamterHandler填充预编译参数、(调用TypeHandler设置预编译参数)

9、查询数据后，使用ResultSetHandler处理结果(封装对象),调用的是TypeHandler的getResult方法

5.5运行流程总结

参考

1、读取主配置文件以及所有的Mapper文件初始化Configuration对象，将这个Configuration放到new出来的DefaultSqlSessionFactory中，

2、通过SqlSessionFactory开启一个SqlSession，里面包含了Configuration以及Executor，（根据主配置文件中的defaultExecutorType创建出对应的Executor）

3、通过调用SqlSession的getMapper()方法，拿到Mapper接口对应的MapperProxy(就是一个InvocationHanler)，MapperProxy里面有当前sqlSession,然后通过动态代理生成一个接口的实现类对象。

4、执行增删改查方法时，调用的是代理类里面的sqlSession里面的增删改查，本质还是Executor的增删改查，最终会创建一个StatementHandler对象，同时也会创建出ParameterHandler和ResultSetHanler

5、调用StatementHandler获取连接预编译SQL以及设置预编译参数值(ParameterHandler设置参数值)，然后执行StatementHandler的增删改查方法，使用ResultSetHanler封装结果 (设置参数以及封装返回结果时都会用到TypeHandler)
在这里插入图片描述

第六章-Mybatis插件

6.1概述

在四大对象创建的时候，不是直接返回，都会调用 interceptorChain.pluginAll(XxxHandler);

获取所有的Interceptor,（插件需要实现的接口),调用interceptor.plugin(target)返回target包装后的对象，
本质上，使用的就是JDK的动态代理，在执行时为其产生一个动态代理对象，然后配置切入点（拦截的方法）以及额外功能。然后在执行原始方法时，实际上执行的是代理对象的方法

插件开发可以拦截的对象及方法
在这里插入图片描述

6.2编写插件

1、实现Interceptor接口，重写方法


//配置拦截的对象以及对象的方法
@Intercepts({@Signature(type = StatementHandler.class,method = "parameterize",args = java.sql.Statement.class)})
public class MyFirstPlugin implements Interceptor {

    /*
    *       额外功能
    * */
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("----额外功能");
        Object result = invocation.proceed();
        return result;
    }

    /*
    * 为这个对象产生一个动态代理的对象
    * */
    @Override
    public Object plugin(Object o) {
        System.out.println("原始对象" + o.getClass());
        //使用Plugin快速的为原始对象生成一个代理对象，底层就是JDK的动态代理
        Object wrap = Plugin.wrap(o, this);
        return wrap;
    }
	
     /*
    * 可以获取在主配置文件里配置的插件信息
    * */
    @Override
    public void setProperties(Properties properties) {
        Object p1 = properties.get("p1");
        System.out.println(p1);
    }
}

2、在主配置文件里注册插件

<plugins>
    <plugin interceptor="dao.MyFirstPlugin">
        <!--自定义一些配置 运行时可以读取到-->
        <property name="p1" value="v1"/>
    </plugin>
</plugins>

6.3多个插件的运行流程

如果有多个插件同时拦截同一个对象的同一个方法，那么要看在主配置文件里插件的配置顺序，按照注册的顺序依次为其生产代理对象，主要是操作同一个对象，即第一个插件生成了一个代理对象，然后第二个插件操作的是第一个插件生产后的代理对象。
在执行目标方法时，后注册的插件先执行方法，因为是最外层。

在这里插入图片描述

6.4PageHelper分页插件的使用

1、导入依赖

<dependency>
     <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
  <version>4.2.0</version>
</dependency>

2、在主配置文件中注册

   <plugins> 
        <plugin interceptor="com.github.pagehelper.PageHelper"></plugin>
    </plugins>

3、使用

简单的用法

 @Test
    public void 分页测试() throws IOException {
 		
        //通过startPage方法传入信息 每次在查询时都会拦截请求 必须在查询方法前调用
        Page<Object> page = PageHelper.startPage(pageNum(显示第几页的数据),
                                                 pageSize(每页显示几条记录);
        
        //查询数据
        List<Employee> emps = mapper.getEmps();
        emps.forEach(System.out::println);
        
        //必须在查询方法被拦截后才能获取正确的数据
                                                
        page.getPageNum()   //当前页数
        page.getTotal()     //结果集的总记录数
        page.getPages()     //总页数
        page.getPageSize()  //每页的记录数
        page.getStartRow()  //当前页的第一条数据是结果集的第几条数据(索引从0开始) 
                                                  
    //(逻辑上)当前页的第最后一条数据是结果集的第几条数据(索引从0开始) 
    //就是单纯使用pageNum*pageSize计算出来的，可能最后一页的数据没有填满，
        page.getEndRow()   
            
        
    }

更加强大的用法

@Test
public void 分页测试() throws IOException {
 		
    
    //分页拦截 显示第5页数据 一页显示1条
    Page<Object> page = PageHelper.startPage(5, 1);
	
    //查询
    List<Employee> emps = mapper.getEmps();
    emps.forEach(System.out::println);

	
    //构造一个PageInfo对象  第一个是空参的，第二个构造器带了一个参数
    //就是连续的显示的页码 这里设置为4 即连续显示4页的页码数(用作页码导航条)
    PageInfo<Employee> pageInfo = new PageInfo<>(emps);
    PageInfo<Employee> pageInfo = new PageInfo<>(emps,5);
   
    System.out.println(pageInfo.isIsFirstPage());      //是否是第一页
    System.out.println(pageInfo.isHasNextPage());      //是否有下一页
    System.out.println(pageInfo.getNextPage());        //获取下一页的页码
    System.out.println(pageInfo.isHasPreviousPage());  //是否有上一页
    System.out.println(pageInfo.getPageNum());         //获取当前页码数
    System.out.println(pageInfo.getTotal());           //获取总记录数
    System.out.println(pageInfo.getPages());           //获取总页数
    System.out.println(pageInfo.getPageSize());        //获取一页的记录数     
    //获取连续的页码数  我们上面设置为5
    // 上面我们设置了一页显示1条数据，如果现在我想要第5页的数据，一共有8页(8条数据)
    //那么连续显示的页码数 就是  3 4 5 6 7 
    int[] navigatepageNums = pageInfo.getNavigatepageNums();
    for (int i : navigatepageNums) {
        System.out.println(i);
    }

}

       //获取当前页码数
    System.out.println(pageInfo.getTotal());           //获取总记录数
    System.out.println(pageInfo.getPages());           //获取总页数
    System.out.println(pageInfo.getPageSize());        //获取一页的记录数
    ...
        
    //获取连续的页码数  我们上面设置为5
    // 上面我们设置了一页显示1条数据，如果现在我想要第5页的数据，一共有8页(8条数据)
    //那么连续显示的页码数 就是  3 4 5 6 7 
    int[] navigatepageNums = pageInfo.getNavigatepageNums();
    for (int i : navigatepageNums) {
        System.out.println(i);
    }