Redis7_09 基础篇第九章 SpringBoot集成Redis

孤尘Java

于 2024-04-14 02:09:16 发布

阅读量1k

点赞数 10

分类专栏： Redis从小白到精通文章标签： spring boot redis 后端

本文链接：https://blog.csdn.net/qq_33168558/article/details/137730277

版权

Redis从小白到精通专栏收录该内容

22 篇文章 6 订阅

订阅专栏

推荐直接使用RedisTemplate集成方式

1 集成方式

集成Jedis

集成Lettuce

集成RedisTemplate

2 创建springboot工程

创建一个新的Spring Boot工程可以通过以下步骤完成：

打开 IntelliJ IDEA
- 打开 IntelliJ IDEA 开发环境。
创建新项目
- 点击 "File" -> "New" -> "Project" 来创建一个新项目。
选择 Spring Initializr
- 在弹出的窗口中，选择 "Spring Initializr" 作为项目类型。
配置项目
- 选择项目的相关信息，包括项目名称、位置等。
- 选择项目的类型为 "Maven" 或 "Gradle"。
- 点击 "Next" 继续。
选择项目的依赖
- 在 "New Project" 窗口中，选择 "Spring Boot" 相关的依赖。
- 你可以选择 Web、JPA、Security 或其他你需要的依赖。
- 点击 "Next" 继续。
配置项目结构
- 设置项目的名称和位置。
- 点击 "Finish" 完成项目的创建。
等待项目构建
- IntelliJ IDEA 将会下载所需的依赖并构建项目。

创建好后，我们就可以用springboot集成redis

3 使用Jedis方式集成

Jedis是什么

Jedis Client是Redis官网推荐的一个面向iava客户端库文件实现了对各类API进行封装调用。

集成步骤

编写pom文件

使用jedis依赖版本为4.3.1

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.atguigu.redis7</groupId>
    <artifactId>redis7_study</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.10</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
    </properties>

    <dependencies>
        <!--SpringBoot通用依赖模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jedis-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.3.1</version>
        </dependency>
        <!--通用基础配置-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

编写配置文件

resource下创建application.properties

server.port=7777

spring.application.name=redis7_study

启动类

package com.atguigu.redis7;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @auther zzyy
 * @create 2022-11-17 16:36
 */
@SpringBootApplication
public class Redis7Study7777
{
    public static void main(String[] args)
    {
        SpringApplication.run(Redis7Study7777.class,args);
    }
}

业务代码

主要是靠这几行代码连接redis服务的

//1.用带参构造，传入 Redis服务的 ip 和端口号
Jedis jedis = new Jedis("192.168.186.128", 6379);
//2.指定密码
jedis.auth("111111");
//获得了连接可以像之前使用客户端redis命令那样访问redis
System.out.println(jedis.ping());

package com.atguigu.demo;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.StreamEntryID;

import java.util.HashMap;

/**
 * Description:
 * Author: fy
 * Date: 2024/4/12 23:47
 */
public class JedisDemo {
    public static void main(String[] args) {
        //1.用带参构造，传入 Redis服务的 ip 和 端口号
        Jedis jedis = new Jedis("192.168.186.128", 6379);
        //2.指定密码
        jedis.auth("111111");
        //获得了连接 可以像之前使用客户端redis命令那样访问redis
        System.out.println(jedis.ping());

        //string
        System.out.println(jedis.set("k3", "v3"));
        //过期时间
        System.out.println(jedis.ttl("k3"));
        System.out.println(jedis.exists("k3"));

        //list
        System.out.println(jedis.rpush("my list", "a", "b", "c"));
        System.out.println(jedis.lrange("my list", 0, -1));

        //set
        jedis.sadd("set1", "v1", "v2", "v3");
        System.out.println(jedis.smembers("set1"));

        //zset
        HashMap<String, Double> zsetValue = new HashMap<>();
        zsetValue.put("zsetv1", 1.0);
        zsetValue.put("zsetv2", 2.0);
        zsetValue.put("zsetv3", 3.0);
        jedis.zadd("zset1", zsetValue);
        System.out.println(jedis.zrange("zset1", 0, -1));

        //hash
        jedis.hset("hash", "field1", "value1");
        System.out.println(jedis.hget("hash", "field1"));

        //bitmap
        jedis.setbit("bitmap1", 2L, true);
        jedis.setbit("bitmap1", 5L, true);
        System.out.println(jedis.getbit("bitmap1", 2L));
        System.out.println(jedis.getbit("bitmap1", 5L));

        //Hyperloglog
        jedis.pfadd("hyperloglog", "1", "2", "3", "1", "2", "3", "1", "5", "3", "1", "2", "3", "1");
        System.out.println(jedis.pfcount("hyperloglog"));

        //geo
        jedis.geoadd("mygeo", 116.397428, 39.90923, "天安门");
        System.out.println(jedis.geopos("mygeo", "天安门"));

        //stream
        HashMap<String, String > map = new HashMap<>();
        map.put("msg1", "v1");
        map.put("msg2", "v2");
        map.put("msg3", "v3");
        jedis.xadd("stream", StreamEntryID.NEW_ENTRY, map);
        System.out.println(jedis.xrange("stream", StreamEntryID.MINIMUM_ID, StreamEntryID.MAXIMUM_ID));
    }
}

