springboot之使用redis为mybatis二级缓存

最新推荐文章于 2024-06-27 18:31:08 发布

lss0555

最新推荐文章于 2024-06-27 18:31:08 发布

阅读量815

点赞数

分类专栏： # SpringBoot # MyBatis # redis 文章标签： springboot mybatis 二级缓存

本文链接：https://blog.csdn.net/u010520146/article/details/86680275

版权

SpringBoot 同时被 3 个专栏收录

29 篇文章 1 订阅

订阅专栏

redis

14 篇文章 0 订阅

订阅专栏

MyBatis

9 篇文章 1 订阅

订阅专栏

一.前言

Mybatis默认开启一级缓存,二级缓存需要手动开启。Mybatis的二级缓存是多个SqlSession共享的，作用于是mapper配置文件中同一个namespace，不同的SqlSession两次执行相同namespace下的sql语句且参数如果也一样，则通过缓存查询的cacheKey也是一样的,则最终执行的sql语句是相同的。每次查询都会先看看缓存中是否有对应查询结果，如果有就从缓存拿，如果没有就执行sql语句从数据库中读取，从而提高查询效率。本文提使用redis的hash结构存储来实现mybatis的二级缓存方案。

二.缓存机制分析

1.概述

二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap存储，不同在于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache、Hazelcast等
对于缓存数据更新机制，当某一个作用域(一级缓存Session/二级缓存Namespaces)的进行了 C/U/D 操作后，默认该作用域下所有 select 中的缓存将被clear
MyBatis 的缓存采用了delegate机制及装饰器模式设计

2.Executor分析

Executor是跟SqlSession绑定在一起的，每一个SqlSession都拥有一个新的Executor对象，由Configuration创建。Executor接口代码如下

public interface Executor {
    ResultHandler NO_RESULT_HANDLER = null;

    int update(MappedStatement var1, Object var2) throws SQLException;

    <E> List<E> query(MappedStatement var1, Object var2, RowBounds var3, ResultHandler var4, CacheKey var5, BoundSql var6) throws SQLException;

    <E> List<E> query(MappedStatement var1, Object var2, RowBounds var3, ResultHandler var4) throws SQLException;

    <E> Cursor<E> queryCursor(MappedStatement var1, Object var2, RowBounds var3) throws SQLException;

    List<BatchResult> flushStatements() throws SQLException;

    void commit(boolean var1) throws SQLException;

    void rollback(boolean var1) throws SQLException;

    CacheKey createCacheKey(MappedStatement var1, Object var2, RowBounds var3, BoundSql var4);

    boolean isCached(MappedStatement var1, CacheKey var2);

    void clearLocalCache();

    void deferLoad(MappedStatement var1, MetaObject var2, String var3, CacheKey var4, Class<?> var5);

    Transaction getTransaction();

    void close(boolean var1);

    boolean isClosed();

    void setExecutorWrapper(Executor var1);
}

Executor类结构图：

在这里插入图片描述

3.Executor源码浅析

Executor接口的实现类有2个,一个是BaseExecutor,另外一个是CachingExecutor。Executor是MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护；CachingExecutor是一个Executor的装饰器，给一个Executor增加了缓存的功能。此时可以看做是对Executor类的一个增强，故使用装饰器模式是不错的选择。

Executor是跟SqlSession绑定在一起的，每一个SqlSession都拥有一个新的Executor对象，由Configuration创建。代码如下

 public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
        executorType = executorType == null ? this.defaultExecutorType : executorType;
        executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
        Object executor;
        if (ExecutorType.BATCH == executorType) {
            executor = new BatchExecutor(this, transaction);
        } else if (ExecutorType.REUSE == executorType) {
            executor = new ReuseExecutor(this, transaction);
        } else {
            executor = new SimpleExecutor(this, transaction);
        }

        if (this.cacheEnabled) {
            executor = new CachingExecutor((Executor)executor);
        }

        Executor executor = (Executor)this.interceptorChain.pluginAll(executor);
        return executor;
    }

1.BaseExecutor

SimpleExecutor
每执行一次doUpdate或doQuery，就开启一个Statement对象，用完马上关闭Statement对象。（可以是Statement或PrepareStatement对象）

