首页 > 软件编程 > java > SpringCloud搭建

从零搭建SpringCloud的超详细过程

2025-09-18 12:01:07 作者：晚风乱了温柔

本文给大家详细介绍从零搭建SpringCloud的超详细过程,本文通过图文实例代码相结合给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧

1. 引言

环境 : Windows、jdk17、IntelliJ Idea
‌目标 : 使用SpringBoot3.4和Springcloud2024,搭建一个基础的SpringCloud

2. 介绍

记录本人从零搭建SpringCloud的过程

SpringCloud官网 : Spring Cloud

版本适配

2.1. 项目简介

计划搭建多个项目模块
eureka 模块 : 项目的服务注册中心
entity 模块 : 存放项目的实体类
commons 模块 : 存放项目的公共类和工具类等
gateway 模块 : 服务网关和服务调用模块
cache 模块 : 项目的缓存模块,如操作Redis等
manager 模块 : 项目的管理使用模块

3. SpringCloud的搭建

3.1. 父工程项目的搭建

在 File --> new project --> 选择Java类型的项目
设置相关信息后点击create

将新建项目的 src 文件删除

配置maven File --> setting

配置pom.xml文件

    <!--1. 文件自动生成的配置 -->
    <groupId>com.yida</groupId>
    <artifactId>springcloud-daily</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--2 设置聚合工程（即父模块）的打包方式为pom-->
    <packaging>pom</packaging>
    <!--3 设置子模块-->
    <modules>
    </modules>
    <!--4 自定义属性-->
    <properties>
        <java.version>17</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!--版本控制-->
        <spring-boot.version>3.4.3</spring-boot.version>
        <spring-cloud.version>2024.0.0</spring-cloud.version>
    </properties>
    <!--5 配置公共依赖-->
    <dependencies>
    </dependencies>
    <!--6 配置可选依赖    项目并不是每一个都是SpringBoot项目如果是单独加入依赖-->
    <dependencyManagement>
        <dependencies>
            <!-- springboot的依赖-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- springcloud依赖-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring-cloud-alibaba-->
        </dependencies>
    </dependencyManagement>
    <build>
        <!--7 配置插件-->
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <compilerArgs>
                        <arg>-parameters</arg>
                    </compilerArgs>
                </configuration>
            </plugin>
        </plugins>
    </build>

3.2. 子模块项目的搭建

选中文件你创建的文件(springcloud-template)
右键 --> new --> module
此时没什么要配置的只要取名字之后, create

ps :

项目的每一个子模块都是如此创建

3.3. 子模块搭建 -- eureka

eureka 是Springcloud 的服务注册中心,所以我们优先搭建此模块

配置pom.yml文件
添加依赖

<!-- 定义项目依赖
    服务的注册中心 - eureka是SpringBoot项目
    -->
    <dependencies>
        <!-- 引入Spring Boot Web启动器依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 引入Spring Cloud Netflix Eureka服务器启动器依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

在daily-eureka --> src --> main --> resource 文件下
新建 application.yml文件

server:
  port: 8761  # 配置服务器的端口号为8761
eureka:
  instance:
    hostname: localhost  # 设置Eureka实例的主机名为localhost
  client:
    registerWithEureka: false  # 关闭注册到Eureka服务器的功能
    fetchRegistry: false  # 关闭从Eureka服务器获取注册信息的功能
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/  # 设置Eureka服务器的地址

daily-eureka --> src --> main --> Java 文件下
创建启动类 EurekaServerStartApp

// 启动应用程序的主类，使用Spring Boot的自动配置功能
@SpringBootApplication
// 启用Eureka Server功能，使该应用作为服务注册中心
@EnableEurekaServer
public class EurekaServerStartApp {
    /**
     * 主函数入口
     * 启动Spring Boot应用，使其作为一个Eureka客户端，连接到Eureka服务器
     *
     * @param args 命令行参数，通常用于传递配置信息或启动参数
     */
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerStartApp.class, args);
    }
}

启动可以查看eureka的可视化界面访问地址 : http://localhost:8761/

3.4. 子模块搭建 -- entity

entity子模块,用于存放项目的实体类的模块
不属于SpringBoot项目

配置pom.yml文件
添加依赖

<dependencies>
        <!-- Lombok依赖，用于简化Java代码 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

3.5. 子模块搭建 -- commons

commons 子模块,是放一写公共类的模块,如返回结果,工具类等
不属于SpringBoot服务

