我的架构梦：（二）MyBatis的一级、二级、分布式缓存的应用以及源码分析

今天药忘吃喽~ 2023-02-12 11:24 8阅读 0赞

### mybatis的一级、二级、分布式缓存的应用以及源码分析 ###

*   *  一、mybatis缓存
     *  二、一级缓存
     *  三、一级缓存源码分析
     *  四、二级缓存
     *  五、二级缓存整合redis
     *  六、二级缓存整合redis源码分析

## 一、mybatis缓存 ##

缓存就是内存中的数据，常常来自对数据库查询结果的保存。使用缓存，我们可以避免频繁与数据库进行交互，从而提高响应速度。

`mybatis` 也提供了对缓存的支持，分为一级缓存和二级缓存，来看下下面这张图：

![在这里插入图片描述][20200525230302101.png]

1、**一级缓存**是`SqlSession`级别的缓存。在操作数据库时需要构造`SqlSession`对象，在对象中有一个数据结构（`HashMap`）用于存储缓存数据。不同的是`SqlSession`之间的缓存数据区（`HashMap`）是互相不影响。

2、**二级缓存** 是`Mapper`级别的缓存，多个`SqlSession`去操作同一个`Mapper`的`sql`语句，多个`SqlSession`可以共用二级缓存，二级缓存是`SqlSession`跨的。

## 二、一级缓存 ##

**1、我们在一个`SqlSession`中，对`User`表根据`id`进行**两次**查询，查看它们发出`sql`语句的情况。**

一级缓存默认是开启的，现在我们来验证下：

我们先把一些通用的操作先用`@Before`来操作下面各个测试方法之前要运行的方法。

private OrderMapper orderMapper;
    
    private SqlSession sqlSession;
    
    private SqlSessionFactory sqlSessionFactory;
    
    @Before
    public void before() throws IOException { 
        InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        sqlSession = sqlSessionFactory.openSession(true);
        userMapper = sqlSession.getMapper(UserMapper.class);
        orderMapper = sqlSession.getMapper(OrderMapper.class);
    }

@Test
    public void firstLevelCache() { 
        // 第一次查询id为1的用户
        User user1 = userMapper.findUserById(1);
    
        // 第二次查询id为1的用户
        User user2 = userMapper.findUserById(1);
    
        System.out.println(user1 == user2);
    }

控制台日志输出：

![在这里插入图片描述][20200525234248535.png]

**2、我们继续对`User`表进行两次查询，只不过两次查询之间加入一次`update`操作。**

@Test
    public void firstLevelCacheOfUpdate() { 
        // 第一次查询id为1的用户
        User user1 = userMapper.findUserById(1);
    
        // 更新用户
        User user = new User();
        user.setId(3);
        user.setUsername("tom");
    
        userMapper.updateUser(user);
        sqlSession.commit(); // 刷新一级缓存
        // sqlSession.clearCache(); 这个也可以刷新一级缓存
    
        // 第二次查询id为1的用户
        User user2 = userMapper.findUserById(1);
    
        System.out.println(user1 == user2);
    }

控制台日志输出：

![在这里插入图片描述][20200525235106561.png]

**3、小结**

*  第一次发起查询用户id为1的用户信息，先去缓存中找是否有id为1的用户信息，如果没有，从数据库查询用户信息。得到用户信息，将用户信息存储到一级缓存中。
 *  如果中间sqlSession去执行commit操作(执行插入、更新、删除)，则会清空sqlSession中的一级缓存，这样做的目的为了让缓存存储最新的信息，避免脏读。
 *  第二次查询id为1的用户信息，先去缓存中找是否有id为1的用户信息，缓存中有，直接从缓存中获取用户信息。

## 三、一级缓存源码分析 ##

**1、一级缓存的工作流程**

调研了一下，画出工作流程图：

![在这里插入图片描述][20200526000227841.png]

跟踪到`PerpetualCache`中的`clear()`方法。

...
    private Map<Object, Object> cache = new HashMap();
    
    public void clear() { 
        this.cache.clear();
    }
    ...

也就是说一级缓存的底层数据结构就是 `HashMap`。所以说`cache.clear()`其实就是`map.clear()`,也就是说，缓存其实是本地存放的一个map对象，每一个`SqlSession`都会存放一个map对象的引用。

