使用spring-data-redis对redis进行操作

布满荆棘的人生 2022-05-09 08:40 247阅读 0赞

前面介绍了Redis的安装配置，今天我将介绍通过spring-data-redis实现java程序对redis进行操作。对于redis的介绍我就不细说，在我们写程序的时候就是要构建好我们的key-value对，然后利用spring-data-redis将我们构建好的key-value保存到redis中。  
spring-data-redis官方提供了很多种应用方式：与spring cache集成、redis持久化等等，我这里只简单做一个事情利用spring-data-redis将数据存储到redis服务器，然后再从redis服务器取回我保存的数据。  
开始开发前需要介绍一下，spring-data-redis与redis之间的数据交互需要经历序列化/反序列化操作（key-value都会进行序列化操作），应用向redis发送的数据需要经历序列化操作才能保存，从redis取回来的数据需要经历反序列化操作才能得到我们想要的结果。因此如果我们要缓存对象到redis中的话该对象需要实现Serializable接口。  
spring-data-redis提供了多种序列化的方式，String、JDK、Jackson等，根据网上的推荐结合我自己的实际情况建议key采用StringRedisSerializer序列化方式，value采用Jackson2JsonRedisSerializer序列化方式。下面我们来开始代码阶段  
环境：

> spring boot 2

\#\#spring-data-redis配置  
首先是在applications.config配置文件添加redis的配置信息，spring2.0开始使用Lettuce作为默认的redis连接工具，因此我这里也使用这个连接redis。

spring.redis.host=url
    spring.redis.port=6379
    spring.redis.password=password
    # 连接超时时间（毫秒）
    spring.redis.timeout=10000
    # Redis默认情况下有16个分片，这里配置具体使用的分片，默认是0
    spring.redis.database=0
    # 连接池最大连接数（使用负值表示没有限制） 默认 8
    spring.redis.lettuce.pool.max-active=8
    # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
    spring.redis.lettuce.pool.max-wait=-1
    # 连接池中的最大空闲连接 默认 8
    spring.redis.lettuce.pool.max-idle=8
    # 连接池中的最小空闲连接 默认 0
    spring.redis.lettuce.pool.min-idle=0

下面我们再创建一个类RedisConfiguration

