SpringBoot整合redis

173次阅读

共计 4980 个字符，预计需要花费 13 分钟才能阅读完成。

redis 是最常用的缓存数据库，常用于存储用户登录 token、临时数据、定时相关数据等。

redis 是单线程的，所以 redis 的操作是原子性的，这样可以保证不会出现并发问题。

redis 基于内存，速度非常快，据测试，redis 读的速度是 110000 次 /s, 写的速度是 81000 次 /s

本节介绍 SpringBoot 引入 redis，以及使用 RedisTemplate 来操作 redis 数据。

采用 SpringBoot 2.1.9.RELEASE，对应 示例代码 在：https://github.com/laolunsi/spring-boot-examples/tree/master/07-spring-boot-redis-demo

一、A Simple Demo- 使用 SpringBoot 连接 redis

maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

yml:

server:
  port: 8867
spring:
  redis:
    host: localhost
    port: 6379
    #password: ''
    database: 6

测试类：

@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisTest {
 
    @Autowired
    private RedisTemplate redisTemplate;
 
    @Test
    public void testRedis() {
        String key = "hello";
        redisTemplate.opsForValue().set("hello", "你好");
 
        String res = (String) redisTemplate.opsForValue().get(key);
        System.out.println(res);
    }
}

执行结果：

看一下 redis：

这里存在一个问题：默认的存储方式导致 key 在 redis-manager 里面显示出来是乱码的，并且存储结果是二进制了。这样不利用我们查看 redis 里面的数据。

我们需要自定义 redis 存储的序列化规则。

二、解决 RedisTemplate 默认序列化的问题

完善一下 maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

定义 RedisConfig 类：

/**
 * redis 配置
 * 主要是配置 Redis 的序列化规则，替换默认的 jdkSerializer
 * key 的序列化规则用 StringRedisSerializer
 * value 的序列化规则用 Jackson2JsonRedisSerializer
 */
@Configuration
public class RedisConfig {
 
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
 
        // 使用 Jackson2JsonRedisSerialize 替换默认序列化
        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);
 
        // 设置 key 和 value 的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
 
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
 
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

删除之前的 key，重新执行一下 test 方法：

下面来演示一下 SpringBoot 使用 RedisTemplate 进行 redis 数据的操作

三、基于 SpringBoot 的 redis 操作——key/list/hash

RedisTemplate 内置 redis 操作如下：

这里主要展示 value/hash/list 三种用法：

3.1 RedisTemplate.opsForValue

  @Test
    public void testKeyOps() {
        // 测试 redis 操作 key-value 形式
        Set<String> keySet = new HashSet<>();
 
        String key1 = "name";
        keySet.add(key1);
        // 存储简单的 key-value，并设置过期时间
        redisTemplate.opsForValue().set(key1, "eknown", 1, TimeUnit.MINUTES);
 
        String key2 = "token:user1";
        String key3 = "token:user2";
        keySet.add(key2);
        keySet.add(key3);
        //
        redisTemplate.opsForValue().set(key2, "{\"name\":\"eknown\"}, \"role\":\"admin\"");
        redisTemplate.opsForValue().set(key3, "{\"name\":\"test\"}, \"role\":\"test\"");
 
        // 根据 key 的集合获取多个 value
        List<String> valueList = redisTemplate.opsForValue().multiGet(keySet);
        for (String value : valueList) {System.out.println(value);
        }
    }

执行结果：

redis 中的数据：

redis 中的 key 显示出了一个层级关系，这个小技巧对于实际项目有个非常好的作用：通过 prefix:suffix 这样的形式，可以将 redis 中存储的数据分出层级。

3.2 RedisTemplate.opsForHash

清空该 database 下的数据，测试 redisTemplate.opsForHash：

    @Test
    public void testHashOps() {
        String key = "hash";
        // 单次往 hash 中存放一个数据
        redisTemplate.opsForHash().put(key, "1", "你好");
 
        Map<String, Object> map = new HashMap<>();
        map.put("2", "hello");
        map.put("3a", "china1=2");
 
        // 一次性向 hash 中存放一个 map
        redisTemplate.opsForHash().putAll(key, map);
 
        // 获取 hash 下的所有 key 和 value
        Map<String, Object> resultMap = redisTemplate.opsForHash().entries(key);
        for (String hashKey : resultMap.keySet()) {System.out.println(hashKey + ":" + resultMap.get(hashKey));
        }
    }