public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
        Statement stmt = null;

        int var6;
        try {
            Configuration configuration = ms.getConfiguration();
            StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, (ResultHandler)null, (BoundSql)null);
            stmt = this.prepareStatement(handler, ms.getStatementLog());
            var6 = handler.update(stmt);
        } finally {
            this.closeStatement(stmt);
        }

        return var6;
    }

    public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        Statement stmt = null;

        List var9;
        try {
            Configuration configuration = ms.getConfiguration();
            StatementHandler handler = configuration.newStatementHandler(this.wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
            stmt = this.prepareStatement(handler, ms.getStatementLog());
            var9 = handler.query(stmt, resultHandler);
        } finally {
            this.closeStatement(stmt);
        }

        return var9;
    }

ReuseExecutor
执行doUpdate或doQuery

 public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
        Configuration configuration = ms.getConfiguration();
        StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, (ResultHandler)null, (BoundSql)null);
        Statement stmt = this.prepareStatement(handler, ms.getStatementLog());
        return handler.update(stmt);
    }

    public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        Configuration configuration = ms.getConfiguration();
        StatementHandler handler = configuration.newStatementHandler(this.wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
        Statement stmt = this.prepareStatement(handler, ms.getStatementLog());
        return handler.query(stmt, resultHandler);
    }

以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map<String, Statement>内，供下一次使用。（可以是Statement或PrepareStatement对象）

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
        BoundSql boundSql = handler.getBoundSql();
        String sql = boundSql.getSql();
        Statement stmt;
        //通过sql作为key查找是否存在
        if (this.hasStatementFor(sql)) {
            stmt = this.getStatement(sql);
            this.applyTransactionTimeout(stmt);
        } else {
            Connection connection = this.getConnection(statementLog);
            stmt = handler.prepare(connection, this.transaction.getTimeout());
            this.putStatement(sql, stmt);
        }

        handler.parameterize(stmt);
        return stmt;
    }
  
  //通过sql作为key,判断是否存在
  private boolean hasStatementFor(String sql) {
        try {
            return this.statementMap.keySet().contains(sql) && !((Statement)this.statementMap.get(sql)).getConnection().isClosed();
        } catch (SQLException var3) {
            return false;
        }
    }	
	
	
  //存放于statementMap中	
  private void putStatement(String sql, Statement stmt) {
        this.statementMap.put(sql, stmt);
    }

BatchExecutor
执行doUpdate（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理的（可以是Statement或PrepareStatement对象）

 public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {
        Configuration configuration = ms.getConfiguration();
        StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, (ResultHandler)null, (BoundSql)null);
        BoundSql boundSql = handler.getBoundSql();
        String sql = boundSql.getSql();
        Statement stmt;
        if (sql.equals(this.currentSql) && ms.equals(this.currentStatement)) {
            int last = this.statementList.size() - 1;
            stmt = (Statement)this.statementList.get(last);
            this.applyTransactionTimeout(stmt);
            handler.parameterize(stmt);
            BatchResult batchResult = (BatchResult)this.batchResultList.get(last);
            batchResult.addParameterObject(parameterObject);
        } else {
            Connection connection = this.getConnection(ms.getStatementLog());
            stmt = handler.prepare(connection, this.transaction.getTimeout());
            handler.parameterize(stmt);
            this.currentSql = sql;
            this.currentStatement = ms;
            this.statementList.add(stmt);
            this.batchResultList.add(new BatchResult(ms, sql, parameterObject));
        }

        handler.batch(stmt);
        return -2147482646;
    }

2.CachingExecutor
先从缓存中获取查询结果，存在就返回，不存在，再委托给Executor delegate去数据库取，delegate可以是上面任一的SimpleExecutor、ReuseExecutor、BatchExecutor。代码如下：

 public int update(MappedStatement ms, Object parameterObject) throws SQLException {
        this.flushCacheIfRequired(ms);
        return this.delegate.update(ms, parameterObject);
    }
	
	//通过cacheKey获取缓存数据
    public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        BoundSql boundSql = ms.getBoundSql(parameterObject);
        CacheKey key = this.createCacheKey(ms, parameterObject, rowBounds, boundSql);
        return this.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }

    public <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException {
        this.flushCacheIfRequired(ms);
        return this.delegate.queryCursor(ms, parameter, rowBounds);
    }
	
	//缓存判断,如果存在则返回缓存中的数据
    public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        Cache cache = ms.getCache();
        if (cache != null) {
            this.flushCacheIfRequired(ms);
            //判断是否为isUserCache为true 且resusultHandle不为空
            if (ms.isUseCache() && resultHandler == null) {
                this.ensureNoOutParams(ms, boundSql);
                //通过key,获取缓存中的数据
                List<E> list = (List)this.tcm.getObject(cache, key);
                if (list == null) {
                //缓存不存在,直接去数据库查询
                    list = this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
                    this.tcm.putObject(cache, key, list);
                }
				//存在,直接返回缓存数据
                return list;
            }
        }
		//直接去数据库查询	
        return this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }

