Mybatis的缓存过期机制和RedisCache

  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;
  }

  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);
    }
  }

  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);
  }

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

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

/**
 * 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;
            }
        }
    }
}

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);
  }
}