從零搭建SpringCloud的超詳細過程

更新時間：2025年09月18日 12:01:07 作者：晚風亂了溫柔

本文給大家詳細介紹從零搭建SpringCloud的超詳細過程,本文通過圖文實例代碼相結(jié)合給大家介紹的非常詳細,對大家的學習或工作具有一定的參考借鑒價值,需要的朋友參考下吧

1. 引言

環(huán)境 : Windows、jdk17、IntelliJ Idea
‌目標 : 使用SpringBoot3.4和Springcloud2024,搭建一個基礎的SpringCloud

2. 介紹

記錄本人從零搭建SpringCloud的過程

SpringCloud官網(wǎng) : Spring Cloud

版本適配

2.1. 項目簡介

計劃搭建多個項目模塊
eureka 模塊 : 項目的服務注冊中心
entity 模塊 : 存放項目的實體類
commons 模塊 : 存放項目的公共類和工具類等
gateway 模塊 : 服務網(wǎng)關(guān)和服務調(diào)用模塊
cache 模塊 : 項目的緩存模塊,如操作Redis等
manager 模塊 : 項目的管理使用模塊

3. SpringCloud的搭建

3.1. 父工程項目的搭建

在 File --> new project --> 選擇Java類型的項目
設置相關(guān)信息后點擊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. 子模塊項目的搭建

選中文件你創(chuàng)建的文件(springcloud-template)
右鍵 --> new --> module
此時沒什么要配置的只要取名字之后, create

ps :

項目的每一個子模塊都是如此創(chuàng)建

3.3. 子模塊搭建 -- eureka

eureka 是Springcloud 的服務注冊中心,所以我們優(yōu)先搭建此模塊

配置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  # 關(guān)閉注冊到Eureka服務器的功能
    fetchRegistry: false  # 關(guān)閉從Eureka服務器獲取注冊信息的功能
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/  # 設置Eureka服務器的地址

daily-eureka --> src --> main --> Java 文件下
創(chuàng)建啟動類 EurekaServerStartApp