那么这个`cache`是何时创建的呢?

你觉得最有可能创建缓存的地方是哪？我觉得是`Executor`,为啥这么认为？因为`Executor`是执行器，用来执行sql请求，而且清除缓存的方法也在`Executor`中执行，去查看源码，果真在里面。

public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) { 
       if (this.closed) { 
            throw new ExecutorException("Executor was closed.");
        } else { 
            CacheKey cacheKey = new CacheKey();
            // MappedStatement的id
            // id 就是sql语句的所在位置 包名+类名+sql名称
            cacheKey.update(ms.getId());
            // offset 就是0
            cacheKey.update(rowBounds.getOffset());
             // limit 就是Integer.MAX_VALUE
            cacheKey.update(rowBounds.getLimit());
            // 具体的sql语句
            cacheKey.update(boundSql.getSql());
            List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
            TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
            Iterator var8 = parameterMappings.iterator();
    
            while(var8.hasNext()) { 
                ParameterMapping parameterMapping = (ParameterMapping)var8.next();
                if (parameterMapping.getMode() != ParameterMode.OUT) { 
                    String propertyName = parameterMapping.getProperty();
                    Object value;
                    if (boundSql.hasAdditionalParameter(propertyName)) { 
                        value = boundSql.getAdditionalParameter(propertyName);
                    } else if (parameterObject == null) { 
                        value = null;
                    } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) { 
                        value = parameterObject;
                    } else { 
                        MetaObject metaObject = this.configuration.newMetaObject(parameterObject);
                        value = metaObject.getValue(propertyName);
                    }
    				// sql中带的参数
                    cacheKey.update(value);
                }
            }
    
            if (this.configuration.getEnvironment() != null) { 
                cacheKey.update(this.configuration.getEnvironment().getId());
            }
    
            return cacheKey;
        }
    }

创建缓存`key`会经过一系列的`update`方法，`update`方法由一个`cacheKey` 这个对象来执行的。这个`update`方法最终由`updateList`的`list`来把六个值存进去，对照上面的代码，你应该能理解下面六个值分别是啥了吧。

![在这里插入图片描述][20200526002450126.png]

这里需要关注最后一个值`this.configuration.getEnvironment().getId()`，这其实就是定义在`mybatis-config.xml`中的标签。如下：

![在这里插入图片描述][20200526002819728.png]

