Redis应用（8）——Redis的项目应用：结合SpringBoot如何在Redis里面存对象 & RedisUtil工具类的封装 & 遇到的问题

前言

Redis作为一款优秀的开源、高效的内存数据库，在各种项目中都能见到其身影，熟练使用Redis是程序员必备的技能之一。本系列博客结合应用场景，阐述Redis从安装到使用的，从入门到进阶的相关内容。

本篇博客介绍在Spring项目中，如何往Redis里面存Java对象，以及使用中遇到的问题。

其他相关的Redis的博客如下：

Redis是啥 & 安装Docker的Redis & Redis的基本数据类型+常用命令 & SpringBoot整合Redis初步

结合redis.conf配置文件深入理解 Redis两种数据持久化方案：RDB和AOF

Redis数据的持久化 & CAP分布式理论（高可用性） & Redis主从搭建 & Redis的哨兵机制

在Linux上基于Docker容器Redis搭建一主二从三哨兵 & SpringBoot整合Redis哨兵

认识redis未授权访问漏洞 & 漏洞的部分复现 & 设置连接密码 & redis其他命令学习

Redis的项目应用（一）：验证码 —＞ UUID到雪花ID & JMeter高并发测试 & 下载安装使用

Redis的项目应用（二）：抢购图书 —＞ Redis高并发的问题 & 分布式锁Redission的使用

Redis的项目应用（三）：抢购图书2.0 —＞ Lua脚本 & Redis+Lua+Redission实现抢购 & Redission锁

Redis的项目应用（四）：缓存预热，用户注册为例 —＞注册的流程 & 缓存预热的方式，quartz方式 / @Schedule方式

Redis的项目应用（五）：缓存自动更新 —＞Canal管道 & MySQL配置+安装canal & 入门案例 & Canal的项目应用

Redis的项目应用（六）：布隆过滤器—白名单 ----＞ Reids的问题，雪崩/ 击穿 / 穿透【重要】& 布隆过滤器

Redis数据一致性 & 用Java代码加锁解决一致性 & 采用lua脚本实现减1的原子性 & 分布式环境下的setnex锁及其问题 & Redission框架的使用

IDEA启动两个Tomcat服务的方式 & 使用nginx进行反向代理 & JMeter测试分布式情况下synchronized锁失效

引出

---

1.之前的Redis相关博客的汇总；
2.redis里面存java对象的解决方案；
3.在实际使用中遇到的问题及处理；

如何在redis里面存java对象

1.本文的项目依赖

使用的是最基础的springboot的redis依赖

由于代码中用了布隆过滤器，因此这里引用了hutool工具包

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>


        <dependency>
            <groupId>cn.hutoolgroupId>
            <artifactId>hutool-allartifactId>
            <version>5.8.11version>
        dependency>
1
2
3
4
5
6
7
8
9
10
11
12

2.核心配置类

核心是存对象的Redistemplate配置，

还包括了Redisson的配置，lua脚本的配置。

package com.tianju.fresh.config;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.springframework.context.annotation.Bean;
import org.redisson.config.Config;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;


/**
 * Redisson的配置，lua脚本的配置，redis序列化存对象的配置
 */
@Configuration
public class RedisConfig {

    /**
     * Redisson的配置，
     * Redisson框架，分布式环境下redis数据一致性
     * @return
     */
    @Bean
    public RedissonClient redissonClient(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379")
                .setPassword("5672");
        return Redisson.create(config);
    }

    /**
     * lua脚本的配置类，让减库存-1操作原子化
     * @return
     */
    @Bean
    public RedisScript<Long> redisScript(){
        DefaultRedisScript redisScript = new DefaultRedisScript<>();
        redisScript.setResultType(Long.class);
        // lua脚本的位置
        redisScript.setLocation(
                new ClassPathResource("/lua/goods-unstock.lua") // 关联lua脚本
        );
        return redisScript;
    }

