Redis-15-与Spring Boot整合使用

发表于 | 分类于

述

我们在实际的开发中,通常是需要spring集成redis,这里就以spring boot为例,整合redis,做一些常用的操作

环境准备

首先开启redis服务,可以用我们之前创建的集群,或者是开启一个单独的redis服务,并且开启远程连接,还是上篇文章的那三步

然后,新建一个Spring Boot的工程

建好工程之后,引入下面的依赖:

1
2
3
4
5
<!-- redis依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置修改

application.yml中的配置如下:

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
spring:
  redis:
    # 单节点的ip
    # host:
    # 单节点的端口
    # port:
    cluster:
      # 集群节点
      nodes: 172.16.12.3:7000,172.16.12.3:7001,172.16.12.3:7002,172.16.12.3:7003,172.16.12.3:7004,172.16.12.3:7005
    # 连接超时时间
    timeout: 10000
    # 密码(默认是空)
    password:
    # Redis数据库索引(默认是0)
    database: 0
    jedis:
      pool:
        # 连接池最大阻塞等待时间(使用负值表示没有限制)
        max-wait: -1
        # 连接池最大连接数(使用负值表示没有限制)
        max-active: 8
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池中的最小空闲连接
        min-idle: 0

这里我直接使用上文中建的集群了,单个redis服务的话,直接用host和port设置就ok了,其他不变

StringRedisTemplate和RedisTemplate

Spring给了两个模板,一个是StringRedisTemplate一个是RedisTemplate,那具体应该用哪个呢

这个主要根据要存储的数据类型决定,key的话一般都是string,但是value我们可能放string也可能是放一个对象进去

所以,对于k-v都是String类型的话,那直接使用StringRedisTemplate就好了,也不需要什么配置,直接注入就可以使用了,这也是官方建议的

对于k-v是String,Object类型的话就用RedisTemplate,但是还需要自定义配置一下,这个下面再说

StringRedisTemplate的使用

这里我写了一个工具类,是一些基本的操作,代码如下:

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
@Slf4j
@Component
public class RedisStringUtil {

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 写入redis缓存,没有过期时间
     * @param key key
     * @param value value
     */
    public void set(final String key, String value){
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 写入redis缓存,过期时间单位是秒
     * @param key key
     * @param value value
     * @param expire 过期时间(单位是秒)
     */
    public void setex(final String key, String value, Long expire){
        redisTemplate.opsForValue().set(key, value, expire, TimeUnit.SECONDS);
    }

    /**
     * 写入redis缓存,过期时间单位是毫秒
     * @param key key
     * @param value value
     * @param expire 过期时间(单位是毫秒)
     */
    public void psetex(final String key, String value, Long expire){
        redisTemplate.opsForValue().set(key, value, expire, TimeUnit.MILLISECONDS);
    }

    /**
     * 读取缓存
     * @param key key
     * @return result
     */
    public String get(final String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 判断某个key是否存在
     * @param key key
     * @return 是否存在
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 根据key删除数据
     * @param key key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 批量删除
     * @param keys key
     */
    public void remove(final  String ... keys){
        for (String key : keys) {
            if (exists(key)) {
                redisTemplate.delete(key);
            }
        }
    }

}

主要就是通过StringRedisTemplate对数据的一些基本操作,然后测试类测试一下:

1
2
3
4
5
6
7
8
9
10
@Test
public void test(){
    boolean result = redisStringUtil.exists("k1");
    log.info(String.valueOf(result));

    redisStringUtil.set("k2", "v1");

    String v2 = redisStringUtil.get("k2");
    log.info(v2);
}

控制台输出如下: 

1
2
2019-04-26 14:19:32.525  INFO 4212 --- [           main] com.redis.example.AppTests               : true
2019-04-26 14:19:32.540  INFO 4212 --- [           main] com.redis.example.AppTests               : v1

可以看到数据能正常添加,查询

RedisTemplate

下面再来看一下RedisTemplate的一些操作

spring boot是不支持直接使用RedisTemplate的,需要我们自己做一些配置才可以使用,具体步骤如下

序列化

我们需要自己实现RedisSerializer<T>接口来对传入对象进行序列化和反序列化,新建一个RedisObjectSerializer类,代码如下: 

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
public class RedisObjectSerializer implements RedisSerializer<Object> {

    static final byte[] EMPTY_ARRAY = new byte[0];

    @Override
    public byte[] serialize(Object o) throws SerializationException {
        if (o == null) {
            return EMPTY_ARRAY;
        }

        ObjectOutputStream oos = null;
        ByteArrayOutputStream bos = null;

        try {
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);

            oos.writeObject(o);
            byte[] byt = bos.toByteArray();

            return byt;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    @Override
    public Object deserialize(byte[] bytes) throws SerializationException {
        if (isEmpty(bytes)) {
            return null;
        }

        ObjectInputStream ois = null;
        ByteArrayInputStream bis = null;

        bis = new ByteArrayInputStream(bytes);
        try {
            ois = new ObjectInputStream(bis);
            Object obj = ois.readObject();

            return obj;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    private boolean isEmpty(byte[] data) {
        return (data == null || data.length == 0);
    }
}

序列化的类搞定之后,需要在spring中配置一下RedisTemplate,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        RedisObjectSerializer redisObjectSerializer = new RedisObjectSerializer();

        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setStringSerializer(stringRedisSerializer);
        redisTemplate.setValueSerializer(redisObjectSerializer);

        return redisTemplate;
    }

}

配置完成之后就是测试环节了,定义一个User类供测试使用,代码如下:

1
2
3
4
5
6
7
8
9
10
11
@Data
@AllArgsConstructor
public class User implements Serializable {
    
    private Long id;
    
    private String name;
    
    private Integer age;
    
}

然后就可以写单元测试来测试了,测试代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
@Autowired
private RedisTemplate<String, Object> redisTemplate;

@Test
public void test1() {
    User user = new User(1L, "张三", 18);

    redisTemplate.opsForValue().set("user1", user);

    User user1 = (User)redisTemplate.opsForValue().get("user1");

    log.info("用户名:{}", user1.getName());
}

运行后,控制台输出如下:

1
2019-04-26 16:47:52.319  INFO 20444 --- [           main] com.redis.example.AppTests               : 用户名:张三

我们可以在redis可视化工具中看一下这个数据,如下图:
image

在reids中,他的key和value都是经过序列化的,在到了java程序中,反序列化转成对象

总结对比

StringRedisTemplate 和 RedisTemplate的区别主要有以下几点:

  1. StringRedisTemplate继承了RedisTemplate
  2. RedisTemplate是一个泛型类,而StringRedisTemplate则不是
  3. StringRedisTemplate只能对k-v都是String类型的数据操作,RedisTemplate可以对任何类型的k-v数据操作
  4. 他们各自序列化的方式不同,但最终都是得到了一个字节数组,StringRedisTemplate使用的是StringRedisSerializer类;RedisTemplate使用的是JdkSerializationRedisSerializer类.反序列化的时候则是一个得到String,一个得到Object

好了,RedisTemplate就先说到这里

参考文章
本文代码地址