Mybatis的缓存过期机制和RedisCache

MyBatis的缓存过期机制, flushInterval参数

在实际测试中, 发现Redis中的缓存数据TTL为-1, 在Hash中的key也无过期时间信息, 怀疑RedisCache的实现是否能正常处理缓存过期, 因此一路追查到了MyBatis的代码.

MyBatis在每个Mapper中, 可以设置参数 flushInterval 用来控制缓存的过期时间, 这个参数, 在 MapperBuilderAssistant 中, 被设置为Cache的clearInternal

  public Cache useNewCache(Class<? extends Cache> typeClass,
      Class<? extends Cache> evictionClass,
      Long flushInterval,
      Integer size,
      boolean readWrite,
      boolean blocking,
      Properties props) {
    Cache cache = new CacheBuilder(currentNamespace)
        .implementation(valueOrDefault(typeClass, PerpetualCache.class))
        .addDecorator(valueOrDefault(evictionClass, LruCache.class))
        .clearInterval(flushInterval)
        .size(size)
        .readWrite(readWrite)
        .blocking(blocking)
        .properties(props)
        .build();
    configuration.addCache(cache);
    currentCache = cache;
    return cache;
  }

而后在CacheBuilder中, 会根据这个参数, 判断是否生成代理类ScheduledCache

  private Cache setStandardDecorators(Cache cache) {
    try {
      MetaObject metaCache = SystemMetaObject.forObject(cache);
      if (size != null && metaCache.hasSetter("size")) {
        metaCache.setValue("size", size);
      }
      if (clearInterval != null) {
        cache = new ScheduledCache(cache);
        ((ScheduledCache) cache).setClearInterval(clearInterval);
      }
      if (readWrite) {
        cache = new SerializedCache(cache);
      }
      cache = new LoggingCache(cache);
      cache = new SynchronizedCache(cache);
      if (blocking) {
        cache = new BlockingCache(cache);
      }
      return cache;
    } catch (Exception e) {
      throw new CacheException("Error building standard cache decorators.  Cause: " + e, e);
    }
  }

ScheduledCache内部存储了一个变量lastClear, 用来记录最后一次清空缓存的时间, 在get, put, remove等各个操作前, 会判断是否需要清空, 注意是整个namespace的缓存清空.

  private boolean clearWhenStale() {
    if (System.currentTimeMillis() - lastClear > clearInterval) {
      clear();
      return true;
    }
    return false;
  }

  @Override
  public void putObject(Object key, Object object) {
    clearWhenStale();
    delegate.putObject(key, object);
  }

  @Override
  public Object getObject(Object key) {
    return clearWhenStale() ? null : delegate.getObject(key);
  }

由此可以看出, MyBatis的缓存过期管理机制还是比较粗糙的, 并且依赖本地实例中记录的时间, 同样的LRU机制也是依赖本地.

在分布系统中使用MyBatis如果使用Redis作为缓存, 需要注意这个问题,

1. 默认情况下, Redis中的缓存时间为-1永不过期, 根据各个实例中的计时进行过期清除, 在节点数超过2的情况下, 建议关闭mapper中的flushInterval

2. 如果使用Github中beta3版本的代码, 那么可以在mapper中增加一个timeout来设置Redis key的过期时间, 这个可以在flushInterval关闭的情况下, 通过redis自身进行缓存的过期清理, 但是这个过期时间对应的是一个namespace, 意味着每隔一段时间, 这整个namespace中的缓存全部失效, 哪怕这个查询结果一秒前刚刚被缓存, 这一秒就被清空了.

3. 缓存的主动失效由insert, update, delete发起, 这个在分布式环境下的触发依然是有效的. 但是对于通过多表join得到的结果, 如果未共享namespace, 容易出现缓存未更新而拿到旧数据的情况. 建议在sql编写中通过1+N形式完成复杂查询, 尽量不用使用join

针对Redis缓存的优化方案

1. 关闭 MyBatis 的 flushInterval , 避免各个节点互相干扰的问题, 将缓存的过期控制交给Redis管理

2. 对每一个缓存结果, 在序列化和反序列化时增加一个时间戳, 在读取缓存的时候判断是否过期, 如果过期就返回空(等同于缓存未命中或缓存失效), 将过期时间粒度细化到单个结果.

3. 实现了2之后可以关闭key的timeout, 仅由增删改来触发整个key的清理.

MyBatis RedisCache

http://mybatis.org/redis-cache/

https://github.com/mybatis/redis-cache

这是MyBatis官方的二级缓存的Redis实现, 不支持Redis Cluster, 因为其依赖于Jedis和固定的redis.properties, 和Spring Boot集成较为麻烦, 在Spring Boot 2.1.x中使用还会报RedisConfig初始化错误.

https://github.com/MiltonLai/redis-cache

魔改后的版本, 支持Cluster, 并且支持单个查询结果的过期控制, 未经高强度验证, 请谨慎使用.

使其正常运行

首先不要用pom的jar包引入, 直接到github项目地址上下载源代码, 需要的只是 src/main/java/org/mybatis/caches/redis/ 目录下的文件, 将其放到自己的项目里.