结果展示

4 使用Lettuce方式集成

Lettuce简介

Lettuce是一个Redis的Java驱动包，是一个基于 Java 的异步 Redis 客户端，用于与 Redis 服务器进行通信。它提供了一种响应式、基于事件的方式来与 Redis 进行交互。

与Jedis的对比

集成步骤

编写pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.atguigu.redis7</groupId>
    <artifactId>redis7_study</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.10</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
    </properties>

    <dependencies>
        <!--SpringBoot通用依赖模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jedis-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.3.1</version>
        </dependency>
        <!--lettuce-->
        <dependency>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
            <version>6.2.1.RELEASE</version>
        </dependency>
        <!--通用基础配置-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

编写配置文件

和jedis中的一样，不变。

编写业务方法

package com.atguigu.demo;


import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.SortArgs;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Description:
 * Author: fy
 * Date: 2024/4/13 1:19
 */
public class LettuceDemo {
    public static void main(String[] args) {
        //1.使用构建器链式编程来build我们的RedisURI、
        /*
            Builder是RedisURI的静态内部类，这意味着它可以直接通过外部类名 RedisURI 访问，无需创建 RedisURI 的实例。
         */
        RedisURI redisURI = RedisURI.Builder.redis("192.168.186.128")
                .withPort(6379)
                .withAuthentication("default", "111111")
                .build();
        //2.连接客户端
        RedisClient redisClient = RedisClient.create(redisURI);
        StatefulRedisConnection<String, String> connect = redisClient.connect();
        //3.用connect创建操作的command对象
        RedisCommands<String, String> commands = connect.sync();
        //============业务================
        //keys
        List<String> list = commands.keys("*");
        for(String s : list) {
            System.out.print(s + "    ");
        }
        //String
        commands.set("k1","1111");
        String s1 = commands.get("k1");
        System.out.println("String s ==="+s1);

        //list
        commands.lpush("myList2", "v1","v2","v3");
        List<String> list2 = commands.lrange("myList2", 0, -1);
        for(String s : list2) {
            System.out.println("list ssss==="+s);
        }
        //set
        commands.sadd("mySet2", "v1","v2","v3");
        Set<String> set = commands.smembers("mySet2");
        for(String s : set) {
            System.out.println("set ssss==="+s);
        }
        //hash
        Map<String,String> map = new HashMap<>();
        map.put("k1","138xxxxxxxx");
        map.put("k2","atguigu");
        map.put("k3","zzyybs@126.com");//课后有问题请给我发邮件

        commands.hmset("myHash2", map);
        Map<String,String> retMap = commands.hgetall("myHash2");
        for(String k : retMap.keySet()) {
            System.out.println("hash  k="+k+" , v=="+retMap.get(k));
        }

        //zset
        commands.zadd("myZset2", 100.0,"s1",110.0,"s2",90.0,"s3");
        List<String> list3 = commands.zrange("myZset2",0,10);
        for(String s : list3) {
            System.out.println("zset ssss==="+s);
        }

        //sort
        SortArgs sortArgs = new SortArgs();
        sortArgs.alpha();
        sortArgs.desc();

        List<String> list4 = commands.sort("myList2",sortArgs);
        for(String s : list4) {
            System.out.println("sort ssss==="+s);
        }



        //=============业务===============


        //4.关闭资源（应当写在try 、 catch 、 finally里边）
        connect.close();
        redisClient.shutdown();


    }
}

结果展示

5 使用RedisTemplate方式集成

连接单机步骤

pom文件编写

如果日志输出报错，可以修改lombok为更高版本比如 1.18.18

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.atguigu.redis7</groupId>
    <artifactId>redis7_study</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.10</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
    </properties>


    <dependencies>
        <!--SpringBoot通用依赖模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jedis-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.3.1</version>
        </dependency>
        <!--lettuce-->
        <dependency>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
            <version>6.2.1.RELEASE</version>
        </dependency>
        <!--SpringBoot与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>
        <!--swagger2-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!--通用基础配置junit/devtools/test/log4j/lombok/hutool-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置文件

