在项目中,实现redis的缓存功能,采用了redisTemplate 和jedis两种方式。
一、redisTemplate的实现
1、配置Spring 文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:redis="http://www.springframework.org/schema/redis"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/redis
http://www.springframework.org/schema/redis/spring-redis.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="${redis.maxIdle}" />
<property name="testOnBorrow" value="${redis.testOnBorrow}" />
</bean>
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
p:hostName="${redis.host}"
p:port="${redis.port}"
p:password="${redis.pass}"
p:poolConfig-ref="poolConfig"/>
<bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate" p:connectionFactory-ref="jedisConnectionFactory"/>
<!---->
</beans>
2、redis属性配置
# Redis settings
redis.host=localhost
redis.port=6379
redis.pass=
redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true
3、创建一个接口,实现redis的添加数据,删除数据,查看数据等
import java.util.Set;
/**
* Created by gangchaopan on 16/7/26.
*/
public interface RedisService {
/**
* 通过key删除
*
* @param keys
*/
public abstract long del(String... keys);
/**
* 添加key value 并且设置存活时间(byte)
*
* @param key
* @param value
* @param liveTime
*/
public abstract void set(byte[] key, byte[] value, long liveTime);
/**
* 添加key value 并且设置存活时间
*
* @param key
* @param value
* @param liveTime
* 单位秒
*/
public abstract void set(String key, String value, long liveTime);
/**
* 添加key value
*
* @param key
* @param value
*/
public abstract void set(String key, String value);
/**
* 添加key value (字节)(序列化)
*
* @param key
* @param value
*/
public abstract void set(byte[] key, byte[] value);
/**
* 获取redis value (String)
*
* @param key
* @return
*/
public abstract String get(String key);
/**
* 通过正则匹配keys
*
* @param pattern
* @return
*/
public abstract Set keys(String pattern);
/**
* 检查key是否已经存在
*
* @param key
* @return
*/
public abstract boolean exists(String key);
/**
* 清空redis 所有数据
*
* @return
*/
public abstract String flushDB();
/**
* 查看redis里有多少数据
*/
public abstract long dbSize();
/**
* 检查是否连接成功
*
* @return
*/
public abstract String ping();
}
4、实现redis 的接口
import java.io.UnsupportedEncodingException;
import java.util.Set;
import com.yuepai.service.RedisService;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* 封装redis 缓存服务器服务接口
*
* @author hk
* <p>
* 2012-12-16 上午3:09:18
*/
@Service(value = "redisService")
public class RedisServiceImpl implements RedisService {
private static String redisCode = "utf-8";
private RedisTemplate<String, String> redisTemplate;
@Resource
public void setRedisTemplate(RedisTemplate<String, String> redisTemplate) {
this.redisTemplate = redisTemplate;
}
private RedisServiceImpl() {
}
@Override
public long del(final String... keys) {
return redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
long result = 0;
for (String key : keys) {
result = redisConnection.del(key.getBytes());
}
return result;
}
});
}
/**
* @param key
* @param value
* @param liveTime
*/
@Override
public void set(final byte[] key, final byte[] value, final long liveTime) {
redisTemplate.execute(new RedisCallback() {
public Long doInRedis(RedisConnection connection) throws DataAccessException {
connection.set(key, value);
if (liveTime > 0) {
connection.expire(key, liveTime);
}
return 1L;
}
});
}
/**
* @param key
* @param value
* @param liveTime
*/
@Override
public void set(String key, String value, long liveTime) {
this.set(key.getBytes(), value.getBytes(), liveTime);
}
/**
* @param key
* @param value
*/
@Override
public void set(String key, String value) {
this.set(key, value, 0L);
}
/**
* @param key
* @param value
*/
@Override
public void set(byte[] key, byte[] value) {
this.set(key, value, 0L);
}
@Override
public String get(final String key) {
return redisTemplate.execute(new RedisCallback<String>() {
@Override
public String doInRedis(RedisConnection redisConnection) throws DataAccessException {
try {
return new String(redisConnection.get(key.getBytes()), redisCode);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return "";
}
});
}
@Override
public Set keys(String pattern) {
return redisTemplate.keys(pattern);
}
/**
* @param key
* @return
*/
@Override
public boolean exists(final String key) {
return redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.exists(key.getBytes());
}
});
}
/**
* @return
*/
@Override
public String flushDB() {
return redisTemplate.execute(new RedisCallback<String>() {
@Override
public String doInRedis(RedisConnection redisConnection) throws DataAccessException {
redisConnection.flushDb();
return "ok";
}
});
}
@Override
public long dbSize() {
return redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.dbSize();
}
});
}
@Override
public String ping() {
return redisTemplate.execute(new RedisCallback<String>() {
@Override
public String doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.ping();
}
});
}
}
redisTemplate 是通过内部类实现内部类的方法实现。
测试:启动测试需要,把redis的服务开启。
import com.yuepai.service.RedisService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
* Created by gangchaopan on 16/7/26.
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring/spring-mvc.xml", "classpath:mybatis/spring-mybatis.xml","classpath:rabbitmq/spring-rabbitmq.xml","classpath:redis/spring-redis.xml"})
public class RedisTemplateTest {
Logger log = LoggerFactory.getLogger(RedisTemplateTest.class);
private RedisService redisService;
@Autowired
public void setRedisServicel(RedisService redisServicel) {
this.redisService = redisServicel;
}
@Test
public void testSet(){
String key ="test1";
String value= "hello mac";
redisService.set(key,value);
log.debug("存储信息,key:{},value:{}",key,value);
}
@Test
public void testGet(){
if(redisService.exists("key")){
String getValue = redisService.get("key");
log.debug("获取缓存信息:{}",getValue);
}else{
log.debug("获取缓存信息key:{}","不存在");
}
}
@Test
public void testDel(){
redisService.del("test1");
log.debug("已经删除缓存:key{}","test1");
}
@Test
public void testFlushDb(){
redisService.flushDB();
log.debug("缓存:{}","刷新缓存");
}
@Test
public void testPing(){
String ping = redisService.ping();
log.debug("ping,{}",ping);
}
}
二、jedis实现。这里用jedis继承mybatis的cache 缓存,来做redis的二级缓存。这里不需要再spring文件中配置。
package com.yuepai.redis.mybatisCache;
import com.yuepai.utils.SerializeUtil;
import org.apache.ibatis.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* Created by gangchaopan on 16/7/25.
* 自定义redis缓存集成mybatis缓存
*/
public class RedisCache implements Cache {
private Logger log = LoggerFactory.getLogger(RedisCache.class);
private Jedis redisClient = createClient();
private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
private String id;
public RedisCache(final String id) {
if (id == null) {
throw new IllegalArgumentException("Cache instances require an ID");
}
log.debug("-----------创建redis:id=" + id);
this.id = id;
}
@Override
public ReadWriteLock getReadWriteLock() {
return this.readWriteLock;
}
@Override
public String getId() {
return this.id;
}
@Override
public int getSize() {
return Integer.valueOf(redisClient.dbSize().toString());
}
@Override
public void putObject(Object key, Object value) {
log.debug("缓存数据:" + key + "=" + value);
redisClient.set(SerializeUtil.serialize(key.toString()), SerializeUtil.serialize(value));
}
@Override
public Object getObject(Object key) {
log.debug("参数{}",key);
Object value = SerializeUtil.unserialize(redisClient.get(SerializeUtil.serialize(key.toString())));
log.debug("获取缓存数据:" + key + "=" + value);
return value;
}
@Override
public Object removeObject(Object key) {
return redisClient.expire(SerializeUtil.serialize(key.toString()), 0);
}
@Override
public void clear() {
redisClient.flushDB();
}
protected static Jedis createClient() {
try {
JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost");
return pool.getResource();
} catch (Exception e) {
e.printStackTrace();
}
throw new RuntimeException("初始化连接池错误");
}
}
2、开启mybatis的缓存
<property name="configurationProperties">
<props>
<prop key="cacheEnabled">true</prop>
<!-- 查询时,关闭关联对象即时加载以提高性能 -->
<prop key="lazyLoadingEnabled">false</prop>
<!-- 设置关联对象加载的形态,此处为按需加载字段(加载字段由SQL指定),不会加载关联表的所有字段,以提高性能 -->
<prop key="aggressiveLazyLoading">true</prop>
<!-- 对于未知的SQL查询,允许返回不同的结果集以达到通用的效果 -->
<prop key="multipleResultSetsEnabled">true</prop>
<!-- 允许使用列标签代替列名 -->
<prop key="useColumnLabel">true</prop>
<!-- 允许使用自定义的主键值(比如由程序生成的UUID 32位编码作为键值),数据表的PK生成策略将被覆盖 -->
<prop key="useGeneratedKeys">true</prop>
<!-- 给予被嵌套的resultMap以字段-属性的映射支持 -->
<prop key="autoMappingBehavior">FULL</prop>
<!-- 对于批量更新操作缓存SQL以提高性能 -->
<prop key="defaultExecutorType">BATCH</prop>
<!-- 数据库超过25000秒仍未响应则超时 -->
<prop key="defaultStatementTimeout">25000</prop>
</props>
</property>
3、在mybatis的mapper文件中使用。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="XXXXXXXX">
<cache type="XXXXXXX.mybatisCache" eviction="LRU"></cache>
<select id="findById" parameterType="int" resultType="NNnnNNNNNN" >
select * from user where id = #{id}
</select>
<!---通过账号密码,查找用户信息-->
<select id="findByUsernameAndPassword" parameterType="map" resultType="YYYYYYYYY">
SELECT * FROM user WHERE username = #{username} and password = #{password}
</select>
</mapper>
我使用了缓存的近期最少使用算法。在查询的时候,第二次会从缓存中获取