其次, 现在的源码中, 对redis.properties要求其中各项配置名称要以redis.为前缀, 和jar包引用时的要求不一样.

这样基本就能启动运行了

在beta3之后增加了timeout参数, 可以通过redis自身的ttl设置缓存失效时间, 在mapper中的配置方式为

XML

<cache type="org.mybatis.caches.redis.RedisCache">
  <property name="timeout" value="3" />
</cache>

Annotation

@CacheNamespace(properties = { @Property(name = "timeout", value = "3") })

如果需要支持Redis Cluster, 可以使用这个版本

Spring Boot中的配置

在Spring Boot中, 也可以通过redis.properties配置.

使用RedisTemplate

如果希望使用SpringBoot的RedisTemplate, 可以加上一个静态引用, 例如

/**
 * Cons:
 * 1. Memory issues: if you redeploy the WAR without restarting the VM, you end up with 2 application contexts in the
 * same VM: the one attached to the static field of ApplicationContextHolder and the new one that is stored in the
 * ServletContext. This is just the same issue as the commons-logging memory issue.
 * 2. Tests: if you use spring tests, you will have multiple application contexts in the same VM when running a suite,
 * but only the one loaded from the first test is stored in the static field.
 * 3. Application context hierarchy: It is quite common to have a "services application context" and a "web application
 * context" (and a DispatcherServlet application context), each one being a child of the previous one. Only the root
 * (services) application context will be stored in the static variable, and thus you have a lot of beans that are not
 * accessible.
 *
 * Though, it's safe to use this in a java -jar application.
 */
@Component
public class ApplicationContextHolder implements ApplicationContextAware {

    private static ApplicationContext context;

    /**
     * Returns the Spring managed bean instance of the given class type if it exists.
     * Returns null otherwise.
     */
    public static <T> T getBean(Class<T> beanClass) {
        return context.getBean(beanClass);
    }

    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) {
        return (T) context.getBean(name);
    }

    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        // store ApplicationContext reference to access required beans later on
        synchronized (this) {
            if (ApplicationContextHolder.context == null) {
                ApplicationContextHolder.context = context;
            }
        }
    }
}

这时候需要自己重写RedisCache.java, 在方法中引用RedisTemplate. 因为在mapper初始化的时候给redisTemplate赋值有可能会失败, 所以使用getRedisTemplate()方法, 在调用时再赋值.

代码参考 https://programmer.help/blogs/spring-boot-mybatis-redis-secondary-cache.html, 这个实现是使用整个db存kv实现的, 跟mybatis redis的实现(用hash)不一样, 这个的好处是自带过期时间, 但是在namespace缓存清空时, 会影响所有的namespace. 如果要在正式环境使用, 需要改一下.

private RedisTemplate redisTemplate;

private RedisTemplate getRedisTemplate() {
    if (redisTemplate == null) {
        redisTemplate = ApplicationContextHolder.getBean("redisTemplate");
    }
    return redisTemplate;
}
...
public void putObject(Object key, Object value) {
    ValueOperations opsForValue = getRedisTemplate().opsForValue();
    opsForValue.set(key, value, timeout, TimeUnit.SECONDS);
}
...

将过期控制应用到单个查询结果

在序列化/反序列化中增加时间戳

public byte[] serialize(long timestamp, Object object) {
    try (
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos)) {
      oos.writeObject(object);
      baos.write(longToBytes(timestamp));
      return baos.toByteArray();
    } catch (Exception e) {
      throw new CacheException(e);
    }
  }

  public long getTimestamp(byte[] bytes) {
    if (bytes == null || bytes.length < 8) {
      return -1;
    }
    byte[] copy = new byte[8];
    System.arraycopy(bytes, bytes.length - 8, copy, 0, 8);
    return bytesToLong(copy);
  }

  public Object unserialize(byte[] bytes) {
    if (bytes == null || bytes.length < 8) {
      return null;
    }
    try (ByteArrayInputStream bais = new ByteArrayInputStream(Arrays.copyOf(bytes, bytes.length - 8));
        ObjectInputStream ois = new ObjectInputStream(bais)) {
      return ois.readObject();
    } catch (Exception e) {
      throw new CacheException(e);
    }
  }

在缓存读写时增加过期判断

@Override
public void putObject(final Object key, final Object value) {
  final byte[] idBytes = id.getBytes();
  long ts = 0;
  if (timeout != null) {
    ts = System.currentTimeMillis() + timeout * 1000;
  }
  final byte[] objBytes = redisConfig.getSerializer().serialize(ts, value);
  client.hset(idBytes, key.toString().getBytes(), objBytes);
}

@Override
public Object getObject(final Object key) {
  byte[] objBytes = client.hget(id.getBytes(), key.toString().getBytes());
  if (objBytes == null || objBytes.length < 8) return null;
  long ts = redisConfig.getSerializer().getTimestamp(objBytes);
  if (ts > 0 && ts < System.currentTimeMillis()) {
    client.hdel(id, key.toString());
    return null;
  } else {
    return redisConfig.getSerializer().unserialize(objBytes);
  }
}