redis做缓存的demo

由于之前对redis有了一个系统的研究，在公司的多个项目中使用redis当做数据缓存；所以趁着这些天晚上的时间，自己写了一个demo；这里仅供自己后期学习笔记参考，若有不对的地方，请轻拍砖！

redis 官网推荐给java 使用的客户端很多：Jedis、Redisson、JRedis、JDBC-Redis 等，当然首推是jedis；可以参考redis客户端官网查看。

接下来来讲下我的这个demo，我这个案例不是通过spring进行整合的redis，这个将会在之后的demo中讲到的。

(1).创建一个maven 功臣，在工程的pom 中引入jedis客户端；还有要依赖spring管理，所以也要引入spring相关jar包。

 <span style="white-space:pre">        span><dependency>
                 <groupId>redis.clientsgroupId>
                 <artifactId>jedisartifactId>
                 <version>${jedis-version}version>
             dependency>
         <dependency>

(2).一般一个（系统）项目所用的redis服务器 多节点的集群服务器，所以会自己对（jedis）redis客户端进行封装，由于本例我自己写的是单节点，但是我还是按多节点的思路对客户端进行了封装。

redisClient类

 /**
  * redis 客户端封装
  * @author leo
  *
  */
 public class RedisClient  {
     /**
      * 日志记录
      */
     private static final Log LOG = LogFactory.getLog(RedisClient.class);
     /**
      * redis 连接池
      */
     private JedisPool pool;

     public void setPool(JedisPool pool) {
         this.pool = pool;
     }
     /**
      * 获取jedis
      * @return
      */
     public Jedis getResource(){
         Jedis jedis =null;
         try {
             jedis =pool.getResource();
         } catch (Exception e) {
             LOG.info("can't  get  the redis resource");
         }
         return jedis;
     }
     /**
      * 关闭连接
      * @param jedis
      */
     public void disconnect(Jedis jedis){
         jedis.disconnect();
     }
     /**
      * 将jedis 返还连接池
      * @param jedis
      */
     public void returnResource(Jedis jedis){
         if(null != jedis){
             try {
                 pool.returnResource(jedis);
             } catch (Exception e) {
                 LOG.info("can't return jedis to jedisPool");
             }
         }
     }
     /**
      * 无法返还jedispool，释放jedis客户端对象，
      * @param jedis
      */
     public void brokenResource(Jedis jedis){
         if (jedis!=null) {
             try {
                 pool.returnBrokenResource(jedis);
             } catch (Exception e) {
                 LOG.info("can't release jedis Object");
             }
         }
     }
 }

然后 通过spring的bean.xml 来管理 连接池，和连接池参数配置，以及redisClient 的依赖注入。

         <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
             <property name="maxActive" value="100">property>
             <property name="maxIdle" value="25">property>
             <property name="maxWait" value="15000">property>
             <property name="testOnBorrow" value="false">property>
             <property name="testOnReturn" value="false">property>
         bean>

         <bean id="pool" class="redis.clients.jedis.JedisPool">
             <constructor-arg index="0"  ref="poolConfig"/>
             <constructor-arg index="1" value="10.224.68.46"/>
             <constructor-arg index="2" value="6379"/>
             <constructor-arg index="3" value="2000"/>
         bean>

         <bean id="redisClient" class="com.deppon.cache.redis.RedisClient">
             <property name="pool" ref="pool"/>
         bean>

(3).创建好redisClient 之后，我要创造一个存储器，即一个对redis操作的工具容器。由于是公共容器，所以我创建接口是的容器接口就不该是封闭的，应该是开封的，保证存入数据库中对象类型的多态性。

