redis做缓存的简单实例

最新推荐文章于 2024-09-29 00:04:20 发布

美好的未来在于把握今天

最新推荐文章于 2024-09-29 00:04:20 发布

阅读量373

点赞数

分类专栏： Redis 文章标签： Redis

Redis 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

由于之前对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.clients</groupId>  
                <artifactId>jedis</artifactId>  
                <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 的依赖注入。

<!-- jedis 连接池配置参数：  -->  
        <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>  
        <!-- jedis 连接池  连接本地redis服务 构造器注入-->  
        <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>  
        <!-- cleint-->  
        <bean id="redisClient" class="com.deppon.cache.redis.RedisClient">  
            <property name="pool" ref="pool"/>  
        </bean>

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

存储器接口：

/** 
 *  
 * @author leo 
 *缓存存储接口 
 * @param <K> key 
 * @param <V> value 
 */  
public interface RedisCacheStorage<K, V> {  
    /** 
     * 在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<K,V> hget(String cacheKey);

以及存储实现类：

/** 
 * redis 缓存存储器实现 
 * @author leo 
 * 
 * @param <V> 
 */  
public class RedisCacheStorageImpl<V> implements RedisCacheStorage<String, V> {  
    /** 
     * 日志记录 
     */  
    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<String, V> hget(String cacheKey) {  
        String jCacheKey =CacheUtils.toJsonString(cacheKey);  
        //非空校验  
        if(StringUtils.isEmpty(jCacheKey)){  
            LOG.info("cacheKey is empty!");  
            return null;  
        }  
        Jedis jedis =null;  
        Map<String,V> result =null;  
        try {  
            jedis =redisClient.getResource();  
            //获取列表集合  
            Map<String,String> map = jedis.hgetAll(jCacheKey);   
              
            if(null !=map){  
                for(Map.Entry<String, String> entry : map.entrySet()){  
                    if(result ==null){  
                        result =new HashMap<String,V>();  
                    }  
                    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<UserEntity> storageCache;  
      
    public void setStorageCache(RedisCacheStorageImpl<UserEntity> 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的配置对业务层的管理：

<!-- storge Cache 存储器-->  
        <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就这样了