server.port=7777

spring.application.name=redis7_study

# ========================logging=====================
logging.level.root=info
logging.level.com.atguigu.redis7=info
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger- %msg%n 

logging.file.name=D:/mylogs2023/redis7_study.log
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger- %msg%n

# ========================swagger=====================
spring.swagger2.enabled=true
#在springboot2.6.X结合swagger2.9.X会提示documentationPluginsBootstrapper空指针异常，
#原因是在springboot2.6.X中将SpringMVC默认路径匹配策略从AntPathMatcher更改为PathPatternParser，
# 导致出错，解决办法是matching-strategy切换回之前ant_path_matcher
spring.mvc.pathmatch.matching-strategy=ant_path_matcher

# ========================redis单机=====================
spring.redis.database=0
# 修改为自己真实IP
spring.redis.host=192.168.111.185
spring.redis.port=6379
spring.redis.password=111111
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0

主启动类

package com.atguigu.redis7;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Redis7Study7777
{
    public static void main(String[] args)
    {
        SpringApplication.run(Redis7Study7777.class,args);
    }
}

配置类

查看代码可以注意到我们对RedisTemplate的序列化做了初始化，让他只是用我们指定的String类的序列化。这样可以方式java后台存入的key 和 value 在Redis服务上查看时产生乱码问题。（即使使用了 --raw也会乱码，这个问题是由于序列化使用了jdk中默认的序列化而导致的）

还有一种方法就是不要使用RedisTemplate，转而使用StringRedisTemplate

RedisConfig类

package com.atguigu.redis7.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;


@Configuration
public class RedisConfig
{
    /**
     * redis序列化的工具配置类，下面这个请一定开启配置
     * 127.0.0.1:6379> keys *
     * 1) "ord:102"  序列化过
     * 2) "\xac\xed\x00\x05t\x00\aord:102"   野生，没有序列化过
     * this.redisTemplate.opsForValue(); //提供了操作string类型的所有方法
     * this.redisTemplate.opsForList(); // 提供了操作list类型的所有方法
     * this.redisTemplate.opsForSet(); //提供了操作set的所有方法
     * this.redisTemplate.opsForHash(); //提供了操作hash表的所有方法
     * this.redisTemplate.opsForZSet(); //提供了操作zset的所有方法
     * @param lettuceConnectionFactory
     * @return 、
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory)
    {
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();

        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        //设置key序列化方式string
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置value的序列化方式json，使用GenericJackson2JsonRedisSerializer替换默认序列化
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        //hash的
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

        redisTemplate.afterPropertiesSet();

        return redisTemplate;
    }
}

SwaggerConfig类

package com.atguigu.redis7.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;


@Configuration
public class RedisConfig
{
    /**
     * redis序列化的工具配置类，下面这个请一定开启配置
     * 127.0.0.1:6379> keys *
     * 1) "ord:102"  序列化过
     * 2) "\xac\xed\x00\x05t\x00\aord:102"   野生，没有序列化过
     * this.redisTemplate.opsForValue(); //提供了操作string类型的所有方法
     * this.redisTemplate.opsForList(); // 提供了操作list类型的所有方法
     * this.redisTemplate.opsForSet(); //提供了操作set的所有方法
     * this.redisTemplate.opsForHash(); //提供了操作hash表的所有方法
     * this.redisTemplate.opsForZSet(); //提供了操作zset的所有方法
     * @param lettuceConnectionFactory
     * @return 、
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory)
    {
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();

        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        //设置key序列化方式string
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置value的序列化方式json，使用GenericJackson2JsonRedisSerializer替换默认序列化
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        //hash的
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

        redisTemplate.afterPropertiesSet();

        return redisTemplate;
    }
}

业务类

Service类

package com.atguigu.service;

import lombok.extern.slf4j.Slf4j;
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.Service;

import javax.annotation.Resource;
import java.util.UUID;
import java.util.concurrent.ThreadLocalRandom;

/**
 * Description:
 * Author: fy
 * Date: 2024/4/13 16:05
 */
@Service
@Slf4j
public class OrderService {

    public static final String ORDER_KEY_PREFIX = "order_no:";