执行结果：

redis:

3.3 RedisTemplate.opsForList

    @Test
    public void testListOps() {
        String listKey = "list";
        redisTemplate.opsForList().leftPush(listKey, "first value"); // 从 list 最左边插入数据
        redisTemplate.opsForList().leftPush(listKey, "second value but left");
        redisTemplate.opsForList().rightPush(listKey, 3); // 从 list 最右边插入数据
 
        List<Object> list = new ArrayList<>();
        list.add("hello");
        list.add("http://www.eknown.cn");
        list.add(23344);
        list.add(false);
        redisTemplate.opsForList().rightPushAll(listKey, list); // 从 list 右边批量插入数据
 
        long size = redisTemplate.opsForList().size(listKey);
        if (size > 0) {for (int i = 0; i < size -1 ; i++) {
                // 从 list 最左边开始读取 list 中的数据，注意 pop 会导致出栈，也就是数据被取出来了（redis 中就没有这个值了）// 此处我们读取 size- 1 条数据，仅留下最后一条数据
                System.out.println(i + ":" + redisTemplate.opsForList().leftPop(listKey).toString());
            }
        }
    }

执行上面的脚本，注意在最后的读取 list 数据代码前面加一个断点，此时 redis 中是这样的：

放开断点，程序继续执行，控制台如下：

注意，此时 redis 中仅剩余最后一条数据，这是由于 pop 的问题，list 中的数据被读取并删除了：

好了，这一节主要讲了 SpringBoot 引入 redis，以及使用 redis 的一些基本操作和相关技巧，在此基础上，我们可以让我们的项目变得更加快速、灵活！

交流学习

我的个人网站：http://www.eknown.cn

Git 仓库地址：https://github.com/laolunsi

另外也欢迎大家关注我的公众号：猿生物语，一起学习 Java/SpringBoot/SpringCloud 技术。

正文完
发表至： java
2019-11-07
 0
关于java:Redis总结
关于spring:SpringMVC-九大组件之-ViewResolver-深入分析
区块链项目如何俘获用户芳心，这些用户心声你值得听一听
关于java:7-整数反转

springboot 整合redis

174次阅读

共计 1334 个字符，预计需要花费 4 分钟才能阅读完成。

配置文件
spring:
redis:
# Redis 数据库索引（默认为 0）
database: 0
# Redis 服务器地址
host: 192.168.133.128
# Redis 服务器连接端口
port: 6379
# Redis 服务器连接密码（默认为空）
password: redis
jedis:
pool:
# 连接池最大连接数（使用负值表示没有限制）
max-active: 8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
max-wait: -1
# 连接池中的最大空闲连接
max-idle: 8
# 连接池中的最小空闲连接
min-idle: 0
# 连接超时时间（毫秒）
timeout: 10000
redis 工具类
@Component
public class RedisUtils {
@Autowired
private StringRedisTemplate stringRedisTemplate;

public void set(String key, Object object, Long time) {
// 让该方法能够支持多种数据类型存放
if (object instanceof String) {
setString(key, object);
}
// 如果存放时 Set 类型
if (object instanceof Set) {
setSet(key, object);
}
// 设置有效期
if (time != null) {
stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
}

}

public void setString(String key, Object object) {
String value = (String) object;
// 存放 string 类型
stringRedisTemplate.opsForValue().set(key, value);
}

public void setSet(String key, Object object) {
Set<String> valueSet = (Set<String>) object;
for (String string : valueSet) {
stringRedisTemplate.opsForSet().add(key, string);
}
}

public String getString(String key) {
return stringRedisTemplate.opsForValue().get(key);
}

}
测试
@RestController
public class RedisController {
@Autowired
private RedisUtils redisUtils;

@GetMapping(“test-set-string”)
public String testSetString(String key, String value) {
redisUtils.set(key, value,60L);
return “success set string”;
}

@GetMapping(“test-get-string”)
public String testGetString(String key) {
return redisUtils.getString(key);
}
}
代码：springboot-redis

正文完
redis
发表至： java
2019-04-16
 0
关于java:Redis总结
关于spring:SpringMVC-九大组件之-ViewResolver-深入分析
区块链项目如何俘获用户芳心，这些用户心声你值得听一听
关于java:7-整数反转