三.实例分析

本实例采用的是springboot2.1.1

1.poml文件添加redis与mybatis包

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.2</version>
		</dependency>

2.application.xml配置

配置端口8016,mysql与redis以及mybatis的配置

server:
  port: 8016
spring:
  datasource:
    driver-class-name:  com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/lss0555?serverTimezone=UTC&characterEncoding=utf-8
    username: root
    password: 888888
    dbcp2:
      validation-query: select 1 from dual
      test-on-borrow: true
      min-evictable-idle-time-millis: 600000
      time-between-eviction-runs-millis: 300000
  redis:
    host: 127.0.0.1
    port: 6379
    password: 888888
    timeout: 10000
    jedis:
      pool:
        max-idle: 8
        min-idle: 10
        max-active: 100
        max-wait: -1


mybatis:
  configuration:
    mapUnderscoreToCamelCase: false
    cache-enabled: true
  type-aliases-package: com.example.mybatistest.model
  mapper-locations: classpath*:mapping/*.xml

mybatis开启缓存使用: cache-enabled: true

3.定义SpringContextHolder

实现了Spring的ApplicationContextAware来获取ApplicationContext，从中获取容器的bean

@Component
public class SpringContextHolder  implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    /**
     * 实现ApplicationContextAware接口的context注入函数, 将其存入静态变量.
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        SpringContextHolder.applicationContext = applicationContext; // NOSONAR
    }

    /**
     * 取得存储在静态变量中的ApplicationContext.
     */
    public static ApplicationContext getApplicationContext() {
        checkApplicationContext();
        return applicationContext;
    }

    /**
     * 从静态变量ApplicationContext中取得Bean, 自动转型为所赋值对象的类型.
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) {
        checkApplicationContext();
        return (T) applicationContext.getBean(name);
    }

    /**
     * 从静态变量ApplicationContext中取得Bean, 自动转型为所赋值对象的类型.
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(Class<T> clazz) {
        checkApplicationContext();
        return (T) applicationContext.getBeansOfType(clazz);
    }

    /**
     * 清除applicationContext静态变量.
     */
    public static void cleanApplicationContext() {
        applicationContext = null;
    }

    private static void checkApplicationContext() {
        if (applicationContext == null) {
            throw new IllegalStateException("applicaitonContext未注入,请在applicationContext.xml中定义SpringContextHolder");
        }
    }
}

4.实现ibatis的Cache接口 RedisCache

public class RedisCache implements Cache {
    private static final Logger logger = LoggerFactory.getLogger(RedisCache.class);

    // 读写锁
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);

    private RedisTemplate<String, Object> redisTemplate = SpringContextHolder.getBean("redisTemplate");

    private String id;

    public RedisCache(){

    }

    public RedisCache(final String id) {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        }
        logger.info("Redis Cache id " + id);
        this.id = id;
    }

    @Override
    public String getId() {
        return this.id;
    }

    @Override
    public void putObject(Object key, Object value) {
        if (value != null) {
            // 向Redis中添加数据，有效时间是1天
            logger.info("缓存:新增缓存  key:"+key);
            redisTemplate.opsForValue().set(key.toString(), value, 1, TimeUnit.DAYS);
        }
    }

    @Override
    public Object getObject(Object key) {
        try {
            if (key != null) {
                logger.info("缓存:获取  key:"+key);
                Object obj = redisTemplate.opsForValue().get(key.toString());
                return obj;
            }
        } catch (Exception e) {
            logger.error("redis 异常:"+e);
        }
        return null;
    }

    @Override
    public Object removeObject(Object key) {
        try {
            if (key != null) {
                logger.info("缓存:移除:"+key);
                redisTemplate.delete(key.toString());
            }
        } catch (Exception e) {
        }
        return null;
    }

    @Override
    public void clear() {
        logger.info("缓存:清空");
        try {
            Set<String> keys = redisTemplate.keys("*:" + this.id + "*");
            if (!CollectionUtils.isEmpty(keys)) {
                redisTemplate.delete(keys);
            }
        } catch (Exception e) {
        }
    }

    @Override
    public int getSize() {
        Long size = (Long) redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.dbSize();
            }
        });
        logger.info("缓存:数量:"+size.intValue());
        return size.intValue();
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return this.readWriteLock;
    }
}