配置pom.yml文件
添加依赖

<dependencies>
        <!-- 依赖于daily-commons项目 -->
        <dependency>
            <groupId>com.yida</groupId>
            <artifactId>daily-entity</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

3.6. 子模块搭建 -- gateway

gateway 子模块用于项目 zuul 和 feign
属于SpringBoot服务

配置pom.yml文件
添加依赖

<!-- 定义项目依赖  -->
    <dependencies>
        <!--SpringBoot项目 使用Spring Boot Web启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--在Eureka注册 集成Netflix Eureka客户端，用于服务发现 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- 集成Netflix Zuul，用于路由和过滤 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
            <!-- 需要指定,具体可能是停止更新 -->
            <version>2.2.10.RELEASE</version>
        </dependency>
        <!-- 使用OpenFeign进行声明式HTTP调用 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
    </dependencies>

新建 application.yml文件

server:
  port: 5200  # 配置服务器的端口号为5200
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/  # 设置Eureka服务器的地址，用于服务注册和发现
spring:
  application:
    name: daily-gateway  # 起一个服务名称，用于在Eureka服务器上注册

创建启动类 GatewayServerStartApp
在 Spring Cloud 中，@EnableEurekaClient 注解用于启用 Eureka 客户端，使得应用程序可以注册到 Eureka Server 并发现其他服务。但是，从 Spring Cloud Netflix 版本 2.0 开始，官方推荐的做法是使用 @EnableDiscoveryClient 注解，而不是 @EnableEurekaClient。这是因为 @EnableDiscoveryClient 更加通用，可以与多种服务发现机制（例如 Eureka, Consul, Zookeeper 等）一起使用。

如果你的项目是基于 Spring Cloud Netflix 并使用了 spring-cloud-starter-netflix-eureka-client 4.2.0 版本，你应该注意到以下几点：

使用 @EnableDiscoveryClient 注解：

如果你的项目是基于 Spring Cloud Netflix 并希望保持与未来版本的兼容性，你应该使用 @EnableDiscoveryClient 注解

// 启动Spring Boot应用程序
@SpringBootApplication
// 启用Eureka客户端，使应用能够注册和发现其他微服务
@EnableDiscoveryClient
// 启用Zuul代理，使应用成为API网关，负责路由和过滤请求
@EnableZuulProxy
// 启用Feign客户端，简化HTTP调用，实现服务间调用
@EnableFeignClients
public class GatewayServerStartApp {
    /**
     * main方法是Java应用程序的入口点
     * 这里使用SpringApplication.run来启动Spring Boot应用
     *
     * @param args 命令行参数，允许在启动时传递配置信息
     */
    public static void main(String[] args) {
        SpringApplication.run(GatewayServerStartApp.class, args);
    }
}

启动测试

ps:

需要先启动eureka,否则会启动报错

3.7. 子模块搭建 -- cache

cache 子模块用于项目的缓存服务,例如Redis相关的服务
属于SpringBoot服务

配置pom.yml文件
添加依赖

   <dependencies>
        <!-- 依赖于daily-commons项目 -->
        <dependency>
            <groupId>com.yida</groupId>
            <artifactId>daily-commons</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--SpringBoot项目 使用Spring Boot Web启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--在Eureka注册 集成Netflix Eureka客户端，用于服务发现 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- 依赖于Spring Boot Redis模块，用于操作Redis数据库 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- 依赖项：Fastjson
             Fastjson是阿里巴巴的一个开源项目，它是一个Java语言编写的高性能功能完备的JSON库。
             它可以用来将Java对象转换为JSON字符串，也可以将JSON字符串转换为Java对象。
             版本：1.1.23 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>
    </dependencies>

新建 application.yml文件

server:
  port: 9980  # 配置服务器的端口号为9980
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/  # 设置Eureka服务器的地址，用于服务发现与注册
spring:
  application:
    name: daily-cache  # 起一个服务名称，便于在Eureka服务器中识别
  redis:
    host: 192.168.233.134  # 配置Redis服务器的主机地址
    port: 6379  # 配置Redis服务器的端口号
    password: root  # 配置访问Redis服务器的密码

创建启动类

@SpringBootApplication
@EnableDiscoveryClient
public class CacheServerStartApp {
    /**
     * main 方法是应用程序的入口点
     * 它使用 Spring Boot 的 SpringApplication.run 方法来启动应用程序
     *
     * @param args 命令行参数，允许在应用程序启动时传递参数
     */
    public static void main(String[] args) {
        SpringApplication.run(CacheServerStartApp.class, args);
    }
}