存储器接口：

 /**
  *
  * @author leo
  *缓存存储接口
  * @param  key
  * @param  value
  */
 public interface RedisCacheStorage {
     /**
      * 在redis数据库中插入 key  和value
      * @param key
      * @param value
      * @return
      */
     boolean set(K key,V value);
     /**
      * 在redis数据库中插入 key  和value 并且设置过期时间
      * @param key
      * @param value
      * @param exp 过期时间 s
      * @return
      */
     boolean set(K key, V value, int exp);
     /**
      * 根据key 去redis 中获取value
      * @param key
      * @return
      */
     V get(K key);
     /**
      * 删除redis库中的数据
      * @param key
      * @return
      */
     boolean remove(K key);
     /**
      * 设置哈希类型数据到redis 数据库
      * @param cacheKey 可以看做一张表
      * @param key   表字段
      * @param value
      * @return
      */
     boolean hset(String cacheKey,K key,V value);
     /**
      * 获取哈希表数据类型的值
      * @param cacheKey
      * @param key
      * @return
      */
     V hget(String cacheKey,K key);
     /**
      * 获取哈希类型的数据
      * @param cacheKey
      * @return
      */
     Map hget(String cacheKey);

以及存储实现类：

 /**
  * redis 缓存存储器实现
  * @author leo
  *
  * @param
  */
 public class RedisCacheStorageImpl implements RedisCacheStorage {
     /**
      * 日志记录
      */
     public static final Log LOG = LogFactory.getLog(RedisCacheStorageImpl.class);
     /**
      * redis 客户端
      */
     private RedisClient redisClient;
     /**
      * 默认过时时间
      */
     private static final int EXPRIE_TIME =3600*24;

     public void setRedisClient(RedisClient redisClient) {
         this.redisClient = redisClient;
     }
     /**
      * 在redis数据库中插入 key  和value
      * @param key
      * @param value
      * @return
      */
     @Override
     public boolean set(String key, V value) {
         //设置默认过时时间
         return set(key, value, EXPRIE_TIME);
     }
     /**
      * 在redis数据库中插入 key  和value 并且设置过期时间
      * @param key
      * @param value
      * @param exp 过期时间 s
      * @return
      */
     @SuppressWarnings("finally")
     @Override
     public boolean set(String key, V value, int exp) {
         Jedis jedis =null;
         //将key 和value  转换成 json 对象
         String jKey =CacheUtils.toJsonString(key);
         String jValue =CacheUtils.toJsonString(value);
         //操作是否成功
         boolean isSucess =true;
         if(StringUtils.isNotEmpty(jKey)){
             LOG.info("key is empty");
             return false;
         }
         try {
             //获取客户端对象
             jedis =redisClient.getResource();
             //执行插入
             jedis.setex(jKey, exp, jValue);
         } catch (JedisException e) {
             LOG.info("client can't connect server");
             isSucess =false;
             if(null !=jedis){
                 //释放jedis对象
                 redisClient.brokenResource(jedis);
             }
             return false;
         }finally{
             if(isSucess){
                 //返还连接池
                 redisClient.returnResource(jedis);
             }
             return true;
         }
     }
     /**
      * 根据key 去redis 中获取value
      * @param key
      * @return
      */
     @SuppressWarnings("unchecked")
     @Override
     public V get(String key) {
         Jedis jedis =null;
         //将key 和value  转换成 json 对象
         String jKey =CacheUtils.toJsonString(key);
         V jValue =null;
         //key 不能为空
         if(StringUtils.isEmpty(jKey)){
             LOG.info("key is empty");
             return null;
         }
         try {
             //获取客户端对象
             jedis =redisClient.getResource();
             //执行查询
             String value =  jedis.get(jKey);
             //判断值是否非空
             if(StringUtils.isEmpty(value)){
                 return null;
             }else{
                 jValue= (V) CacheUtils.jsonParseObject(value);
             }
             //返还连接池
             redisClient.returnResource(jedis);
         } catch (JedisException e) {
             LOG.info("client can't connect server");
             if(null !=jedis){
                 //释放jedis 对象
                 redisClient.brokenResource(jedis);
             }
         }
         return jValue;
     }
     /**
      * 删除redis库中的数据
      * @param key
      * @return
      */
     @SuppressWarnings("finally")
     @Override
     public boolean remove(String key) {
         Jedis jedis =null;
         //将key 和value  转换成 json 对象
         String jKey =CacheUtils.toJsonString(key);
         //操作是否成功
         boolean isSucess =true;
         if(StringUtils.isEmpty(jKey)){
             LOG.info("key is empty");
             return false;
         }
         try {
             jedis =redisClient.getResource();
             //执行删除
             jedis.del(jKey);
         } catch (JedisException e) {
             LOG.info("client can't connect server");
             isSucess =false;
             if(null !=jedis){
                 //释放jedis 对象
                 redisClient.brokenResource(jedis);
             }
             return false;
         }finally{
             if (isSucess) {
                 //返还连接池
                 redisClient.returnResource(jedis);
             }
             return true;
         }
     }
     /**
      * 设置哈希类型数据到redis 数据库
      * @param cacheKey 可以看做一张表
      * @param key   表字段
      * @param value
      * @return
      */
     @SuppressWarnings("finally")
     @Override
     public boolean hset(String cacheKey, String key, V value) {
         Jedis jedis =null;
         //将key 和value  转换成 json 对象
         String jKey =CacheUtils.toJsonString(key);
         String jCacheKey =CacheUtils.toJsonString(cacheKey);
         String jValue =CacheUtils.toJsonString(value);
         //操作是否成功
         boolean isSucess =true;
         if(StringUtils.isEmpty(jCacheKey)){
             LOG.info("cacheKey is empty");
             return false;
         }
         try {
             jedis =redisClient.getResource();
             //执行插入哈希
             jedis.hset(jCacheKey, jKey, jValue);
         } catch (JedisException e) {
             LOG.info("client can't connect server");
             isSucess =false;
             if(null !=jedis){
                 //释放jedis 对象
                 redisClient.brokenResource(jedis);
             }
             return false;
         }finally{
             if (isSucess) {
                 //返还连接池
                 redisClient.returnResource(jedis);
             }
             return true;
         }
     }
     /**
      * 获取哈希表数据类型的值
      * @param cacheKey
      * @param key
      * @return
      */
     @SuppressWarnings("unchecked")
     @Override
     public V hget(String cacheKey, String key) {
         Jedis jedis =null;
         //将key 和value  转换成 json 对象
         String jKey =CacheUtils.toJsonString(key);
         String jCacheKey =CacheUtils.toJsonString(cacheKey);
         V jValue =null;
         if(StringUtils.isEmpty(jCacheKey)){
             LOG.info("cacheKey is empty");
             return null;
         }
         try {
             //获取客户端对象
             jedis =redisClient.getResource();
             //执行查询
             String value =  jedis.hget(jCacheKey, jKey);
             //判断值是否非空
             if(StringUtils.isEmpty(value)){
                 return null;
             }else{
                 jValue= (V) CacheUtils.jsonParseObject(value);
             }
             //返还连接池
             redisClient.returnResource(jedis);
         } catch (JedisException e) {
             LOG.info("client can't connect server");
             if(null !=jedis){
                 //释放jedis 对象
                 redisClient.brokenResource(jedis);
             }
         }
         return jValue;
     }
     /**
      * 获取哈希类型的数据
      * @param cacheKey
      * @return
      */
     @Override
     public Map hget(String cacheKey) {
         String jCacheKey =CacheUtils.toJsonString(cacheKey);
         //非空校验
         if(StringUtils.isEmpty(jCacheKey)){
             LOG.info("cacheKey is empty!");
             return null;
         }
         Jedis jedis =null;
         Map result =null;
         try {
             jedis =redisClient.getResource();
             //获取列表集合
             Map map = jedis.hgetAll(jCacheKey);

             if(null !=map){
                 for(Map.Entry entry : map.entrySet()){
                     if(result ==null){
                         result =new HashMap();
                     }
                     result.put((String) CacheUtils.jsonParseObject(entry.getKey()), (V)CacheUtils.jsonParseObject(entry.getValue()));
                 }
             }
         } catch (JedisException e) {
             LOG.info("client can't connect server");
             if(null !=jedis){
                 //释放jedis 对象
                 redisClient.brokenResource(jedis);
             }
         }
         return result;
     }

 }

（4），接下来要把写个具体的业务UserService，来测试redis的存储器在具体业务中的使用，即实现（非关系型数据库的持久化操作）。本例中的例子是经常项目中对user的操作

创建UserEntity实体类：

 /**
  * 用户实体类
  * @author leo
  *
  */
 public class UserEntity {
     //用户id
     private String userId;
     //用户账号
     private String EmpCode;
     //用户名称
     private String EmpName;
     //用户角色
     private String role;
     //职位
     private String title;
     public String getUserId() {
         return userId;
     }
     public void setUserId(String userId) {
         this.userId = userId;
     }
     public String getEmpCode() {
         return EmpCode;
     }
     public void setEmpCode(String empCode) {
         EmpCode = empCode;
     }
     public String getEmpName() {
         return EmpName;
     }
     public void setEmpName(String empName) {
         EmpName = empName;
     }
     public String getRole() {
         return role;
     }
     public void setRole(String role) {
         this.role = role;
     }
     public String getTitle() {
         return title;
     }
     public void setTitle(String title) {
         this.title = title;
     }

然后创建用户操作的业务层Service；由于这里主要是测试NOSQL的数据持久化，所以就忽略了对数据库持久化层（DAO）的操作。

userServiceImpl类：

 /**
  * 业务层接口实现
  * @author leo
  *
  */
 public class UserServiceImpl implements IUserService {
     private static final String  cacheKey  ="userEntity";
     /**
      * 缓存存储
      */
     private RedisCacheStorageImpl storageCache;

     public void setStorageCache(RedisCacheStorageImpl storageCache) {
         this.storageCache = storageCache;
     }
     /**
      * 新增
      * @param entity
      * @return
      */
     @Override
     public boolean addUserEntity(UserEntity entity) {
         //非空
         if(entity ==null || StringUtils.isEmpty(entity.getUserId())){
             return false;
         }
         /**
          * 做数据库持久化，这里就无需再申明了
          */
         System.out.println("先插入数据库中,.........");
         //然后接下来做非关系型数据库持久化
         return storageCache.hset(cacheKey, entity.getUserId(), entity);
     }

     @Override
     public boolean deleteUserEntity(UserEntity entity) {

         return false;
     }
     /**
      * 根据id 查询
      * @return
      */
     @Override
     public UserEntity queryUserEntityByUserId(UserEntity userEntity) {
         //非空
         if(userEntity ==null || StringUtils.isEmpty(userEntity.getUserId())){
             return null;
         }
         //先去缓存中查询 是否存在，不存在在查询
          UserEntity reslut = storageCache.hget(cacheKey, userEntity.getUserId());
         if(reslut!=null){
             return reslut;
         }else{
             //查询数据库
             System.out.println("查询数据库");
         }
         return null;
     }

 }

以及spring-bean.xml的配置对业务层的管理：

         <bean id="storageCache" class="com.deppon.cache.storage.impl.RedisCacheStorageImpl">
             <property name="redisClient" ref="redisClient" />
         bean>
         <bean id="userServiceImpl" class="com.deppon.cache.service.impl.UserServiceImpl">
             <property name="storageCache" ref="storageCache"/>
         bean>

(6).最后写个junit 测下，查看是否有没有插入到redis库中

 public class TestUserServiceImpl {
     /**
      * 用户接口
      */
     private IUserService userServiceImpl;

     public void setUserServiceImpl(IUserService userServiceImpl) {
         this.userServiceImpl = userServiceImpl;
     }
     @Before
     public void setUp() throws Exception {
         userServiceImpl = (IUserService) SpringTestHelper.get().getBeanByClass(UserServiceImpl.class);
     }

     @After
     public void tearDown() throws Exception {
     }
     @Test
     public void testAdd(){
         UserEntity entity = new UserEntity();
         entity.setUserId("000001");
         entity.setEmpCode("130566");
         entity.setEmpName("leonardo-zeng");
         entity.setRole("Java Development Engineer");
         entity.setTitle("PM");
         boolean isTrue =userServiceImpl.addUserEntity(entity);
         Assert.assertTrue(isTrue);
     }

     @Test
     public void testQueryById(){
         UserEntity entity = new UserEntity();
         entity.setUserId("000001");
         UserEntity userEntity =userServiceImpl.queryUserEntityByUserId(entity);
         System.out.println(userEntity);
     }
 }

连接redis库，查询出来的确值在库中存在

redis 127.0.0.1:6379> hkeys "\"userEntity\""
1) "\"000001\""
redis 127.0.0.1:6379> hget "\"userEntity\"" "\"000001\""
"{\"@type\":\"com.deppon.cache.entity.UserEntity\",\"empCode\":\"130566\",\"empN
ame\":\"leonardo-zeng\",\"role\":\"Java Development Engineer\",\"title\":\"PM\",
\"userId\":\"000001\"}"
redis 127.0.0.1:6379>
整个demo就这样了

本文转载自 http://blog.csdn.net/leonardo9029/article/details/42550423