[Java知识库]Spring Boot 中集成Redis（一）

SpringBoot 中集成Redis

一、Redis 介绍

Redis 是一种非关系型数据库（NoSQL），NoSQL 是以 key-value 的形式存储的，和传统的关系型数据库不一样，不一定遵循传统数据库的一些基本要求，比如说 SQL 标准，ACID 属性，表结构等等，这类数据库主要有以下特点：非关系型的、分布式的、开源的、水平可扩展的。NoSQL 使用场景有：对数据高并发读写、对海量数据的高效率存储和访问、对数据的高可扩展性和高可用性等等。

Redis 的 key 可以是字符串、哈希、链表、集合和有序集合。
Redis 的value 类型很多，包括 String、list、set、zset。
这些数据类型都支持 push/pop、add/remove、取交集和并集以及更多更丰富的操作，Redis 也支持各种不同方式的排序。为了保证效率，数据都是在缓存在内存中，它也可以周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件中。 有了 redis 有哪些好处呢？举个比较简单的例子，看下图：

Redis 集群和 Mysql 是同步的，首先会从 redis 中获取数据，如果 redis 挂了，再从 mysql 中获取数
据，这样网站就不会挂掉。更多关于 redis 的介绍以及使用场景，可以谷歌和百度，在这就不赘述了。

?

二、Redis 安装

只要能 ping 的通云主机或者虚拟机的 ip，然后在虚拟机或者云主机中放行对应的端口（或者关掉防火墙）即可访问 redis。下面来介绍一下 redis 的安装过程：

1.源安装

安装 gcc 编译
下载 redis
解压安装
修改配置文件

2.Docker安装

docker run -p 6379:6379 --name redis -v /data/redis/redis.conf:/etc/redis/redis.conf  -v /data/redis/data:/data -d redis redis-server /etc/redis/redis.conf 

三、Spring Boot 集成 Redis

3.1 依赖导入

Spring Boot 集成 redis 很方便，只需要导入一个 redis 的 starter 依赖即可。如下：

<!--redis-->
<dependency>
?? ?<groupId>org.springframework.boot</groupId>
?? ?<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
     <groupId>org.apache.commons</groupId>
     <artifactId>commons-pool2</artifactId>
</dependency>
<!--阿里巴巴fastjson -->
<dependency>
?? ?<groupId>com.alibaba</groupId>
?? ?<artifactId>fastjson</artifactId>
?? ?<version>1.2.35</version>
</dependency>

这里也导入阿里巴巴的 fastjson 是为了在后面我们要存一个实体，为了方便把实体转换成 json 字符串存进去。

3.2 Redis 配置

导入了依赖之后，我们在 application.properties文件里配置 redis：

################ Redis 基础配置 ##############
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
#spring.redis.password=
# 链接超时时间 单位 ms（毫秒）
spring.redis.timeout=3000
################ Redis 线程池设置 ##############
# 连接池最大连接数（使用负值表示没有限制） 默认 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

# 连接池中的最大空闲连接，默认值也是8。
spring.redis.jedis.pool.max-idle=8
# 连接池中的最小空闲连接，默认值也是0。
spring.redis.jedis.pool.min-idle=0
# 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)
spring.redis.jedis.pool.max-active=1000
# 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
spring.redis.jedis.pool.max-wait=8

3.3 常用 api 介绍

? ? ?Spring Boot 对 redis 的支持已经非常完善了，丰富的 api 已经足够我们日常的开发，这里我介绍几个最常用的供大家学习，其他 api 希望大家自己多学习，多研究。用到会去查即可。

? ? ? ?有两个 redis 模板：RedisTemplate 和 StringRedisTemplate。
? ? ? ?我们不使用 RedisTemplate，RedisTemplate 提供给我们操作对象，操作对象的时候，我们通常是以 json 格式存储，但在存储的时候，会使用 Redis 默认的内部序列化器；导致我们存进里面的是乱码之类的东西。当然了，我们可以自己定义序列化，但是比较麻烦，所以使用 StringRedisTemplate 模板。StringRedisTemplate 主要给我们提供字符串操作，我们可以将实体类等转成 json 字符串即可，在取出来后，也可以转成相应的对象，这就是上面我导入了阿里 fastjson 的原因。