那么问题来了。创建缓存了，那具体在哪里用呢？我们一级缓存探究后，我们发现一级缓存更多的用于`查询操作`，比较一级缓存也叫查询缓存嘛。我们跟踪到`query`方法：

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { 
        BoundSql boundSql = ms.getBoundSql(parameter);
        // 创建缓存
        CacheKey key = this.createCacheKey(ms, parameter, rowBounds, boundSql);
        return this.query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }
    
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { 
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        if (this.closed) { 
            throw new ExecutorException("Executor was closed.");
        } else { 
            if (this.queryStack == 0 && ms.isFlushCacheRequired()) { 
                this.clearLocalCache();
            }
    
            List list;
            try { 
                ++this.queryStack;
                // resultHandler为null的话，走的this.localCache.getObject(key)缓存
                list = resultHandler == null ? (List)this.localCache.getObject(key) : null;
                if (list != null) { 
                	// 主要处理存储过程用的
                    this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
                } else { 
                	// 为null的话则从数据库中查
                    list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
                }
            } finally { 
                --this.queryStack;
            }
    
            if (this.queryStack == 0) { 
                Iterator var8 = this.deferredLoads.iterator();
    
                while(var8.hasNext()) { 
                    BaseExecutor.DeferredLoad deferredLoad = (BaseExecutor.DeferredLoad)var8.next();
                    deferredLoad.load();
                }
    
                this.deferredLoads.clear();
                if (this.configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) { 
                    this.clearLocalCache();
                }
            }
    
            return list;
        }
    }

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { 
        this.localCache.putObject(key, ExecutionPlaceholder.EXECUTION_PLACEHOLDER);
    
        List list;
        try { 
            list = this.doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally { 
            this.localCache.removeObject(key);
        }
    
        this.localCache.putObject(key, list);
        if (ms.getStatementType() == StatementType.CALLABLE) { 
            this.localOutputParameterCache.putObject(key, parameter);
        }
    
        return list;
    }

如果查不到话，就从数据库查，在`queryFromDatabase`中，会对`localCache`进行写入。

`localCache`对象的`put`方法最终交给`map`进行存放。

private Map<Object, Object> cache = new HashMap();
    
    public void putObject(Object key, Object value) { 
        this.cache.put(key, value);
    }

ok了，一级缓存的应用与源码分析就先到这，我们下面来介绍二级缓存。

## 四、二级缓存 ##

二级缓存的原理与一级缓存一样，底层数据结构也是`HashMap`,不同的是，一级缓存是基于`SqlSession`的；而二级缓存是基于`mapper`文件的`namespace`的，也就是说多个`SqlSession`可以共享一个`mapper`中的二级缓存区域，这里注意如果要用二级缓存的话需要把一级缓存关闭，这样才会走二级缓存。`mybatis`是默认关闭二级缓存的，因为对于增删改操作频繁的话，那么二级缓存形同虚设，每次都会被清空缓存。

二级缓存结构图如下：  
![在这里插入图片描述][20200526193641616.png]  
**1、如何开启二级缓存**

*  开启二级缓存
    
    和一级缓存默认开启不一样，二级缓存需要我们手动开启。  
    (1)、首先在全局配置文件`SqlMapConfig.xml`文件中加入如下代码：
    
        
        <settings>
            <setting name="cacheEnabled" value="true"/>
        </settings>
    
    (2)、其次在`UserMapper.xml`文件中开启二级缓存
    
    mapper代理模式：
    
        
        <cache></cache>
    
    注解开发模式：
    
        @CacheNamespace(implementation = PerpetualCache.class) // 开启二级缓存
        public interface UserMapper { 
        }
    
    `mapper`代理模式开启的二级缓存是一个空标签，其实这里可以配置，`PerpetualCache`这个类是`mybatis`默认实现的二级缓存功能的类，我们不写`type`就使用`mybatis`默认的二级缓存，也可以去实现`Cache`接口来自定义缓存。下面注解的也是一样的道理，用`@CacheNamespace` 也是直接默认`PerpetualCache`这个类。
    
    ![在这里插入图片描述][2020052620294165.png]
 *  实体类实现`Serializable`序列化接口
    
    ![在这里插入图片描述][20200526203104716.png]  
    开启二级缓存后，还需要将要缓存的实体类去实现`Serializable`序列化接口，为了将缓存数据取出执行反序列化操作，因为二级缓存数据存储介质多种多样，不一定只存在内存中，有可能存在硬盘中，如果我们再取出这个缓存的话，就需要反序列化。所以`mybatis`的所有`pojo`类都要去实现`Serializable`序列化接口。

**2、测试二级缓存**

**(1)、测试二级缓存和与`SqlSession`无关**

@Test
    	public void secondLevelCache() { 
        SqlSession sqlSession1 = sqlSessionFactory.openSession();
        SqlSession sqlSession2 = sqlSessionFactory.openSession();
    
        UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
        UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
    
        // 第一次查询id为1的用户
        User user1 = userMapper1.findUserById(1);
        sqlSession1.close(); // 清空一级缓存
    
        // 第二次查询id为1的用户
        User user2 = userMapper2.findUserById(1);
        sqlSession2.close();
    
        System.out.println(user1 == user2);
    }

第一次查询时，将查询结果放入缓存中，第二次查询，即使`sqlSession1.close();` 清空了一级缓存，第二次查询依然不发出`sql`语句。

**(2)、测试执行`commit()`，二级缓存数据清空**

@Test
    public void secondLevelCacheOfUpdate() { 
        SqlSession sqlSession1 = sqlSessionFactory.openSession();
        SqlSession sqlSession2 = sqlSessionFactory.openSession();
        SqlSession sqlSession3 = sqlSessionFactory.openSession();
    
        UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
        UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
        UserMapper userMapper3 = sqlSession3.getMapper(UserMapper.class);
    
        // 第一次查询id为1的用户
        User user1 = userMapper1.findUserById(1);
        sqlSession1.close(); // 清空一级缓存
    
        User user = new User();
        user.setId(3);
        user.setUsername("edgar");
        userMapper3.updateUser(user);
        sqlSession3.commit();
    
        // 第二次查询id为1的用户
        User user2 = userMapper2.findUserById(1);
        sqlSession2.close();
    
        System.out.println(user1 == user2);
    }

![在这里插入图片描述][20200526205035498.png]

**3、`useCache` 和 `flushCache`**

`useCache` 是用来设置是否禁用二级缓存的，在`statement`中设置`useCache="false"`，可以禁用当前`select`语句的二级缓存，即每次都会去数据库查询。如下：

<select id="findAll" resultMap="userMap" useCache="false">
        select * from user u left join orders o on u.id = o.uid
    </select>

设置statement配置中的flushCache=“true”属性，默认情况下为true，即刷新缓存，一般执行完commit操作都需要刷新缓存，flushCache=“true”表示刷新缓存，这样可以避免增删改操作而导致的脏读问题。默认不要配置，如下：

<select id="findAll" resultMap="userMap" useCache="false" flushCache="true">
        select * from user u left join orders o on u.id = o.uid
    </select>

## 五、二级缓存整合redis ##

上面我们介绍了mybatis自带的二级缓存，但这个缓存是单服务工作，无法实现分布式缓存。那什么是分布式缓存呢？假如我们系统部署在两台服务器1和2上，用户访问服务器1，将查询后的缓存放在服务器1上，加入另一个用户访问服务器2，那它就在服务器2上无法获取刚刚那个缓存。如下图所示：

![在这里插入图片描述][20200526211100837.png]

为了解决这个问题，分布式缓存就应运而生了，这样不同的服务器要缓存数据都往它那存，取缓存也从它那取。如下图所示：

![在这里插入图片描述][2020052621125168.png]

如上图所示，我们使用第三方缓存框架，将缓存存放在这个第三方框架中，无论多少台服务器，我们都从分布式缓存中获取数据。

--------------------

这里我们来介绍`mybatis`与`redis`整合

**1、pom文件**

<dependency>
        <groupId>org.mybatis.caches</groupId>
        <artifactId>mybatis-redis</artifactId>
        <version>1.0.0-beta2</version>
    </dependency>

**2、配置文件**

`UserMapper.xml`中加入：

<cache type="org.mybatis.caches.redis.RedisCache" />

**3、redis.properties**

redis.host=localhost
    redis.port=6379
    redis.connectionTimeout=5000
    redis.password=
    redis.database=0

**4、测试**

## 六、二级缓存整合redis源码分析 ##

`RedisCache`和大家普遍实现的`mybatis`的缓存方案大同小异，无非就是实现`Cache`接口，并使用`jedis`操作缓存；不过该项目在设计细节有一些区别。

public final class RedisCache implements Cache { 
        private final ReadWriteLock readWriteLock = new DummyReadWriteLock();
        private String id;
        private static JedisPool pool;
    
        public RedisCache(String id) { 
            if (id == null) { 
                throw new IllegalArgumentException("Cache instances require an ID");
            } else { 
                this.id = id;
                RedisConfig redisConfig = RedisConfigurationBuilder.getInstance().parseConfiguration();
                pool = new JedisPool(redisConfig, redisConfig.getHost(), redisConfig.getPort(), redisConfig.getConnectionTimeout(), redisConfig.getSoTimeout(), redisConfig.getPassword(), redisConfig.getDatabase(), redisConfig.getClientName());
            }
        }
        ...
    }

`RedisCache`在`mybatis`启动的时候，由`MyBatis`的`CacheBuilder`创建，创建的方式很简单，就是调用`RedisCache`的带有`String`参数的构造方法，即`RedisCache(String id)`；

而在`RedisCache`构造方法中，调用`RedisConfigurationBuilder`来创建`RedisConfig`对象，并使用`RedisConfig`来创建`JedisPool`。

`RedisConfig`提供了`host、port`等属性的包装。

public class RedisConfig extends JedisPoolConfig { 
        private String host = "localhost";
        private int port = 6379;
        private int connectionTimeout = 2000;
        private int soTimeout = 2000;
        private String password;
        private int database = 0;
        private String clientName;
        ...
    }

`RedisConfig`是由`RedisConfigurationBuilder`创建的，我们主要来看下核心方法`parseConfiguration`，该方法从`classpath`中读取一个`redis.properties`文件：

redis.host=localhost
    redis.port=6379
    redis.connectionTimeout=5000
    redis.password=
    redis.database=0

final class RedisConfigurationBuilder { 
        private static final RedisConfigurationBuilder INSTANCE = new RedisConfigurationBuilder();
        private static final String SYSTEM_PROPERTY_REDIS_PROPERTIES_FILENAME = "redis.properties.filename";
        private static final String REDIS_RESOURCE = "redis.properties";
        private final String redisPropertiesFilename = System.getProperty("redis.properties.filename", "redis.properties");
    
        private RedisConfigurationBuilder() { 
        }
    
        public static RedisConfigurationBuilder getInstance() { 
            return INSTANCE;
        }
    
        public RedisConfig parseConfiguration() { 
            return this.parseConfiguration(this.getClass().getClassLoader());
        }
    
        public RedisConfig parseConfiguration(ClassLoader classLoader) { 
            Properties config = new Properties();
            InputStream input = classLoader.getResourceAsStream(this.redisPropertiesFilename);
            if (input != null) { 
                try { 
                    config.load(input);
                } catch (IOException var12) { 
                    throw new RuntimeException("An error occurred while reading classpath property '" + this.redisPropertiesFilename + "', see nested exceptions", var12);
                } finally { 
                    try { 
                        input.close();
                    } catch (IOException var11) { 
                    }
    
                }
            }
    
            RedisConfig jedisConfig = new RedisConfig();
            this.setConfigProperties(config, jedisConfig);
            return jedisConfig;
        }
        ...
    }

并将该配置文件中的内容设置到`RedisConfig`对象中，并返回；接下来，就是`RedisCache`使用`RedisConfig`类创建完成`JedisPool`；在`RedisCache`中实现了一个简单的模板方法，用来操作`Redis`:

private Object execute(RedisCallback callback) { 
        Jedis jedis = pool.getResource();
    
        Object var3;
        try { 
            var3 = callback.doWithRedis(jedis);
        } finally { 
            jedis.close();
        }
    
        return var3;
    }

模板接口`RedisCallback`，这个接口只需要实现一个`doWithRedis`方法：

public interface RedisCallback { 
        Object doWithRedis(Jedis var1);
    }

接下来看`RedisCache`最重要的两个方法`putObject`和`getObject`

public void putObject(final Object key, final Object value) { 
        this.execute(new RedisCallback() { 
            public Object doWithRedis(Jedis jedis) { 
                jedis.hset(RedisCache.this.id.toString().getBytes(), key.toString().getBytes(), SerializeUtil.serialize(value));
                return null;
            }
        });
    }
    
    public Object getObject(final Object key) { 
        return this.execute(new RedisCallback() { 
            public Object doWithRedis(Jedis jedis) { 
                return SerializeUtil.unserialize(jedis.hget(RedisCache.this.id.toString().getBytes(), key.toString().getBytes()));
            }
        });
    }

不难发现，`mybatis-redis`在存储数据的时候，使用的是`hash`结构，把`cache`的`id`作为这个`hash`的`key`(`cache`的`id`在`mybatis`中就是`mapper`的`namespace`)；这个`mapper`中的查询缓存数据作为`hash`的`field`，需要缓存的内容直接使用`SerializeUtil`存储，`SerializeUtil`和其他序列化工具类差不多，负责将对象序列化和反序列化。

[20200525230302101.png]: https://img-blog.csdnimg.cn/20200525230302101.png
[20200525234248535.png]: https://img-blog.csdnimg.cn/20200525234248535.png
[20200525235106561.png]: https://img-blog.csdnimg.cn/20200525235106561.png
[20200526000227841.png]: https://img-blog.csdnimg.cn/20200526000227841.png
[20200526002450126.png]: https://img-blog.csdnimg.cn/20200526002450126.png
[20200526002819728.png]: https://img-blog.csdnimg.cn/20200526002819728.png
[20200526193641616.png]: https://img-blog.csdnimg.cn/20200526193641616.png
[2020052620294165.png]: https://img-blog.csdnimg.cn/2020052620294165.png
[20200526203104716.png]: https://img-blog.csdnimg.cn/20200526203104716.png
[20200526205035498.png]: https://img-blog.csdnimg.cn/20200526205035498.png
[20200526211100837.png]: https://img-blog.csdnimg.cn/20200526211100837.png
[2020052621125168.png]: https://img-blog.csdnimg.cn/2020052621125168.png