Java对Redis的简单封装

拼搏现实的明天。 2024-04-18 10:50 56阅读 0赞

### Java对Redis的简单封装 ###

相关文章:  
[Linux安装Redis][Linux_Redis]  
[SpringBoot连接Redis][SpringBoot_Redis]  
[Redis常见问题][Redis]  
[Redis实现主从复制][Redis 1]

封装说明:

项目中对于Redis的简单封装,仅供参考学习使用,不完全保证生产环境中不会出现问题

方法汇总:

*  存储对象,不设置过期时间
 *  存储对象,设置过期时间
 *  获取对象
 *  判断Key是否存在
 *  值自增
 *  值自减
 *  Redis 充当分布式锁
 *  释放锁
 *  Redis存放Hash
 *  获取hash值
 *  刷新过期时间

完整代码如下:

package com.xcx.cache.common;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.connection.RedisStringCommands;
    import org.springframework.data.redis.connection.ReturnType;
    import org.springframework.data.redis.core.RedisCallback;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.types.Expiration;
    import org.springframework.stereotype.Service;
    
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.TimeUnit;
    
    
    /** * @Auther: chenlong * @Date: 2018/9/16 14:22 * @Description:封装Redis */
    @Service
    public class RedisCache { 
        @Autowired
        private RedisTemplate<Object, Object> redisTemplate;
    
        //日志
        private Logger logger = LoggerFactory.getLogger(RedisCache.class);
    
        //维护获取锁的线程是否释放锁
        private Map<String, Boolean> map = new ConcurrentHashMap<>();
    
        //是否启用缓存,可用配置文件
        private boolean isCancel = false;
    
    
        /** * 存储对象,不设置过期时间 * * @param key * @param val */
        public void setObj(String key, Object val) { 
            if (isCancel)
                return;
            try { 
                redisTemplate.opsForValue().set(key, val);
            } catch (Exception e) { 
                logger.info("set opsForValue error" + e);
            }
    
        }
    
        /** * 存储对象,设置过期时间 * * @param key * @param value * @param time */
        public void setObj(String key, String value, long time) { 
            if (isCancel)
                return;
            try { 
                redisTemplate.opsForValue().set(key, value);
                redisTemplate.expire(key, time, TimeUnit.MINUTES);
            } catch (Exception e) { 
                logger.info("set opsForValue error" + e);
            }
        }
    
        /** * 获取对象 * * @param key * @return */
        public Object getObj(String key) { 
            if (isCancel)
                return null;
            if (!containKey(key))
                return null;
            Object o = redisTemplate.opsForValue().get(key);
            return o;
        }
    
        /** * 判断Key 是否存在 * * @param key * @return */
        public boolean containKey(String key) { 
            return redisTemplate.hasKey(key);
        }
    
        /** * 值自增 * * @param key * @return */
        public long inc(String key) { 
            redisTemplate.hasKey(key);
            long num = redisTemplate.opsForValue().increment(key);
            return num;
        }
    
        /** * 值自减 * * @param key * @return */
        public long dec(String key) { 
            long num = redisTemplate.opsForValue().decrement(key);
            return num;
        }
    
        public void delKey(String key) { 
            if (containKey(key))
                redisTemplate.delete(key);
        }
    
        /** * Redis 充当分布式锁，uuid是释放锁时用 * * @param key * @param expire */
        public boolean lock(String key, long expire, String uuid) { 
    
            return (Boolean) redisTemplate.execute((RedisCallback) conn -> { 
                Boolean result = conn.set(key.getBytes(), uuid.getBytes(), Expiration.from(expire, TimeUnit.SECONDS), RedisStringCommands.SetOption.SET_IF_ABSENT);
                return result;
    
            });
        }
    
    
        /** * 释放锁,使用Lua语言来确保解锁操作是原子性的 * * @param key * @return */
        public Boolean release(String key, String uuid) { 
            return (Boolean) redisTemplate.execute((RedisCallback) conn -> { 
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                Boolean result = conn.eval(script.getBytes(), ReturnType.BOOLEAN, 1, key.getBytes(), uuid.getBytes());
                return result;
            });
        }
    
        /** * Redis存放Hash * * @param key * @param map */
        public void setHash(String key, Map map) { 
            if (isCancel)
                return;
            redisTemplate.opsForHash().putAll(key, map);
            //10分钟有效
            redisTemplate.expire(key, 5, TimeUnit.MINUTES);
        }
    
        /** * 获取hash值 * * @param hashKey * @param mapKey * @return */
    
        public Object getHash(String hashKey, String mapKey) { 
            if (isCancel)
                return null;
            if (!containKey(hashKey))
                return null;
            Object o;
            Map map = redisTemplate.opsForHash().entries(hashKey);
            o = map.get(mapKey);
            return o;
        }
    
        /** * 刷新过期时间 * * @param key * @param time */
        public void refKey(String key, long time) { 
            redisTemplate.expire(key, time, TimeUnit.MINUTES);
        }
    
    
    }

[Linux_Redis]: http://www.study-java.cn/#/article?id=104
[SpringBoot_Redis]: http://www.study-java.cn/#/article?id=105
[Redis]: http://www.study-java.cn/#/article?id=75
[Redis 1]: http://www.study-java.cn/#/article?id=107