    /**
     * redis序列化的相关配置，可以存对象
     * @return
     */
    @Bean
    public RedisTemplate redisTemplateInit(RedisConnectionFactory redisConnectionFactory) {

        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();

        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置序列化Key的实例化对象
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置序列化Value的实例化对象
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        /**
         *
         * 设置Hash类型存储时，对象序列化报错解决
         */
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

3.封装RedisUtil工具类

在实际应用redis中形成的自定义的Redis工具类，主要把Redistemplate 和 StringRedistemplate 依赖注入，然后调用这两个的方法；

其中Redistemplate 用来存java对象，而StringRedistemplate 用于普通的操作；

package com.tianju.fresh.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Set;
import java.util.concurrent.TimeUnit;


@Component
public class RedisUtil {
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public void  saveObjectToRedis(String key,Object json){
        redisTemplate.opsForValue().set(key,json);
    }

    /**
     * 从redis里面获取json对象，如果没有，返回null
     * @param key
     * @return
     */
    public Object getJsonFromRedis(String key){
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 删除redis里面的值，键
     * @param key 删除的键
     * @return
     */
    public Boolean deleteKey(String key){
        return redisTemplate.delete(key);
    }

    /**
     * 存到Redis里面的 set 中
     * @param key 存的键
     * @param value 存到set的值
     */
    public void saveSetToRedis(String key,String... value){
        for (String s:value){
            if (s!=null && !s.equals("")){
                stringRedisTemplate.opsForSet().add(key, s);
            }
        }
    }

    /**
     * 判断是否在redis的set中
     * @param key
     * @param val
     * @return
     */
    public Boolean isInSet(String key,String val){
        return stringRedisTemplate.opsForSet().isMember(key, val);
    }

    /**
     * 获得set中的值
     * @param key 键
     * @return
     */
    public Set<String> getSet(String key){
        return stringRedisTemplate.opsForSet().members(key);
    }

    /**
     * 从redis里面的set删除数据
     * @param key
     * @param val
     */
    public void removeFromSet(String key,String val){
        stringRedisTemplate.opsForSet().remove(key, val);
    }



    /**
     * 获得存到redis里面的键对应的string类型的值
     * @param key 键
     * @return
     */
    public String getStringValue(String key){
        return stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * 保存到redis里面string
     * @param key
     * @param timeout 过期时间，传的是多少s之后过期
     * @param val
     */
    public void saveStringValue(String key,String val,Integer... timeout){
        if (timeout==null){
            stringRedisTemplate.opsForValue().set(key,val);
        }else {
            stringRedisTemplate.opsForValue().set(key,val,timeout[0], TimeUnit.SECONDS);
        }
    }

    /**
     * 看某个键是否存在于Redis中
     * @param key 待检验的键
     * @return
     */
    public Boolean isKeyInRedis(String key){
        return stringRedisTemplate.hasKey(key);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

4.工具类的使用

下面以一个缓存预热的代码为例，使用工具类时依赖注入，然后调用工具类里面的方法

package com.tianju.fresh.autho.bloomFilter;

import com.tianju.fresh.entity.Customer;
import com.tianju.fresh.mapper.CustomerMapper;
import com.tianju.fresh.util.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 将用户名，手机号码，邮箱存到redis里面，
 * 作用：
 * 1.登陆的时候先到redis里面查询；
 * 2.用户注册的时候先从redis里面看用户名是否重复
 */
@Component
@Slf4j
public class LoginKeyPreHot {

    private final String LOGIN_KEY = "loginKey";

    @Autowired
    private CustomerMapper customerMapper;

    @Autowired
    private RedisUtil redisUtil;

    /**
     * 每天半夜 2点 跟新布隆过滤器和缓存
     */
    @Scheduled(cron = "0 0 2 * * ?")
    public void perHot(){
        // 1.先清除缓存中的数据
        // 2.然后更新一下redis里面的loginKey；
        // 3.同时把loginKey放到布隆过滤器中

        redisUtil.deleteKey(LOGIN_KEY); // 删除redis里面的key

        Set set = new HashSet();
        List<Customer> customers = customerMapper.selectList(null);

        customers.forEach(c->{
            // 更新Redis里面的set
            redisUtil.saveSetToRedis(LOGIN_KEY, c.getUsername(),c.getEmail(),c.getContactTel());
            // 更新布隆过滤器
            BloomFilterUtil.addBloom(c.getUsername(),c.getEmail(),c.getContactTel());
            // 记录一下谁进了布隆过滤器中
            set.add(c.getUsername());
            set.add(c.getContactTel());
            set.add(c.getEmail());
        });

        // TODO:手动在布隆过滤器中放一个Arya, 模拟骗过了布隆过滤器,但没有骗过redis的情况
        BloomFilterUtil.addBloom("Arya");

        log.debug("缓存预热 + 布隆过滤器初始化成功 >>>" +set);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

在实际应用中遇到的bug

1.问题描述

如果在存redis的时候，用的是实现存java对象的序列化的Redistemplate,则此时就无法用SREM命令删除。

2.问题解决

要用stringRedisTemplate存就可以了

---

总结

1.之前的Redis相关博客的汇总；
2.redis里面存java对象的解决方案；
3.在实际使用中遇到的问题及处理；