5.接口测试用例

（1）dao层接口

@Mapper
public interface UserDaoMapper {
    List<User> userList();
}

（2）Mapping实现层

<mapper namespace="com.example.mybatistest.dao.UserDaoMapper">

    <cache  type="com.example.mybatistest.cache.RedisCache">
        <property name="eviction" value="LRU" />
        <property name="flushInterval" value="6000000" />
        <property name="size" value="1024" />
        <property name="readOnly" value="false" />
    </cache>
    
    <select id="userList"    resultType="com.example.mybatistest.model.User">
        select *  from `user`
    </select>
</mapper>

cache标签内属性：

eviction：定义缓存移除机制（算法），默认为LRU（最近最少使用），它会清除最少使用的数据，还有一种FIFO（先进先出），它会清除最先进来的数据。
flushInterval：定义缓存刷新周期，单位为毫秒。
size：标识缓存cache中容纳的最大元素，默认为1024。
readOnly：默认为false，可配置为true缓存只读。

注意：

select 默认useCache为true：使用缓存，flushCache为false：不清空缓存
insert、update、delete 默认flushCache为true：清空缓存

（3）Service层
UserServiceInter 接口层

public interface UserServiceInter {
   List<User> userList();
}

UserServiceImpl实现层

@Service
public class UserServiceImpl implements UserServiceInter {
    @Resource
    UserDaoMapper userDaoMapper;

    @Override
    public List<User> userList() {
        return userDaoMapper.userList();
    }
}

（4）controller层

	@GetMapping("/userList")
    public TResult getUserList(){
        TResult<User> result = new TResult<>();
        result.setList(userServiceInter.userList());
        return result;
    }

（5）测试结果
第一次访问 http://localhost:8016/userList1 控制台dubug信息如下:

2019-01-28 16:26:49.344 [http-nio-8016-exec-5] DEBUG org.springframework.web.servlet.DispatcherServlet - GET "/userList2", parameters={}
2019-01-28 16:26:49.345 [http-nio-8016-exec-5] DEBUG o.s.w.s.m.m.a.RequestMappingHandlerMapping - Mapped to public com.example.mybatistest.model.TResult com.example.mybatistest.controller.UserController.userList2()
2019-01-28 16:26:49.345 [http-nio-8016-exec-5] DEBUG org.mybatis.spring.SqlSessionUtils - Creating a new SqlSession
2019-01-28 16:26:49.345 [http-nio-8016-exec-5] DEBUG org.mybatis.spring.SqlSessionUtils - SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@1bd8321] was not registered for synchronization because synchronization is not active
2019-01-28 16:26:49.345 [http-nio-8016-exec-5] INFO  com.example.mybatistest.cache.RedisCache - 缓存:获取  key:-1672553611:3475886595:com.example.mybatistest.dao.UserDaoMapper.userList2:0:2147483647:select *  from `user`:SqlSessionFactoryBean
2019-01-28 16:26:49.345 [http-nio-8016-exec-5] DEBUG o.s.data.redis.core.RedisConnectionUtils - Opening RedisConnection
2019-01-28 16:26:49.347 [http-nio-8016-exec-5] DEBUG io.lettuce.core.RedisChannelHandler - dispatching command AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2019-01-28 16:26:49.347 [http-nio-8016-exec-5] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, epid=0x1] write() writeAndFlush command AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2019-01-28 16:26:49.347 [http-nio-8016-exec-5] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, epid=0x1] write() done
2019-01-28 16:26:49.347 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, chid=0x1] write(ctx, AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command], promise)
2019-01-28 16:26:49.348 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandEncoder - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379] writing command AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2019-01-28 16:26:49.349 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, chid=0x1] Received: 5 bytes, 1 commands in the stack
2019-01-28 16:26:49.349 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, chid=0x1] Stack contains: 1 commands
2019-01-28 16:26:49.349 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.RedisStateMachine - Decode AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2019-01-28 16:26:49.349 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.RedisStateMachine - Decoded AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command], empty stack: true
2019-01-28 16:26:49.349 [http-nio-8016-exec-5] DEBUG o.s.data.redis.core.RedisConnectionUtils - Closing Redis Connection
2019-01-28 16:26:49.349 [http-nio-8016-exec-5] DEBUG com.example.mybatistest.dao.UserDaoMapper - Cache Hit Ratio [com.example.mybatistest.dao.UserDaoMapper]: 0.3333333333333333
2019-01-28 16:26:49.349 [http-nio-8016-exec-5] DEBUG o.springframework.jdbc.datasource.DataSourceUtils - Fetching JDBC Connection from DataSource
2019-01-28 16:26:49.351 [http-nio-8016-exec-5] DEBUG o.m.spring.transaction.SpringManagedTransaction - JDBC Connection [HikariProxyConnection@21358673 wrapping com.mysql.cj.jdbc.ConnectionImpl@14e9682] will not be managed by Spring
2019-01-28 16:26:49.351 [http-nio-8016-exec-5] DEBUG c.example.mybatistest.dao.UserDaoMapper.userList2 - ==>  Preparing: select * from `user` 
2019-01-28 16:26:49.351 [http-nio-8016-exec-5] DEBUG c.example.mybatistest.dao.UserDaoMapper.userList2 - ==> Parameters: 
2019-01-28 16:26:49.354 [http-nio-8016-exec-5] DEBUG c.example.mybatistest.dao.UserDaoMapper.userList2 - <==      Total: 5
2019-01-28 16:26:49.354 [http-nio-8016-exec-5] INFO  com.example.mybatistest.cache.RedisCache - 缓存:新增缓存  key:-1672553611:3475886595:com.example.mybatistest.dao.UserDaoMapper.userList2:0:2147483647:select *  from `user`:SqlSessionFactoryBean
2019-01-28 16:26:49.354 [http-nio-8016-exec-5] DEBUG o.s.data.redis.core.RedisConnectionUtils - Opening RedisConnection
2019-01-28 16:26:49.354 [http-nio-8016-exec-5] DEBUG io.lettuce.core.RedisChannelHandler - dispatching command AsyncCommand [type=SETEX, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2019-01-28 16:26:49.355 [http-nio-8016-exec-5] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, epid=0x1] write() writeAndFlush command AsyncCommand [type=SETEX, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2019-01-28 16:26:49.355 [http-nio-8016-exec-5] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, epid=0x1] write() done
2019-01-28 16:26:49.355 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, chid=0x1] write(ctx, AsyncCommand [type=SETEX, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command], promise)
2019-01-28 16:26:49.356 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandEncoder - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379] writing command AsyncCommand [type=SETEX, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2019-01-28 16:26:49.357 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, chid=0x1] Received: 5 bytes, 1 commands in the stack
2019-01-28 16:26:49.357 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, chid=0x1] Stack contains: 1 commands
2019-01-28 16:26:49.357 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.RedisStateMachine - Decode AsyncCommand [type=SETEX, output=StatusOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2019-01-28 16:26:49.357 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.RedisStateMachine - Decoded AsyncCommand [type=SETEX, output=StatusOutput [output=OK, error='null'], commandType=io.lettuce.core.protocol.Command], empty stack: true
2019-01-28 16:26:49.357 [http-nio-8016-exec-5] DEBUG o.s.data.redis.core.RedisConnectionUtils - Closing Redis Connection
2019-01-28 16:26:49.357 [http-nio-8016-exec-5] DEBUG org.mybatis.spring.SqlSessionUtils - Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@1bd8321]
2019-01-28 16:26:49.357 [http-nio-8016-exec-5] DEBUG o.springframework.jdbc.datasource.DataSourceUtils - Returning JDBC Connection to DataSource
2019-01-28 16:26:49.357 [http-nio-8016-exec-5] DEBUG o.s.w.s.m.m.a.RequestResponseBodyMethodProcessor - Using 'application/json', given [*/*] and supported [application/json, application/*+json, application/json, application/*+json]
2019-01-28 16:26:49.358 [http-nio-8016-exec-5] DEBUG o.s.w.s.m.m.a.RequestResponseBodyMethodProcessor - Writing [TResult{errorCode=0, model=null, list=[User{id=1, username='22', password='dd', Salt='ee'}, User{id=2, username='dd', password='dd', Salt='dd'}, User{id=3, username='ccc', password='ccc', Salt='sd'}, User{id=4, username='d', password='d', Salt='d'}, User{id=5, username='1', password='1', Salt='11'}]}]
2019-01-28 16:26:49.359 [http-nio-8016-exec-5] DEBUG org.springframework.web.servlet.DispatcherServlet - Completed 200 OK

发现里面是有走数据库的查询操作
再次访问,log如下:

2019-01-28 16:27:54.968 [http-nio-8016-exec-7] DEBUG org.springframework.web.servlet.DispatcherServlet - GET "/userList2", parameters={}
2019-01-28 16:27:54.968 [http-nio-8016-exec-7] DEBUG o.s.w.s.m.m.a.RequestMappingHandlerMapping - Mapped to public com.example.mybatistest.model.TResult com.example.mybatistest.controller.UserController.userList2()
2019-01-28 16:27:54.968 [http-nio-8016-exec-7] DEBUG org.mybatis.spring.SqlSessionUtils - Creating a new SqlSession
2019-01-28 16:27:54.968 [http-nio-8016-exec-7] DEBUG org.mybatis.spring.SqlSessionUtils - SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@364b19] was not registered for synchronization because synchronization is not active
2019-01-28 16:27:54.969 [http-nio-8016-exec-7] INFO  com.example.mybatistest.cache.RedisCache - 缓存:获取  key:-1672553611:3475886595:com.example.mybatistest.dao.UserDaoMapper.userList2:0:2147483647:select *  from `user`:SqlSessionFactoryBean
2019-01-28 16:27:54.969 [http-nio-8016-exec-7] DEBUG o.s.data.redis.core.RedisConnectionUtils - Opening RedisConnection
2019-01-28 16:27:54.969 [http-nio-8016-exec-7] DEBUG io.lettuce.core.RedisChannelHandler - dispatching command AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2019-01-28 16:27:54.969 [http-nio-8016-exec-7] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, epid=0x1] write() writeAndFlush command AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2019-01-28 16:27:54.969 [http-nio-8016-exec-7] DEBUG io.lettuce.core.protocol.DefaultEndpoint - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, epid=0x1] write() done
2019-01-28 16:27:54.969 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, chid=0x1] write(ctx, AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command], promise)
2019-01-28 16:27:54.970 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandEncoder - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379] writing command AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2019-01-28 16:27:54.971 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, chid=0x1] Received: 298 bytes, 1 commands in the stack
2019-01-28 16:27:54.971 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.CommandHandler - [channel=0xc7f50bf0, /127.0.0.1:49477 -> /127.0.0.1:6379, chid=0x1] Stack contains: 1 commands
2019-01-28 16:27:54.971 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.RedisStateMachine - Decode AsyncCommand [type=GET, output=ValueOutput [output=null, error='null'], commandType=io.lettuce.core.protocol.Command]
2019-01-28 16:27:54.971 [lettuce-nioEventLoop-4-1] DEBUG io.lettuce.core.protocol.RedisStateMachine - Decoded AsyncCommand [type=GET, output=ValueOutput [output=[B@15219b4, error='null'], commandType=io.lettuce.core.protocol.Command], empty stack: true
2019-01-28 16:27:54.972 [http-nio-8016-exec-7] DEBUG o.s.data.redis.core.RedisConnectionUtils - Closing Redis Connection
2019-01-28 16:27:54.972 [http-nio-8016-exec-7] DEBUG com.example.mybatistest.dao.UserDaoMapper - Cache Hit Ratio [com.example.mybatistest.dao.UserDaoMapper]: 0.5
2019-01-28 16:27:54.972 [http-nio-8016-exec-7] DEBUG org.mybatis.spring.SqlSessionUtils - Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@364b19]
2019-01-28 16:27:54.972 [http-nio-8016-exec-7] DEBUG o.s.w.s.m.m.a.RequestResponseBodyMethodProcessor - Using 'application/json', given [*/*] and supported [application/json, application/*+json, application/json, application/*+json]
2019-01-28 16:27:54.972 [http-nio-8016-exec-7] DEBUG o.s.w.s.m.m.a.RequestResponseBodyMethodProcessor - Writing [TResult{errorCode=0, model=null, list=[User{id=1, username='22', password='dd', Salt='ee'}, User{id=2, username='dd', password='dd', Salt='dd'}, User{id=3, username='ccc', password='ccc', Salt='sd'}, User{id=4, username='d', password='d', Salt='d'}, User{id=5, username='1', password='1', Salt='11'}]}]
2019-01-28 16:27:54.975 [http-nio-8016-exec-7] DEBUG org.springframework.web.servlet.DispatcherServlet - Completed 200 OK