启动测试

ps:

需要先启动eureka,否则会启动报错

3.8. 子模块搭建 -- manager

manager 子模块用于项目的实际管理模块
属于SpringBoot服务

配置pom.yml文件
添加依赖

<dependencies>
        <!-- 依赖于daily-commons模块，可能包含通用的工具类或常量 -->
        <dependency>
            <groupId>com.yida</groupId>
            <artifactId>daily-commons</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- 依赖于Spring Boot的Web模块，用于创建Web应用 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 依赖于Eureka客户端，用于服务发现和服务注册 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- 依赖于OpenFeign，用于声明式REST调用 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!-- 依赖于MyBatis，用于ORM操作数据库 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.4</version>
        </dependency>
        <!-- 依赖于MySQL数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        <!-- 依赖于Druid数据源，用于数据库连接池管理 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.24</version>
        </dependency>
        <!-- 依赖于MyBatis-Spring，用于整合MyBatis和Spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>3.0.4</version>
        </dependency>
        <!-- 依赖于PageHelper，用于分页查询 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.13</version>
        </dependency>
    </dependencies>

新建 application.yml文件
数据库名字自己写

server:
  port: 6399 # 设置服务器的端口为6399
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/ # 配置Eureka服务器的地址
spring:
  application:
    name: daily-manager  # 设置服务名称为daily-manager
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver # 配置MySQL数据源驱动
    url: jdbc:mysql://localhost:3306/{需要连接的数据库名字}?characterEncoding=UTF-8&serverTimezone=Asia/Shanghai # 设置数据库连接URL
    username: root # 数据库用户名
    password: root # 数据库密码
#    type: com.alibaba.druid.pool.DruidDataSource # 指定数据源类型为Druid
mybatis:
  mapper-locations: classpath:mapper/*.xml # 配置MyBatis的映射文件位置

创建启动类

// 启动Spring Boot应用程序
@SpringBootApplication
// 启用Eureka客户端，使该应用能够注册和发现其他微服务
@EnableDiscoveryClient
// 启用Feign客户端，用于声明式REST调用
@EnableFeignClients
// 指定MyBatis Plus的Mapper接口所在包，以便进行统一扫描
@MapperScan("daily.manager.mapper")
public class ManagerStartApp {
    /**
     * 主函数入口
     * 它负责启动Spring应用，通过传入当前类和命令行参数来引导应用的执行
     *
     * @param args 命令行参数，允许在启动时传递配置信息
     */
    public static void main(String[] args) {
        SpringApplication.run(ManagerStartApp.class, args);
    }
}

创建空文件夹

设置mapper.xml的文本模版

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="">
</mapper>

启动测试

ps:

需要先启动eureka,否则会启动报错

4. 模块测试

4.1. 模块测试-01

4.1.1. 数据库配置

新建表数据用于测试

CREATE TABLE tb_hello(
    hello_id INT NOT NULL AUTO_INCREMENT  COMMENT '编号' ,
    title VARCHAR(32)    COMMENT '标题' ,
    status INT    COMMENT '状态' ,
    PRIMARY KEY (hello_id)
) COMMENT = 'hello表 ';

添加数据

insert into tb_hello values(1 , '你好,世界!' , '0');

测试entity模块,commons模块,manager模块的使用

文件结构如下

4.1.2. entity模块

Hello文件代码

@lombok.Data
public class Hello {
    private Integer helloId;
    private String title;
    private String status;
}

4.1.3. commons模块

DataResult代码

package daily.commons;
import daily.commons.enumpojo.ResponseResultEnum;
import org.apache.commons.lang.StringUtils;
/**
 * DataResult类用于封装API响应结果
 * 它提供了静态方法来创建表示成功或失败的响应对象，包含消息、状态码和数据
 */
