展开目录 返回顶部 到达底部

SpringBoot2.x集成Redis

Author: Date: 2018-08-13  11:19:24 Category: SpringBoot Words:1,567 Times:7min User:

Redis介绍

Redis数据库是一个完全开源免费的高性能Key-Value数据库。它支持存储的value类型有五种，包括string(字符串)、list(链表)、set(集合)、zset(sorted set –有序集合)和hash（哈希类型）

Redis非常快，每秒可执行大约110000次的设置(SET)操作，每秒大约可执行81000次的读取/获取(GET)操作。

开发工具

IDEA、Maven、SpringBoot2.0.4、Jdk1.8、Redis3.2.100、PostMan

配置开始

说明

spring 封装了两种不同的对象来进行对redis的各种操作，分别是StringTemplate与redisTemplate。

  • 两者的关系是StringRedisTemplate继承RedisTemplate。
  • 两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据。
  • SDR默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。
  • StringRedisTemplate默认采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的。
  • RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。

其实通俗的来讲：

  1. 当你的redis数据库里面本来存的是字符串数据或者你要存取的数据就是字符串类型数据的时候，那么你就使用StringRedisTemplate即可。

  2. 但是如果你的数据是复杂的对象类型，而取出的时候又不想做任何的数据转换，直接从Redis里面取出一个对象，那么使用RedisTemplate是
    更好的选择。

StringTemple

Maven配置

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

yml配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
server:
  port: 8031

spring:
  application:
    name: spirng-boot-redis
  redis:
    host: 127.0.0.1
    timeout: 3000
    password:
    port: 6379
    database: 5
    jedis:
      pool:
        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
        max-idle: 8 # 连接池中的最大空闲连接
        max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制)
        min-idle: 0 # 连接池中的最小空闲连接

Service业务实现

创建StringRedisService

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
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

/**
 * 描述:
 * redis业务
 *
 * @author zhengql
 * @date 2018/8/10 14:29
 */
@Service
public class StringRedisService {
    private static final Logger logger = LoggerFactory.getLogger(StringRedisService.class);
    @Autowired
    private StringRedisTemplate stringRedisTemplate;


    public  void setString(String key, String value){
        logger.info("--------------------->[Redis set start]");
        stringRedisTemplate.opsForValue().set(key,value);
    }

    public String getString(String key){
        logger.info("--------------------->[Redis get start]");
        return  stringRedisTemplate.opsForValue().get(key);
    }
}

测试

测试代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class StringRedisServiceTest {

    @Autowired
    StringRedisService stringRedisService;

    @Test
    public void set() {
        stringRedisService.setString("name","张三");
    }

    @Test
    public void get(){
        System.out.println(stringRedisService.getString("name"));
    }
}

使用Junit测试存入一条数据到redis中,测试效果如下：

可以看到我们已经成功存进去啦，下面测试从redis中去取出刚才存入的数据。

RedisTemple

当我们的数据是复杂的对象类型，那么可以采用RedisTemple

手动配置

首先我们需要手动创建Redis的配置类，来自定义序列化

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
/**
 * 描述:
 *
 * @author zhengql
 * @date 2018/8/10 16:00
 */

@Configuration
@EnableCaching
public class RedisConfiguration extends CachingConfigurerSupport {
    private static final Logger logger = LoggerFactory.getLogger(RedisConfiguration.class);
    
    
    /**
     * redis模板，存储关键字是字符串，值jackson2JsonRedisSerializer是序列化后的值
     *
     * @param
     * @return org.springframework.data.redis.core.RedisTemplate
     * @author zhengql
     * @date 2018/8/10 16:03
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        //使用StringRedisSerializer来序列化和反序列化redis的key值
        RedisSerializer redisSerializer = new StringRedisSerializer();
        //key
        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(redisSerializer);
        //value
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;

    }
    
}

定义User实体类

注意：这里必须实现序列化接口

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
import java.io.Serializable;

/**
 * 描述:
 *
 * @author zhengql
 * @date 2018/8/10 15:29
 */
public class User implements Serializable {

    private static final long serialVersionUID = -8289770787953160443L;

    private String userName;
    private Integer age;

    public User(String userName, Integer age) {
        this.userName = userName;
        this.age = age;
    }

    public User() {
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }
}

Service方法

RedisTemplate中定义了对5种数据结构操作：

  • redisTemplate.opsForValue() ：操作字符串
  • redisTemplate.opsForHash() ：操作hash
  • redisTemplate.opsForList() ：操作list
  • redisTemplate.opsForSet() ：操作set
  • redisTemplate.opsForZSet() ：操作有序set

创建RedisService类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

/**
 * 描述:
 * redisTemple 的Service类
 *
 * @author zhengql
 * @date 2018/8/10 16:22
 */
@Service
public class RedisService {
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    public void setObj(String key,User value) {
        redisTemplate.opsForValue().set(key,value);
    }

    public User getObj(String key) {
        return (User)redisTemplate.opsForValue().get(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

/**
 * @auther: zhengql
 * @date: 2018/8/11 10:25
 * @description:
 */

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisServiceTest {

    @Autowired
    private RedisService redisService;

    @Test
    public void setObj() {
        redisService.setObj("user",new User("小明",22));
        User user = redisService.getObj("user");
        System.out.println(user.toString());
    }

    @Test
    public void getObj() {
        User user = redisService.getObj("user");
        System.out.println(user.toString());
    }
}

执行上述setObj()方法,可以看到我们存入redis中的对象

总结

完成以上配置，我们Springboot集成Redis的基本环境就搭建完成了。redis的功能其实很多，redis可以解决很多关系型数据库所不能解决的问题，它可以实现缓存，可以实现持久化、可以做分布式锁等等，如此强大的redis，需要我们不断的学习和实践理解他的功能和原理。

---------- 😏本文结束  感谢您的阅读😏 ----------
返回    /   首页
评论