@Configuration
    public class RedisConfiguration {
    
        @Bean(name = "redisTemplate")
        public RedisTemplate<String, Object> redisCacheTemplate(LettuceConnectionFactory redisConnectionFactory) {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new
                    Jackson2JsonRedisSerializer<Object>(Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
            template.setKeySerializer(new StringRedisSerializer());
            template.setHashKeySerializer(new StringRedisSerializer());
            template.setValueSerializer(jackson2JsonRedisSerializer);
            template.setHashValueSerializer(jackson2JsonRedisSerializer);
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    }

这里我们配置了一个redisTemplate来对redis进行操作，这里看到了我配置的序列化方式key用的String，value用的Jackson  
\#\#写一个工具类  
spring-data-redis提供的是一系列的api所以呢为了方便我们还是写个工具类吧，我这里的也是从网上找的一个进行了一些修改

@Component
    public class RedisCommonUtil<T> {
    
        private RedisTemplate<String, T> redisTemplate;
    
        @Autowired
        public RedisCommonUtil(RedisTemplate<String, T> redisTemplate) {
            this.redisTemplate = redisTemplate;
        }
    
    
        //============================String=============================
    
        /**
         * 普通缓存获取
         *
         * @param key 键
         * @return 值
         */
        public T getCache(String key) {
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存放入
         *
         * @param key   键
         * @param value 值
         * @return true成功 false失败
         */
        public boolean setCache(String key, T value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
    
        }
    
        /**
         * 普通缓存放入并设置时间
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
        public boolean setCache(String key, T value, long time) {
            try {
                if (time > 0) {
                    redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                } else {
                    setCache(key, value);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        /**
         * HashGet
         *
         * @param key  键 不能为null
         * @param item 项 不能为null
         * @return 值
         */
        public Object getHashCache(String key, String item) {
            return redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 获取hashKey对应的所有键值
         *
         * @param key 键
         * @return 对应的多个键值
         */
        public Map<Object, Object> getHashCache(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * HashSet
         *
         * @param key 键
         * @param map 对应多个键值
         * @return true 成功 false 失败
         */
        public boolean setHashCache(String key, Map<String, T> map) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * HashSet 并设置时间
         *
         * @param key  键
         * @param map  对应多个键值
         * @param time 时间(秒)
         * @return true成功 false失败
         */
        public boolean setHashCache(String key, Map<String, T> map, long time) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                if (time > 0) {
                    setExpireTime(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @return true 成功 false失败
         */
        public boolean setHashCache(String key, String item, T value) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param hashKey  项
         * @param value 值
         * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
         * @return true 成功 false失败
         */
        public boolean setHashCache(String key, String hashKey, T value, long time) {
            try {
                redisTemplate.opsForHash().put(key, hashKey, value);
                if (time > 0) {
                    setExpireTime(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }

因为方法实在太多我就简单列举了下我这里用到的方法，具体的可以看我github上的代码

\#\#字符串数据的操作  
字符串操作就非常简单了直接上代码

@Test
        public void stringRedisTest() {
            String key = "key1";
            String value = "key1_value";
            redisCommonUtil.setCache(key, value);
            String value1 = redisCommonUtil.getCache(key);
            System.out.println(value1);
        }

首先我们把数据存到redis中，然后再从redis中取回那条数据并打印出来，如果跟设置的没有问题说明成功。  
\#\#实体对象操作  
首先我们要设置一下实体对象

@Entity
    @Table(name = "user")
    @XmlRootElement(name = "user")
    @XmlType(propOrder = {"userid", "username", "userpwd", "realname"})
    public class UserEntity implements Serializable {
    
    
        private String userid;
        private String username;
        private String userpwd;
        private String realname;
    
        public static final String USERENTITY_KEY = "UserEntity";
    
        @Id
        @Column(name = "userid", nullable = false, length = 50)
        @XmlElement(name = "userid")
        public String getUserid() {
            return userid;
        }
    
        public void setUserid(String userid) {
            this.userid = userid;
        }
    
        @Basic
        @Column(name = "username", nullable = false, length = 50)
        @XmlElement(name = "username")
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        @Basic
        @Column(name = "userpwd", nullable = false, length = 50)
        @XmlElement(name = "userpwd")
        public String getUserpwd() {
            return userpwd;
        }
    
        public void setUserpwd(String userpwd) {
            this.userpwd = userpwd;
        }
    
        @Basic
        @Column(name = "realname", nullable = true, length = 200)
        @XmlElement(name = "realname")
        public String getRealname() {
            return realname;
        }
    
        public void setRealname(String realname) {
            this.realname = realname;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            UserEntity that = (UserEntity) o;
            return Objects.equals(userid, that.userid) &&
                    Objects.equals(username, that.username) &&
                    Objects.equals(userpwd, that.userpwd) &&
                    Objects.equals(realname, that.realname);
        }
    
        @Override
        public int hashCode() {
    
            return Objects.hash(userid, username, userpwd, realname);
        }
    }

可以看到实体对象中我设置了一个key，USERENTITY\_KEY = "UserEntity"这个key在下面会派上用场

@Test
        public void objectRedisTest() {
            UserEntity user = new UserEntity();
            user.setUserid("a01");
            user.setUserpwd("123456");
            user.setUsername("a001");
            user.setRealname("测试名称");
            redisCommonUtil1.setHashCache(UserEntity.USERENTITY_KEY, user.getUserid(), user);
            Object user1=redisCommonUtil1.getHashCache(UserEntity.USERENTITY_KEY,user.getUserid());
            if(user1!=null){
                UserEntity user2=(UserEntity) user1;
                System.out.println(user2.getUserid());
                System.out.println(user2.getUserpwd());
                System.out.println(user2.getUsername());
                System.out.println(user2.getRealname());
            }
        }

从测试代码可以看出来我在redis中用的hash这个类型来保存的用户对象，USERENTITY\_KEY作为key，UserId作为hashKey。  
这样就完成了一个简单的利用spring-data-redis对redis的操作，详细代码参见[spring][]，只需要按照你自己的redis环境修改一下host、port、password就能直接运行代码。如果对spring-data-redis有更详细的需求请参见spring-data-redis官网，[spring-data-redis][]

[spring]: https://github.com/jackycheng86/spring
[spring-data-redis]: https://docs.spring.io/spring-data/redis/docs/2.0.10.RELEASE/reference/html/