public class DataResult {
    private String msg;
    private Integer code;
    private Object data;
    // 默认构造函数
    public DataResult() {
    }
    // 只含消息的构造函数
    public DataResult(String msg) {
        this.msg = msg;
    }
    // 含消息和状态码的构造函数
    public DataResult(String msg, Integer code) {
        this.msg = msg;
        this.code = code;
    }
    // 含消息、状态码和数据的构造函数
    public DataResult(String msg, Integer code, Object data) {
        this.msg = msg;
        this.code = code;
        this.data = data;
    }
    /**
     * 创建一个表示成功的DataResult对象
     * 使用默认的成功消息和状态码
     *
     * @return 表示成功的DataResult对象
     */
    public static DataResult success() {
        return new DataResult(ResponseResultEnum.SUCCESS.getMsg(), ResponseResultEnum.SUCCESS.getCode());
    }
    /**
     * 创建一个表示成功的DataResult对象
     * 如果消息为空，则使用默认的成功消息
     *
     * @param msg 成功消息，如果为空则使用默认消息
     * @return 表示成功的DataResult对象
     */
    public static DataResult success(String msg) {
        if (msg == null || StringUtils.isEmpty(msg)) {
            msg = ResponseResultEnum.SUCCESS.getMsg();
        }
        return new DataResult(msg, ResponseResultEnum.SUCCESS.getCode());
    }
    /**
     * 创建一个表示成功的DataResult对象，包含数据
     * 如果消息为空，则使用默认的成功消息；如果数据为空，则使用空字符串作为数据
     *
     * @param msg 成功消息，如果为空则使用默认消息
     * @param data 成功数据，如果为空则使用空字符串
     * @return 包含数据的表示成功的DataResult对象
     */
    public static DataResult success(String msg, Object data) {
        if (msg == null || StringUtils.isEmpty(msg)) {
            msg = ResponseResultEnum.SUCCESS.getMsg();
        }
        if (data == null) {
            data = "";
        }
        return new DataResult(msg, ResponseResultEnum.SUCCESS.getCode(), data);
    }
    /**
     * 创建一个表示成功的DataResult对象，包含数据
     * 使用默认的成功消息，如果数据为空，则使用空字符串作为数据
     *
     * @param data 成功数据，如果为空则使用空字符串
     * @return 包含数据的表示成功的DataResult对象
     */
    public static DataResult success(Object data) {
        if (data == null) {
            data = "";
        }
        return new DataResult(ResponseResultEnum.SUCCESS.getMsg(), ResponseResultEnum.SUCCESS.getCode(), data);
    }
    /**
     * 创建一个表示失败的DataResult对象
     * 使用默认的失败消息和状态码
     *
     * @return 表示失败的DataResult对象
     */
    public static DataResult fail() {
        return new DataResult(ResponseResultEnum.FAIL.getMsg(), ResponseResultEnum.FAIL.getCode());
    }
    /**
     * 创建一个表示失败的DataResult对象
     * 如果消息为空，则使用默认的失败消息
     *
     * @param msg 失败消息，如果为空则使用默认消息
     * @return 表示失败的DataResult对象
     */
    public static DataResult fail(String msg) {
        if (msg == null || StringUtils.isEmpty(msg)) {
            msg = ResponseResultEnum.FAIL.getMsg();
        }
        return new DataResult(msg, ResponseResultEnum.FAIL.getCode());
    }
    /**
     * 创建一个表示失败的DataResult对象，包含数据
     * 如果消息为空，则使用默认的失败消息；如果数据为空，则使用空字符串作为数据
     *
     * @param msg 失败消息，如果为空则使用默认消息
     * @param data 失败数据，如果为空则使用空字符串
     * @return 包含数据的表示失败的DataResult对象
     */
    public static DataResult fail(String msg, Object data) {
        if (msg == null || StringUtils.isEmpty(msg)) {
            msg = ResponseResultEnum.FAIL.getMsg();
        }
        if (data == null) {
            data = "";
        }
        return new DataResult(msg, ResponseResultEnum.FAIL.getCode(), data);
    }
    /**
     * 创建一个表示失败的DataResult对象，包含数据
     * 使用默认的失败消息，如果数据为空，则使用空字符串作为数据
     *
     * @param data 失败数据，如果为空则使用空字符串
     * @return 包含数据的表示失败的DataResult对象
     */
    public static DataResult fail(Object data) {
        if (data == null) {
            data = "";
        }
        return new DataResult(ResponseResultEnum.FAIL.getMsg(), ResponseResultEnum.FAIL.getCode(), data);
    }
    // 获取消息
    public String getMsg() {
        return msg;
    }
    // 设置消息
    public void setMsg(String msg) {
        this.msg = msg;
    }
    // 获取状态码
    public Integer getCode() {
        return code;
    }
    // 设置状态码
    public void setCode(Integer code) {
        this.code = code;
    }
    // 获取数据
    public Object getData() {
        return data;
    }
    // 设置数据
    public void setData(Object data) {
        this.data = data;
    }
}

