使用redis的缓存功能

摘要: 应用redis

在项目中，实现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>

我使用了缓存的近期最少使用算法。在查询的时候，第二次会从缓存中获取