    /*
   乱码问题的解决：
        1.要避免直接使用RedisTemplate 最好使用StringRedisTemplate
        否则，默认的序列化方式，会导致key和value从linux的redis客户端去查看
        时乱码
        2.若要使用RedisTemplate 应当在配置类中配置它的不同类型的序列化方式
        key全部使用StringRedisSerializer
        value全部使用GenericJackson2JsonRedisSerializer
     */
    @Autowired
    private RedisTemplate redisTemplate;

    public void createOrder()
    {
        int keyId = ThreadLocalRandom.current().nextInt(1000) + 1;
        String serialNo = UUID.randomUUID().toString();

        String key = ORDER_KEY_PREFIX + keyId;
        String value = "京东订单"+serialNo;
        redisTemplate.opsForValue().set(key,value);
        log.info("----------key{}",key);
        log.info("----------value{}",value);
    }

    //获取value
    public String getOrderById(Integer keyId) {
        return (String) redisTemplate.opsForValue().get(ORDER_KEY_PREFIX + keyId);
    }


}

Controller类

package com.atguigu.controller;

import com.atguigu.service.OrderService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * Description:
 * Author: fy
 * Date: 2024/4/13 16:19
 */
@RestController
@Slf4j
@Api(tags = "订单接口")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @ApiOperation("添加订单")
    @RequestMapping(value = "/order/add", method = RequestMethod.POST)
    public void addOrder() {
        orderService.createOrder();
    }

    @ApiOperation("按照keyId查询订单")
    @RequestMapping(value = "/order/{keyId}", method = RequestMethod.GET)
    public String getOrderById(@PathVariable Integer keyId) {
        return orderService.getOrderById(keyId);
    }


}

结果展示

使用swagger接口测试页面来测试

swagger测试地址

http://localhost:7777/swagger-ui.html#/

点击try it out

再点击execute

返回java后台查看，添加成功。

连接集群步骤

启动六台实例

可以回看集群篇章中的启动三主三从的步骤。

注意事项

编写配置文件

注意一定要改成自己的ip

注意事项

注意，一定要加上连接集群配置中的自动定时刷新拓扑图、自适应刷新拓扑图的功能，否则在redis服务集群的某个主机宕机，从机上位后，后台无法识别到，仍然按照原来的架构去传递数据，一旦某数据要传到宕机的那个服务器上，就会导致长达一分钟的卡顿，直到超时，非常危险！

server.port=7070
server.servlet.context-path=/

spring.application.name=redis7_study

# ========================logging=====================
logging.level.root=info
logging.level.com.atguigu.redis7=info
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger- %msg%n 

logging.file.name=D:/mylogs2023/redis7_study.log
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger- %msg%n

# ========================swagger=====================
spring.swagger2.enabled=true
spring.mvc.pathmatch.matching-strategy=ant_path_matcher

## ========================redis单机=====================
#spring.redis.database=0
#spring.redis.host=192.168.186.128
#spring.redis.port=6379
#spring.redis.password=111111
#spring.redis.lettuce.pool.max-active=8
#spring.redis.lettuce.pool.max-wait=-1ms
#spring.redis.lettuce.pool.max-idle=8
#spring.redis.lettuce.pool.min-idle=0

# ========================redis集群=====================
spring.redis.password=111111
spring.redis.cluster.max-redirects=3
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0
#开启自适应刷新redis服务的拓扑图，防止拓扑图改变时，java后台识别不到
spring.redis.lettuce.cluster.refresh.adaptive=true
# 自动刷新获取拓扑图的时间间隔
spring.redis.lettuce.cluster.refresh.period=2000
spring.redis.cluster.nodes=192.168.186.128:6381,192.168.186.128:6382,192.168.186.128:6383,192.168.186.128:6384,192.168.186.128:6385,192.168.186.128:6386

业务类

和单机的一样，不用改动

结果展示

Redis服务一切正常时，后台添加数据，显示正常。

手动shutdown6381服务器，看看还能不能添加数据到redis了

发现是可以的，就是因为我们配置了自适应刷新拓扑图的配置。否则，一旦有服务器宕机，将会引发极大问题！。

6 总结

建议直接使用RedisTemplate

如果你已经在使用 Spring 框架，并且希望通过统一的接口来与 Redis 进行交互，那么 RedisTemplate 是一个更好的选择。

集群连接时，自己测试的时候，Redis服务内查看集群信息，要求每个redis服务的ip都是真实ip不能是127.0.0.1 否则Java后台连不上redis

集群集成的时候，必须开启自适应刷新拓扑图，自动间隔时间获取拓扑图，否则出现宕机情况时，会有长达一分钟的连接超时，非常危险。