ResponseResultEnum 枚举类

package daily.commons.enumpojo;
/**
 * @Create 2025-03-01 20:19
 * @Description 回复结果 枚举类
 */
public enum ResponseResultEnum {
    SUCCESS(200, "操作成功"),
    FAIL(500, "操作失败"),
    UNAUTHORIZED(401, "未授权"),
    FORBIDDEN(403, "禁止访问"),
    NOT_FOUND(404, "资源不存在"),
    BAD_REQUEST(400, "请求参数错误"),
    METHOD_NOT_ALLOWED(405, "请求方法不允许"),
    REQUEST_TIMEOUT(408, "请求超时"),
    TOO_MANY_REQUESTS(429, "请求过于频繁"),
    ;
    private final int code;
    private final String msg;
    ResponseResultEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }
    // 可以添加 getter 方法以便外部访问这些字段
    public int getCode() {
        return code;
    }
    public String getMsg() {
        return msg;
    }   
}

4.1.4. manager模块

HelloController类

@RestController
@RequestMapping("hello")
@CrossOrigin //跨域请求失败解决
public class HelloController {
    @Autowired
    private HellerService hellerService;
    @RequestMapping("/find")
    public DataResult find() {
        List<Hello> list = hellerService.hello();
        if (list == null) {
            return DataResult.fail("服务异常");
        }
        return DataResult.success(list);
    }
}

HelloMapper 接口

public interface HelloMapper {
    List<Hello> findHello();
}

HellerService 接口

public interface HellerService {
    List<Hello> hello();
}

HelloServiceImpl 类

@Service
public class HelloServiceImpl implements HellerService {
    @Autowired
    private HelloMapper helloMapper;
    @Override
    public List<Hello> hello() {
        return helloMapper.findHello();
    }
}

HelloMapper.xml

<mapper namespace="daily.manager.mapper.HelloMapper">
  <resultMap id="HelloMap" type="daily.pojo.Hello">
    <id column="hello_id" property="helloId"/>
  </resultMap>
  <select id="findHello" resultMap="HelloMap">
    SELECT * FROM tb_hello
  </select>
</mapper>

4.1.5. 运行测试

4.2. 模块测试-02

测试cache模块的使用

4.2.1. 运行Redis

打开虚拟机,开启Redis

4.2.2. cache模块

RedisConfig 配置类

@Configuration
public class RedisConfig {
    /**
     * 创建并配置RedisTemplate实例
     * 该方法通过Spring的@Bean注解声明，确保在需要时能够返回一个完全配置好的RedisTemplate实例
     * 这个实例用于与Redis数据库进行交互，支持键值操作，其中键和值的序列化方式可以自定义
     *
     * @param factory LettuceConnectionFactory实例，用于连接Redis服务器
     *                该工厂配置了Redis连接的必要信息，如地址、端口、密码等
     * @return RedisTemplate<String, Object> 一个配置完成的RedisTemplate实例，
     * 可以直接用于操作Redis数据库
     */
    @Bean
    public RedisTemplate<String, Object> getTemplate(LettuceConnectionFactory factory) {
        // 创建一个RedisTemplate实例，用于操作键值为String类型和值为Object类型的Redis数据库
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 设置ConnectionFactory，这是与Redis服务器建立连接的关键配置
        redisTemplate.setConnectionFactory(factory);
        // 设置键的序列化方式为字符串，确保键以字符串形式存储和读取
        redisTemplate.setKeySerializer(RedisSerializer.string());
        // 设置Hash类型键的序列化方式为字符串，适用于Hash结构中的键
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        // 设置值的序列化方式为JSON，允许复杂对象被序列化后存储
        redisTemplate.setValueSerializer(RedisSerializer.json());
        // 设置Hash类型值的序列化方式为JSON，适用于Hash结构中的值
        redisTemplate.setHashValueSerializer(RedisSerializer.json());
        // 初始化RedisTemplate，确保所有必要属性配置完成
        redisTemplate.afterPropertiesSet();
        // 返回配置完成的RedisTemplate实例
        return redisTemplate;
    }
}

RedisCacheController