3.3.1 redis服务

? ?RedisService

package com.example.demoredis.Service;

import java.util.List;

/**
 * @author lizehua
 */
public interface RedisService {

    public void setString(String key, String value);
    public String getString(String key);
    public void setHash(String key, String filedKey, String value);
    public String getHash(String key, String filedkey);
    public long setList(String key, String value);
    public List<String> getList(String key, long start, long end);

}

RedisServiceimpl

package com.example.demoredis.Service.Impl;

import com.example.demoredis.Service.RedisService;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import java.util.List;

@Service
public class RedisServiceImpl implements RedisService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public void setString(String key, String value) {
        ValueOperations<String, String> valueOperations = stringRedisTemplate.opsForValue();
        valueOperations.set(key, value);
    }

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

    @Override
    public void setHash(String key, String filedKey, String value) {
        HashOperations<String, Object, Object> hashOperations =stringRedisTemplate.opsForHash();
        hashOperations.put(key,filedKey, value);
    }

    @Override
    public String getHash(String key, String filedkey) {
        return (String) stringRedisTemplate.opsForHash().get(key, filedkey);
    }

    @Override
    public long setList(String key, String value) {
        ListOperations<String, String> listOperations = stringRedisTemplate.opsForList();
        return listOperations.leftPush(key, value);
    }

    @Override
    public List<String> getList(String key, long start, long end) {
        return stringRedisTemplate.opsForList().range(key, start, end);
    }

    @PostConstruct
    public void init() {
        System.out.printf("开始测试");
    }


    @PreDestroy
    public void destroy() {
        System.out.printf("结束测试");
    }

}

3.3.2?测试

package com.example.demoredis;

import com.alibaba.fastjson.JSON;
import com.example.demoredis.Entity.UserEntity;
import com.example.demoredis.Service.RedisService;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.List;

@SpringBootTest
class DemoRedisApplicationTests2 {

    @Resource
    private RedisService redisService;
    @Test
    public void contextLoads() {
        //测试redis的string类型
        redisService.setString("weichat","GSCY");
        String weichat = redisService.getString("weichat");
        System.out.println("我的昵称为"+weichat);

        // 如果是个实体，我们可以使用json工具转成json字符串，

        UserEntity user=new UserEntity();
        user.setId(1);
        user.setUsername("朝雾轻寒");
        user.setUsersex("男");

        JSON.toJSONString(user);
        redisService.setString("userInfo", JSON.toJSONString(user));
        String userInfo = redisService.getString("userInfo");
        System.out.println("用户信息： " + userInfo);

        //json序列化和反序列化
        UserEntity user2 = JSON.parseObject(userInfo, UserEntity.class);
        System.out.println(user2.toString());

    }

    @Test
    public void contextLoads2() {
        //测试redis的hash类型
        UserEntity user=new UserEntity();
        user.setId(1);
        user.setUsername("朝雾轻寒");
        user.setUsersex("男");
        redisService.setHash("HSHuser", "name", JSON.toJSONString(user));
        String hash = redisService.getHash("HSHuser", "name");
        System.out.println("用户姓名："+hash);

    }

    @Test
    public void contextLoads3() {
        //测试redis的list类型
        redisService.setList("list", "football");
        redisService.setList("list", "basketball");
        List<String> valList = redisService.getList("list",0,-1);
        for(String value :valList){
            System.out.println("list中有："+value);

        }
    }

}

总结
本节主要介绍了 redis 的使用场景、安装过程，以及 Spring Boot 中集成 redis 的详细步骤。在实际项目中，通常都用 redis 作为缓存，在查询数据库的时候，会先从 redis 中查找，如果有信息，则从 redis中取；如果没有，则从数据库中查，并且同步到 redis 中，下次 redis 中就有了。更新和删除也是如此，都需要同步到 redis。redis 在高并发场景下运用的很多。
?

创作打卡挑战赛

赢取流量/现金/CSDN周边激励大奖