Spring+Redis+MyBatis实现缓存整合

<!--redis缓存-->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.8.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.3</version>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>

<!--配置redis连接的配置文件，placeholder的实例只能存在一个-->
<!--<context:property-placeholder location="classpath:redis.properties"/>-->
<!--启用缓存注解-->
<cache:annotation-driven cache-manager="cacheManager"/>
<!--缓存管理器-->
<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
<property name="caches">
<set>
<!--自定义的redis缓存操作实现-->
<bean class="com.common.cache.redis.RedisCache">
<property name="name" value="myCache"/>
<property name="redisTemplate" ref="redisTemplate"/>
</bean>
</set>
</property>
</bean>
<!--redis连接池配置-->
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="${redis.maxIdle}"/>
<property name="maxTotal" value="${redis.maxTotal}"/>
<property name="testOnBorrow" value="${redis.testOnBorrow}"/>
</bean>
<!--redis连接工厂配置-->
<bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="hostName" value="${redis.host}"/>
<property name="port" value="${redis.port}"/>
<property name="password" value="${redis.pass}"/>
<property name="poolConfig" ref="poolConfig"/>
<property name="usePool" value="true"/>
</bean>
<!--redis操作模板-->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="connectionFactory"/>
</bean>

/**
* Cache adapter for Redis.
*/
public class RedisCache implements Cache {
private RedisTemplate<String, Object> redisTemplate;
private String name;

public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}

public void setName(String name) {
this.name = name;
}

@Override
public String getName() {
return this.name;
}

@Override
public Object getNativeCache() {
return this.redisTemplate;
}

/**
* 从缓存中获取key
*/
@Override
public ValueWrapper get(Object key) {
final String keyf = key.toString();
Object object;
object = redisTemplate.execute((RedisCallback<Object>) connection -> {
byte[] key1 = keyf.getBytes();
byte[] value = connection.get(key1);
if (value == null) {
return null;
}
return SerializationUtils.deserialize(value);
});
return (object != null ? new SimpleValueWrapper(object) : null);
}

/**
* 将一个新的key保存到缓存中
* 先拿到需要缓存key名称和对象，然后将其转成ByteArray
*/
@Override
public void put(Object key, Object value) {
final String keyf = key.toString();
final Object valuef = value;
final long liveTime = 86400;
redisTemplate.execute((RedisCallback<Long>) connection -> {
byte[] keyb = keyf.getBytes();
byte[] valueb = SerializationUtils.serialize(valuef);
connection.set(keyb, valueb);
if (liveTime > 0) {
connection.expire(keyb, liveTime);
}
return 1L;
});
}

/**
* 删除key
*/
@Override
public void evict(Object key) {
final String keyf = key.toString();
redisTemplate.execute((RedisCallback<Long>) connection -> connection.del(keyf.getBytes()));
}

/**
* 清空key
*/
@Override
public void clear() {
redisTemplate.execute((RedisCallback<String>) connection -> {
connection.flushDb();
return "ok";
});
}

@Override
public <T> T get(Object key, Class<T> type) {
return null;
}

@Override
public <T> T get(Object o, Callable<T> callable) {
return null;
}

@Override
public ValueWrapper putIfAbsent(Object key, Object value) {
return null;
}
}

//在Service层写注解
@Cacheable(value = "myCache", key = "getMethodName()")