// 啟動應用程序的主類，使用Spring Boot的自動配置功能
@SpringBootApplication
// 啟用Eureka Server功能，使該應用作為服務注冊中心
@EnableEurekaServer
public class EurekaServerStartApp {
    /**
     * 主函數(shù)入口
     * 啟動Spring Boot應用，使其作為一個Eureka客戶端，連接到Eureka服務器
     *
     * @param args 命令行參數(shù)，通常用于傳遞配置信息或啟動參數(shù)
     */
    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 子模塊,是放一寫公共類的模塊,如返回結(jié)果,工具類等
不屬于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客戶端，用于服務發(fā)現(xiàn) -->
        <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調(diào)用 -->
        <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服務器的地址，用于服務注冊和發(fā)現(xiàn)
spring:
  application:
    name: daily-gateway  # 起一個服務名稱，用于在Eureka服務器上注冊

創(chuàng)建啟動類 GatewayServerStartApp
在 Spring Cloud 中，@EnableEurekaClient 注解用于啟用 Eureka 客戶端，使得應用程序可以注冊到 Eureka Server 并發(fā)現(xiàn)其他服務。但是，從 Spring Cloud Netflix 版本 2.0 開始，官方推薦的做法是使用 @EnableDiscoveryClient 注解，而不是 @EnableEurekaClient。這是因為 @EnableDiscoveryClient 更加通用，可以與多種服務發(fā)現(xiàn)機制（例如 Eureka, Consul, Zookeeper 等）一起使用。

如果你的項目是基于 Spring Cloud Netflix 并使用了 spring-cloud-starter-netflix-eureka-client 4.2.0 版本，你應該注意到以下幾點：

使用 @EnableDiscoveryClient 注解：

如果你的項目是基于 Spring Cloud Netflix 并希望保持與未來版本的兼容性，你應該使用 @EnableDiscoveryClient 注解

// 啟動Spring Boot應用程序
@SpringBootApplication
// 啟用Eureka客戶端，使應用能夠注冊和發(fā)現(xiàn)其他微服務
@EnableDiscoveryClient
// 啟用Zuul代理，使應用成為API網(wǎng)關(guān)，負責路由和過濾請求
@EnableZuulProxy
// 啟用Feign客戶端，簡化HTTP調(diào)用，實現(xiàn)服務間調(diào)用
@EnableFeignClients
public class GatewayServerStartApp {
    /**
     * main方法是Java應用程序的入口點
     * 這里使用SpringApplication.run來啟動Spring Boot應用
     *
     * @param args 命令行參數(shù)，允許在啟動時傳遞配置信息
     */
    public static void main(String[] args) {
        SpringApplication.run(GatewayServerStartApp.class, args);
    }
}

啟動測試

ps:

需要先啟動eureka,否則會啟動報錯

3.7. 子模塊搭建 -- cache

cache 子模塊用于項目的緩存服務,例如Redis相關(guān)的服務
屬于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客戶端，用于服務發(fā)現(xiàn) -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- 依賴于Spring Boot Redis模塊，用于操作Redis數(shù)據(jù)庫 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- 依賴項：Fastjson
             Fastjson是阿里巴巴的一個開源項目，它是一個Java語言編寫的高性能功能完備的JSON庫。
             它可以用來將Java對象轉(zhuǎn)換為JSON字符串，也可以將JSON字符串轉(zhuǎn)換為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服務器的地址，用于服務發(fā)現(xiàn)與注冊
spring:
  application:
    name: daily-cache  # 起一個服務名稱，便于在Eureka服務器中識別
  redis:
    host: 192.168.233.134  # 配置Redis服務器的主機地址
    port: 6379  # 配置Redis服務器的端口號
    password: root  # 配置訪問Redis服務器的密碼

創(chuàng)建啟動類

@SpringBootApplication
@EnableDiscoveryClient
public class CacheServerStartApp {
    /**
     * main 方法是應用程序的入口點
     * 它使用 Spring Boot 的 SpringApplication.run 方法來啟動應用程序
     *
     * @param args 命令行參數(shù)，允許在應用程序啟動時傳遞參數(shù)
     */
    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模塊，用于創(chuàng)建Web應用 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 依賴于Eureka客戶端，用于服務發(fā)現(xiàn)和服務注冊 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- 依賴于OpenFeign，用于聲明式REST調(diào)用 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!-- 依賴于MyBatis，用于ORM操作數(shù)據(jù)庫 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.4</version>
        </dependency>
        <!-- 依賴于MySQL數(shù)據(jù)庫驅(qū)動 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        <!-- 依賴于Druid數(shù)據(jù)源，用于數(shù)據(jù)庫連接池管理 -->
        <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文件
數(shù)據(jù)庫名字自己寫

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數(shù)據(jù)源驅(qū)動
    url: jdbc:mysql://localhost:3306/{需要連接的數(shù)據(jù)庫名字}?characterEncoding=UTF-8&serverTimezone=Asia/Shanghai # 設置數(shù)據(jù)庫連接URL
    username: root # 數(shù)據(jù)庫用戶名
    password: root # 數(shù)據(jù)庫密碼
#    type: com.alibaba.druid.pool.DruidDataSource # 指定數(shù)據(jù)源類型為Druid
mybatis:
  mapper-locations: classpath:mapper/*.xml # 配置MyBatis的映射文件位置

創(chuàng)建啟動類

// 啟動Spring Boot應用程序
@SpringBootApplication
// 啟用Eureka客戶端，使該應用能夠注冊和發(fā)現(xiàn)其他微服務
@EnableDiscoveryClient
// 啟用Feign客戶端，用于聲明式REST調(diào)用
@EnableFeignClients
// 指定MyBatis Plus的Mapper接口所在包，以便進行統(tǒng)一掃描
@MapperScan("daily.manager.mapper")
public class ManagerStartApp {
    /**
     * 主函數(shù)入口
     * 它負責啟動Spring應用，通過傳入當前類和命令行參數(shù)來引導應用的執(zhí)行
     *
     * @param args 命令行參數(shù)，允許在啟動時傳遞配置信息
     */
    public static void main(String[] args) {
        SpringApplication.run(ManagerStartApp.class, args);
    }
}

創(chuàng)建空文件夾

設置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. 數(shù)據(jù)庫配置

新建表數(shù)據(jù)用于測試

CREATE TABLE tb_hello(
    hello_id INT NOT NULL AUTO_INCREMENT  COMMENT '編號' ,
    title VARCHAR(32)    COMMENT '標題' ,
    status INT    COMMENT '狀態(tài)' ,
    PRIMARY KEY (hello_id)
) COMMENT = 'hello表 ';

添加數(shù)據(jù)

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

測試entity模塊,commons模塊,manager模塊的使用

文件結(jié)構(gòu)如下

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響應結(jié)果
 * 它提供了靜態(tài)方法來創(chuàng)建表示成功或失敗的響應對象，包含消息、狀態(tài)碼和數(shù)據(jù)
 */
public class DataResult {
    private String msg;
    private Integer code;
    private Object data;
    // 默認構(gòu)造函數(shù)
    public DataResult() {
    }
    // 只含消息的構(gòu)造函數(shù)
    public DataResult(String msg) {
        this.msg = msg;
    }
    // 含消息和狀態(tài)碼的構(gòu)造函數(shù)
    public DataResult(String msg, Integer code) {
        this.msg = msg;
        this.code = code;
    }
    // 含消息、狀態(tài)碼和數(shù)據(jù)的構(gòu)造函數(shù)
    public DataResult(String msg, Integer code, Object data) {
        this.msg = msg;
        this.code = code;
        this.data = data;
    }
    /**
     * 創(chuàng)建一個表示成功的DataResult對象
     * 使用默認的成功消息和狀態(tài)碼
     *
     * @return 表示成功的DataResult對象
     */
    public static DataResult success() {
        return new DataResult(ResponseResultEnum.SUCCESS.getMsg(), ResponseResultEnum.SUCCESS.getCode());
    }
    /**
     * 創(chuàng)建一個表示成功的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());
    }
    /**
     * 創(chuàng)建一個表示成功的DataResult對象，包含數(shù)據(jù)
     * 如果消息為空，則使用默認的成功消息；如果數(shù)據(jù)為空，則使用空字符串作為數(shù)據(jù)
     *
     * @param msg 成功消息，如果為空則使用默認消息
     * @param data 成功數(shù)據(jù)，如果為空則使用空字符串
     * @return 包含數(shù)據(jù)的表示成功的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);
    }
    /**
     * 創(chuàng)建一個表示成功的DataResult對象，包含數(shù)據(jù)
     * 使用默認的成功消息，如果數(shù)據(jù)為空，則使用空字符串作為數(shù)據(jù)
     *
     * @param data 成功數(shù)據(jù)，如果為空則使用空字符串
     * @return 包含數(shù)據(jù)的表示成功的DataResult對象
     */
    public static DataResult success(Object data) {
        if (data == null) {
            data = "";
        }
        return new DataResult(ResponseResultEnum.SUCCESS.getMsg(), ResponseResultEnum.SUCCESS.getCode(), data);
    }
    /**
     * 創(chuàng)建一個表示失敗的DataResult對象
     * 使用默認的失敗消息和狀態(tài)碼
     *
     * @return 表示失敗的DataResult對象
     */
    public static DataResult fail() {
        return new DataResult(ResponseResultEnum.FAIL.getMsg(), ResponseResultEnum.FAIL.getCode());
    }
    /**
     * 創(chuàng)建一個表示失敗的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());
    }
    /**
     * 創(chuàng)建一個表示失敗的DataResult對象，包含數(shù)據(jù)
     * 如果消息為空，則使用默認的失敗消息；如果數(shù)據(jù)為空，則使用空字符串作為數(shù)據(jù)
     *
     * @param msg 失敗消息，如果為空則使用默認消息
     * @param data 失敗數(shù)據(jù)，如果為空則使用空字符串
     * @return 包含數(shù)據(jù)的表示失敗的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);
    }
    /**
     * 創(chuàng)建一個表示失敗的DataResult對象，包含數(shù)據(jù)
     * 使用默認的失敗消息，如果數(shù)據(jù)為空，則使用空字符串作為數(shù)據(jù)
     *
     * @param data 失敗數(shù)據(jù)，如果為空則使用空字符串
     * @return 包含數(shù)據(jù)的表示失敗的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;
    }
    // 獲取狀態(tài)碼
    public Integer getCode() {
        return code;
    }
    // 設置狀態(tài)碼
    public void setCode(Integer code) {
        this.code = code;
    }
    // 獲取數(shù)據(jù)
    public Object getData() {
        return data;
    }
    // 設置數(shù)據(jù)
    public void setData(Object data) {
        this.data = data;
    }
}

ResponseResultEnum 枚舉類

package daily.commons.enumpojo;
/**
 * @Create 2025-03-01 20:19
 * @Description 回復結(jié)果 枚舉類
 */
public enum ResponseResultEnum {
    SUCCESS(200, "操作成功"),
    FAIL(500, "操作失敗"),
    UNAUTHORIZED(401, "未授權(quán)"),
    FORBIDDEN(403, "禁止訪問"),
    NOT_FOUND(404, "資源不存在"),
    BAD_REQUEST(400, "請求參數(shù)錯誤"),
    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 {
    /**
     * 創(chuàng)建并配置RedisTemplate實例
     * 該方法通過Spring的@Bean注解聲明，確保在需要時能夠返回一個完全配置好的RedisTemplate實例
     * 這個實例用于與Redis數(shù)據(jù)庫進行交互，支持鍵值操作，其中鍵和值的序列化方式可以自定義
     *
     * @param factory LettuceConnectionFactory實例，用于連接Redis服務器
     *                該工廠配置了Redis連接的必要信息，如地址、端口、密碼等
     * @return RedisTemplate<String, Object> 一個配置完成的RedisTemplate實例，
     * 可以直接用于操作Redis數(shù)據(jù)庫
     */
    @Bean
    public RedisTemplate<String, Object> getTemplate(LettuceConnectionFactory factory) {
        // 創(chuàng)建一個RedisTemplate實例，用于操作鍵值為String類型和值為Object類型的Redis數(shù)據(jù)庫
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 設置ConnectionFactory，這是與Redis服務器建立連接的關(guān)鍵配置
        redisTemplate.setConnectionFactory(factory);
        // 設置鍵的序列化方式為字符串，確保鍵以字符串形式存儲和讀取
        redisTemplate.setKeySerializer(RedisSerializer.string());
        // 設置Hash類型鍵的序列化方式為字符串，適用于Hash結(jié)構(gòu)中的鍵
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        // 設置值的序列化方式為JSON，允許復雜對象被序列化后存儲
        redisTemplate.setValueSerializer(RedisSerializer.json());
        // 設置Hash類型值的序列化方式為JSON，適用于Hash結(jié)構(gòu)中的值
        redisTemplate.setHashValueSerializer(RedisSerializer.json());
        // 初始化RedisTemplate，確保所有必要屬性配置完成
        redisTemplate.afterPropertiesSet();
        // 返回配置完成的RedisTemplate實例
        return redisTemplate;
    }
}

RedisCacheController

@RestController
@RequestMapping("/redis")
public class RedisCacheController {
    @Autowired
    private RedisCacheService redisCacheService;
    /**
     * 設置緩存中的鍵值對
     *
     * @param key 鍵，用于唯一標識緩存中的數(shù)據(jù)
     * @param value 值，存儲在緩存中的數(shù)據(jù)
     * @return 返回操作結(jié)果
     */
    @PostMapping("/set")
    public DataResult set(@RequestParam String key, @RequestParam String value){
        return redisCacheService.set(key,value);
    }
    /**
     * 從緩存中獲取指定鍵的數(shù)據(jù)
     *
     * @param key 鍵，用于唯一標識緩存中的數(shù)據(jù)
     * @return 返回獲取到的數(shù)據(jù)結(jié)果
     */
    @GetMapping("get/{key}")
    public DataResult get(@PathVariable String key) {
        return redisCacheService.get(key);
    }
}

RedisCacheService 接口

public interface RedisCacheService {
    /**
     * 設置指定鍵的值
     * 如果鍵已存在，將覆蓋原有值
     *
     * @param key   鍵，用于標識存儲的數(shù)據(jù)
     * @param value 值，要存儲的數(shù)據(jù)
     * @return 返回操作結(jié)果，包括是否成功
     */
    DataResult set(String key, String value);
    /**
     * 獲取指定鍵的值
     *
     * @param key 鍵，用于檢索存儲的數(shù)據(jù)
     * @return 返回操作結(jié)果，包括是否成功和數(shù)據(jù)值
     */
    DataResult get(String key);
}

RedisCacheServiceImpl 類?????

@Service
public class RedisCacheServiceImpl implements RedisCacheService {
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;
    /**
     * 設置Redis中的鍵值對
     *
     * @param key 鍵，用于存儲數(shù)據(jù)的標識
     * @param value 值，與鍵關(guān)聯(lián)的數(shù)據(jù)
     * @return 返回操作結(jié)果，包括成功或失敗的信息
     */
    @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中獲取數(shù)據(jù)
     *
     * @param key 數(shù)據(jù)的唯一標識
     * @return DataResult對象，包含操作結(jié)果和數(shù)據(jù)
     */
    @Override
    public DataResult get(String key) {
        try {
            // 檢查Redis中是否存在指定的key
            Boolean hasKey = redisTemplate.hasKey(key);
            // 如果key不存在或為null，則返回失敗結(jié)果，并提示key不存在
            if (!hasKey) {
                return DataResult.fail("未查詢到數(shù)據(jù),key:"+key+"在數(shù)據(jù)庫中不存在",hasKey);
            }
            // 從Redis中獲取key對應的值
            Object o = redisTemplate.opsForValue().get(key);
            // 如果獲取到的值為null，則返回失敗結(jié)果，并提示未查詢到數(shù)據(jù)
            if (o == null) {
                return DataResult.fail("未查詢到數(shù)據(jù)",false);
            }
            // 返回成功結(jié)果，包含查詢到的數(shù)據(jù)
            return DataResult.success("查詢成功",o.toString());
        } catch (Exception e) {
            // 捕獲異常，并返回失敗結(jié)果，包含異常信息
            return DataResult.fail(e.getMessage());
        }
    }
}