@RestController
@RequestMapping("/redis")
public class RedisCacheController {
    @Autowired
    private RedisCacheService redisCacheService;
    /**
     * 设置缓存中的键值对
     *
     * @param key 键，用于唯一标识缓存中的数据
     * @param value 值，存储在缓存中的数据
     * @return 返回操作结果
     */
    @PostMapping("/set")
    public DataResult set(@RequestParam String key, @RequestParam String value){
        return redisCacheService.set(key,value);
    }
    /**
     * 从缓存中获取指定键的数据
     *
     * @param key 键，用于唯一标识缓存中的数据
     * @return 返回获取到的数据结果
     */
    @GetMapping("get/{key}")
    public DataResult get(@PathVariable String key) {
        return redisCacheService.get(key);
    }
}

RedisCacheService 接口

public interface RedisCacheService {
    /**
     * 设置指定键的值
     * 如果键已存在，将覆盖原有值
     *
     * @param key   键，用于标识存储的数据
     * @param value 值，要存储的数据
     * @return 返回操作结果，包括是否成功
     */
    DataResult set(String key, String value);
    /**
     * 获取指定键的值
     *
     * @param key 键，用于检索存储的数据
     * @return 返回操作结果，包括是否成功和数据值
     */
    DataResult get(String key);
}

RedisCacheServiceImpl 类

@Service
public class RedisCacheServiceImpl implements RedisCacheService {
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;
    /**
     * 设置Redis中的键值对
     *
     * @param key 键，用于存储数据的标识
     * @param value 值，与键关联的数据
     * @return 返回操作结果，包括成功或失败的信息
     */
    @Override
    public DataResult set(String key, String value) {
        try {
            // 检查key和value是否为空，如果为空则返回错误信息
            if (key == null || value == null) {
                return DataResult.fail("key或者value不能为空");
            }
            // 在Redis中设置键值对
            redisTemplate.opsForValue().set(key, value);
            // 检查Redis中是否已存在该key，如果已存在则返回错误信息
            Boolean hasKey = redisTemplate.hasKey(key);
            if (!hasKey) {
                return DataResult.fail("添加失败!",hasKey);
            }
            // 返回成功信息
            return DataResult.success("添加成功! key为"+key+",value为"+value,hasKey);
        } catch (Exception e) {
            // 捕获异常并返回错误信息
            return DataResult.fail(e.getMessage());
        }
    }
    /**
     * 重写get方法，从Redis中获取数据
     *
     * @param key 数据的唯一标识
     * @return DataResult对象，包含操作结果和数据
     */
    @Override
    public DataResult get(String key) {
        try {
            // 检查Redis中是否存在指定的key
            Boolean hasKey = redisTemplate.hasKey(key);
            // 如果key不存在或为null，则返回失败结果，并提示key不存在
            if (!hasKey) {
                return DataResult.fail("未查询到数据,key:"+key+"在数据库中不存在",hasKey);
            }
            // 从Redis中获取key对应的值
            Object o = redisTemplate.opsForValue().get(key);
            // 如果获取到的值为null，则返回失败结果，并提示未查询到数据
            if (o == null) {
                return DataResult.fail("未查询到数据",false);
            }
            // 返回成功结果，包含查询到的数据
            return DataResult.success("查询成功",o.toString());
        } catch (Exception e) {
            // 捕获异常，并返回失败结果，包含异常信息
            return DataResult.fail(e.getMessage());
        }
    }
}

4.2.3. 测试

Redis中写入数据

Redis中读取数据

5. 结尾

更高版本的jdk,Spring,以及SpringCloud相较于之前的配置有些许的不同
经常是版本的冲突问题还有些注解的问题等等

到此这篇关于从零搭建SpringCloud的超详细过程的文章就介绍到这了,更多相关SpringCloud搭建内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

从零搭建SpringCloud的超详细过程

1. 引言

2. 介绍

2.1. 项目简介

3. SpringCloud的搭建

3.1. 父工程项目的搭建

3.2. 子模块项目的搭建

3.3. 子模块搭建 -- eureka

3.4. 子模块搭建 -- entity

3.5. 子模块搭建 -- commons

3.6. 子模块搭建 -- gateway

3.7. 子模块搭建 -- cache

3.8. 子模块搭建 -- manager

4. 模块测试

4.1. 模块测试-01

4.1.1. 数据库配置

4.1.2. entity模块

4.1.3. commons模块

4.1.4. manager模块

4.1.5. 运行测试

4.2. 模块测试-02

4.2.1. 运行Redis

4.2.2. cache模块

4.2.3. 测试

5. 结尾

您可能感兴趣的文章: