SpringCloud 学习笔记

技术	版本
Java	jdk17+
boot	3.2.0
cloud	2023.0.0
cloud alibaba	2022.0.0.0-RC2
Maven	3.9+
MySQL	8.0+

SpringCloud 学习笔记 | 极客日志

CREATE DATABASE db2024;
USE db2024;
DROP TABLE IF EXISTS `t_pay`;
CREATE TABLE `t_pay` (
  `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
  `pay_no` VARCHAR(50) NOT NULL COMMENT '支付流水号',
  `order_no` VARCHAR(50) NOT NULL COMMENT '订单流水号',
  `user_id` INT(10) DEFAULT '1' COMMENT '用户账号 ID',
  `amount` DECIMAL(8,2) NOT NULL DEFAULT '9.9' COMMENT '交易金额',
  `deleted` TINYINT(4) UNSIGNED NOT NULL DEFAULT '0' COMMENT '删除标志，默认 0 不删除，1 删除',
  `create_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='支付交易表';
INSERT INTO t_pay(pay_no,order_no) VALUES('pay17203699','6544bafb424a');
SELECT * FROM t_pay;

<properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <hutool.version>5.8.22</hutool.version>
    <druid.version>1.1.20</druid.version>
    <mybatis.springboot.version>3.0.3</mybatis.springboot.version>
    <mysql.version>8.0.11</mysql.version>
    <swagger3.version>2.2.0</swagger3.version>
    <mapper.version>4.2.3</mapper.version>
    <fastjson2.version>2.0.40</fastjson2.version>
    <persistence-api.version>1.0.2</persistence-api.version>
    <spring.boot.test.version>3.1.5</spring.boot.test.version>
    <spring.boot.version>3.2.0</spring.boot.version>
    <spring.cloud.version>2023.0.0</spring.cloud.version>
    <spring.cloud.alibaba.version>2022.0.0.0-RC2</spring.cloud.alibaba.version>
</properties>
<dependencyManagement>
    <dependencies>
        <!--springboot 3.2.0-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>${spring.boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!--springcloud 2023.0.0-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring.cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!--springcloud alibaba 2022.0.0.0-RC2-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>${spring.cloud.alibaba.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!--SpringBoot 集成 mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.springboot.version}</version>
        </dependency>
        <!--Mysql 数据库驱动 8 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!--SpringBoot 集成 druid 连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <!--通用 Mapper4 之 tk.mybatis-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>${mapper.version}</version>
        </dependency>
        <!--persistence-->
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>persistence-api</artifactId>
            <version>${persistence-api.version}</version>
        </dependency>
        <!-- fastjson2 -->
        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>${fastjson2.version}</version>
        </dependency>
        <!-- swagger3 调用方式 http://你的主机 IP 地址:5555/swagger-ui/index.html -->
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
            <version>${swagger3.version}</version>
        </dependency>
        <!--hutool-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>${hutool.version}</version>
        </dependency>
        <!-- spring-boot-starter-test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>${spring.boot.test.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <properties resource="config.properties"/>
    <context id="Mysql" targetRuntime="MyBatis3Simple" defaultModelType="flat">
        <property name="beginningDelimiter" value="`"/>
        <property name="endingDelimiter" value="`"/>
        <plugin type="tk.mybatis.mapper.generator.MapperPlugin">
            <property name="mappers" value="tk.mybatis.mapper.common.Mapper"/>
            <property name="caseSensitive" value="true"/>
        </plugin>
        <jdbcConnection driverClass="${jdbc.driverClass}" connectionURL="${jdbc.url}" userId="${jdbc.user}" password="${jdbc.password}"></jdbcConnection>
        <javaModelGenerator targetPackage="${package.name}.entities" targetProject="src/main/java"/>
        <sqlMapGenerator targetPackage="${package.name}.mapper" targetProject="src/main/java"/>
        <javaClientGenerator targetPackage="${package.name}.mapper" targetProject="src/main/java" type="XMLMAPPER"/>
        <table tableName="t_pay" domainObjectName="Pay">
            <generatedKey column="id" sqlStatement="JDBC"/>
        </table>
    </context>
</generatorConfiguration>

#t_pay 表包名 package.name=com.example.cloud 
# mysql8.0 jdbc.driverClass = com.mysql.cj.jdbc.Driver 
jdbc.url= jdbc:mysql://localhost:3306/db2024?characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8&rewriteBatchedStatements=true&allowPublicKeyRetrieval=true 
jdbc.user = root 
jdbc.password =123456

<dependencies>
    <!--Mybatis 通用 mapper tk 单独使用，自己独有 + 自带版本号-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.13</version>
    </dependency>
    <!-- Mybatis Generator 自己独有 + 自带版本号-->
    <dependency>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-core</artifactId>
        <version>1.4.2</version>
    </dependency>
    <!--通用 Mapper-->
    <dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper</artifactId>
    </dependency>
    <!--mysql8.0-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--persistence-->
    <dependency>
        <groupId>javax.persistence</groupId>
        <artifactId>persistence-api</artifactId>
    </dependency>
    <!--hutool-->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
    </dependency>
    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>
<build>
    <resources>
        <resource>
            <directory>${basedir}/src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
        <resource>
            <directory>${basedir}/src/main/resources</directory>
        </resource>
    </resources>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <excludes>
                    <exclude>
                        <groupId>org.projectlombok</groupId>
                        <artifactId>lombok</artifactId>
                    </exclude>
                </excludes>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.4.2</version>
            <configuration>
                <configurationFile>${basedir}/src/main/resources/generatorConfig.xml</configurationFile>
                <overwrite>true</overwrite>
                <verbose>true</verbose>
            </configuration>
            <dependencies>
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>8.0.33</version>
                </dependency>
                <dependency>
                    <groupId>tk.mybatis</groupId>
                    <artifactId>mapper</artifactId>
                    <version>4.2.3</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

@SpringBootApplication
@MapperScan("com.example.cloud.mapper")
public class Main8001 {
    public static void main(String[] args) {
        SpringApplication.run(Main8001.class, args);
    }
}

server:
  port: 8001
spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db2024?characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8&rewriteBatchedStatements=true&allowPublicKeyRetrieval=true
    username: root
    password: 123456
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.example.cloud.entities
  configuration:
    map-underscore-to-camel-case: true

<dependencies>
    <!--SpringBoot 通用依赖模块-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--SpringBoot 集成 druid 连接池-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
    </dependency>
    <!-- Swagger3 调用方式 http://localhost:8001/swagger-ui/index.html -->
    <dependency>
        <groupId>org.springdoc</groupId>
        <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    </dependency>
    <!--mybatis 和 springboot 整合-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    <!--Mysql 数据库驱动 8 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--persistence-->
    <dependency>
        <groupId>javax.persistence</groupId>
        <artifactId>persistence-api</artifactId>
    </dependency>
    <!--通用 Mapper4-->
    <dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper</artifactId>
    </dependency>
    <!--hutool-->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
    </dependency>
    <!-- fastjson2 -->
    <dependency>
        <groupId>com.alibaba.fastjson2</groupId>
        <artifactId>fastjson2</artifactId>
    </dependency>
    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.28</version>
        <scope>provided</scope>
    </dependency>
    <!--test-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>3.2.0</version>
        </plugin>
    </plugins>
</build>

注解	标注位置
@Tag	Controller 类
@Operation	方法上
@Schema	model 层的 bean 和 bean 的方法上

localhost:8001/swagger-ui/index.html

@Configuration
public class SwaggerConfiguration {
    @Bean
    public GroupedOpenApi PayApi() {
        //以/pay开头的请求都是支付模块
        return GroupedOpenApi.builder()
                .group("支付微服务模块")
                .pathsToMatch("/pay/**")
                .build();
    }
    @Bean
    public GroupedOpenApi OtherApi() {
        //以/other开头的都是其他模块的请求
        return GroupedOpenApi.builder()
                .group("其它微服务模块")
                .pathsToMatch("/other/**", "/others")
                .build();
    }
    @Bean
    public OpenAPI docsOpenApi() {
        return new OpenAPI().info(new Info().title("cloud2024").description("通用设计 rest").version("v1.0"));
    }
}

@Operation(summary="查询所有订单")

@Tag(name ="支付模块")

<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>${swagger3.version}</version>
</dependency>

@Operation(summary ="添加支付记录")
@PostMapping(value ="/pay/add")
public ResultData<String> addPay(@RequestBody Pay pay) {
    System.out.println(pay.toString());
    int add = payService.add(pay);
    return ResultData.success("添加成功" + add + "条记录");
}

@Data
@Accessors(chain = true)
public class ResultData<T> {
    private String code;
    private String message;
    private T data;
    private long timestamp; //调用方法的时间戳

    public ResultData() {
        this.timestamp = System.currentTimeMillis();
    }

    public static <T> ResultData<T> success(T data) {
        ResultData<T> resultData = new ResultData<>();
        resultData.setCode(ReturnCodeEnum.RC200.getCode());
        resultData.setMessage(ReturnCodeEnum.RC200.getMessage());
        resultData.setData(data);
        return resultData;
    }

    public static <T> ResultData<T> fail(String code, String message) {
        ResultData<T> resultData = new ResultData<>();
        resultData.setCode(code);
        resultData.setMessage(message);
        return resultData;
    }
}

@Getter
public enum ReturnCodeEnum {
    //1.举值
    RC999("999", "操作 XXX 失败"),
    RC200("200", "success"),
    RC201("201", "服务开启降级保护，请稍后再试!"),
    RC202("202", "热点参数限流，请稍后再试!"),
    RC203("203", "系统规则不满足要求，请稍后再试!"),
    RC204("204", "授权规则不通过，请稍后再试!"),
    RC403("403", "无访问权限，请联系管理员授予权限"),
    RC401("401", "匿名用户访问无权限资源时的异常"),
    RC404("404", "404 页面找不到的异常"),
    RC500("500", "系统异常，请稍后重试"),
    RC375("375", "数学运算异常，请稍后重试"),
    INVALID_TOKEN("2001", "访问令牌不合法"),
    ACCESS_DENIED("2003", "没有权限访问该资源"),
    CLIENT_AUTHENTICATION_FAILED("1001", "客户端认证失败"),
    USERNAME_OR_PASSWORD_ERROR("1002", "用户名或密码错误"),
    BUSINESS_ERROR("1004", "业务逻辑异常"),
    UNSUPPORTED_GRANT_TYPE("1003", "不支持的认证模式");

    //2.构造
    private final String code; //自定义状态码，对应前面枚举的第一个参数
    private final String message; //自定义信息，对应前面枚举的第二个参数

    ReturnCodeEnum(String code, String message) {
        this.code = code;
        this.message = message;
    }

    //3.遍历
    public static ReturnCodeEnum getReturnCodeEnum(String code) {
        //传入一个状态码，如果有，就返回整个枚举信息，如果没有就返回空
        for (ReturnCodeEnum element : ReturnCodeEnum.values()) {
            if (element.getCode().equalsIgnoreCase(code)) {
                return element;
            }
        }
        return null;
    }
}

spring:
  jackson:
    date-format: yyyy-MM-dd HH-mm-ss
    time-zone: GMT+8

@JsonFormat(pattern ="yyyy-MM-dd HH-mm-ss", timezone ="GMT+8")
private Date createTime;

@RestControllerAdvice
public class GlobalExceptionHandler {
    //注解的参数是处理的异常信息类型，什么都不加就是全局异常处理
    //@ExceptionHandler(SQlException.class) 这个就是专门处理 sql 异常
    @ExceptionHandler()
    public ResultData<String> globalException(Exception e) {
        e.printStackTrace();
        return ResultData.fail(ReturnCodeEnum.RC500.getCode(), ReturnCodeEnum.RC500.getMessage());
    }
}

@RestController
public class OrderController {
    private String url ="http://localhost:8001";
    //使用 httpclient 调用 pay 模块的相关接口
    @GetMapping("/consumer/pay/add")
    public ResultData addOrder(PayDTO payDTO) throws IOException {
        //创建 httpclient 客户端
        CloseableHttpClient aDefault = HttpClients.createDefault();
        //创建一个 post 请求
        HttpPost httpPost = new HttpPost(url + "/pay/add");
        //将本方法的参收构建为 json 字符串
        String jsonString = JSON.toJSONString(payDTO);
        //将 json 字符串构建为 StringEntity
        StringEntity stringEntity = new StringEntity(jsonString);
        //设置请求头和编码格式
        stringEntity.setContentType("application/json");
        stringEntity.setContentEncoding("UTF-8");
        //将参数传入 post 请求
        httpPost.setEntity(stringEntity);
        //httpclient 客户端执行请求
        CloseableHttpResponse execute = aDefault.execute(httpPost);
        //获取响应实体
        HttpEntity entity = execute.getEntity();
        //将实体转化为 json 字符串
        String string = EntityUtils.toString(entity);
        //将字符串转化为 json 对象
        JSONObject jsonObject = JSON.parseObject(string);
        //从对象中获取对应的参数
        String code = (String) jsonObject.get("code");
        String data = (String) jsonObject.get("data");
        if (code.equals("200")) {
            return ResultData.success("调用成功 data=" + data);
        } else {
            return ResultData.fail(code, (String) jsonObject.get("message"));
        }
    }

    @GetMapping("/consumer/pay/get/{id}")
    public ResultData getPayInfo(@PathVariable("id") Integer id) throws IOException {
        CloseableHttpClient aDefault = HttpClients.createDefault();
        HttpGet httpGet = new HttpGet(url + "/pay/get/" + id);
        CloseableHttpResponse execute = aDefault.execute(httpGet);
        HttpEntity entity = execute.getEntity();
        String string = EntityUtils.toString(entity);
        JSONObject jsonObject = JSON.parseObject(string);
        String code = (String) jsonObject.get("code");
        Object data = jsonObject.get("data");
        if (code.equals("200")) {
            return ResultData.success(data);
        } else {
            return ResultData.fail(code, (String) jsonObject.get("message"));
        }
    }
}

//1.get 请求【两个方法任选一个】
//两个方法的参数一样：①url 请求地址 ②请求参数【可以省略】 ③返回值接收对象类型
//只接受返回对象用这个：restTemplate.getForObject("请求地址",参数，返回值对象类型)
Result result = restTemplate.getForObject("http://localhost:8080/order/getPayResult", Result.class);
//全部响应体用这个：restTemplate.getForEntity("请求地址",参数，返回值对象类型)
ResponseEntity<Result> forEntity = restTemplate.getForEntity("http://localhost:8001/pay/get/all", Result.class);
//2.post 请求【两个方法任选一个】
//两个方法的参数一样：①url 请求地址 ②请求参数 ③返回值接收对象类型
//只接受返回对象用这个：restTemplate.postForObject("请求地址",参数，返回值对象类型)
Result result = restTemplate.postForObject("http://localhost:8080/order/getPayResult", pay, Result.class);
//全部响应体用这个：restTemplate.postForEntity("请求地址",参数，返回值对象类型)
ResponseEntity<String> stringResponseEntity = restTemplate.postForEntity("http://localhost:8080/order/getPayResult", pay, String.class);
//3.delete 请求
//方法的参数：①url 请求地址 restTemplate.delete("http://localhost:8080/order/getPayResult");
//4.put 请求
//方法的参数：①url 请求地址 ②请求参数 restTemplate.put("http://localhost:8080/order/getPayResult", pay);

//两种方式
//1.使用的时候直接 new
RestTemplate restTemplate = new RestTemplate();
//2.在容器中配置一个
@Configuration
public class OrderConfiguration {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

SpringBootWeb 中自带，所以如果是一个 web 项目就不需要导入额外的依赖了

<dependency>
    <groupId>com.example.cloud</groupId>
    <artifactId>cloud-api-commons</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

<dependencies>
    <!--SpringBoot 通用依赖模块-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!--hutool-->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
    </dependency>
    <dependency>
        <groupId>javax.persistence</groupId>
        <artifactId>persistence-api</artifactId>
    </dependency>
</dependencies>

localhost:8500

consul agent -dev

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}

private String url ="http://cloud-payment-service";

@EnableDiscoveryClient

spring:
  #当前服务名
  application:
    name: cloud-pay-service
  #配置注册中心的地址
  cloud:
    consul:
      host: localhost
      port: 8500
    discovery:
      #配置当前服务注册到里面使用的名字
      service-name: ${spring.application.name}
      #开启 consul 的健康检查
      heartbeat:
        enabled: true
        ttl: 10s

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-consul-discovery</artifactId>
</dependency>

//从 application.yml 中获取
@Value("${server.port}")
private String port;
@Value("${altman.info}")
String info;
@GetMapping(value ="/pay/get/consul")
//从 consul 中获取
public ResultData getConsul(@Value("${altman.info}") String info) {
    return ResultData.success(info + "当前端口号" + port);
}

server:
  port: 8001
spring:
  jackson:
    date-format: yyyy-MM-dd HH-mm-ss
    time-zone: GMT+8
  mybatis:
    mapper-locations: classpath:mapper/*.xml
    type-aliases-package: com.example.pojo
    configuration:
      map-underscore-to-camel-case: true

spring:
  #当前服务名
  application:
    name: cloud-pay-service
  #配置注册中心的地址
  cloud:
    consul:
      host: localhost
      port: 8500
    discovery:
      #配置当前服务注册到里面使用的名字
      service-name: ${spring.application.name}
      #开启 consul 的健康检查
      heartbeat:
        enabled: true
        ttl: 10s
  #服务配置
  config:
    #这个是配置文件名以 - 连接【consul 的 k-v 存储用到】，例如：cloud-payment-service
    profile-separator: '-'
    #说明 consul 中 kv 的文本格式
    format: YAML
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db2024?characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8&rewriteBatchedStatements=true&allowPublicKeyRetrieval=true
    #读取 consul 中的配置到这里
    username: ${mysql.username}
    password: ${mysql.password}

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-consul-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bootstrap</artifactId>
</dependency>

spring:
  application:
    name: cloud-payment-service
  cloud:
    consul:
      host: localhost
      port: 8500
    discovery:
      service-name: ${spring.application.name}
    config:
      profile-separator: '-'
      format: YAML
      #设置了这里，1s 刷新
      watch:
        wait-time: 1

public static final String PaymentSrv_URL = "http://cloud-payment-service";

RestTemplate 和 WebClient 支持使用@LoadBalanced 注解实现负载均衡，而 HttpClient 不支持使用@LoadBalanced 注解实现负载均衡

如果没有 loadbalancer 的依赖，那就自己加上

随机给一个数，然后请求下标对应的微服务

实际调用服务器位置下标=rest 接口第几次请求数 % 服务器集群总数量【每次服务重启动后 rest 接口计数从 1 开始】
如：List[0] instances =127.0.0.1:8002
List[1] instances =127.0.0.1:8001
8001+8002 组合成为集群，它们共计 2 台机器，集群总数为 2，按照轮询算法原理：
当总请求数为 1 时：1%2=1 对应下标位置为 1，则获得服务地址为 127.0.0.1:8001
当总请求数位 2 时：2%2=0 对应下标位置为 0，则获得服务地址为 127.0.0.1:8002
当总请求数位 3 时：3%2=1 对应下标位置为 1，则获得服务地址为 127.0.0.1:8001
当总请求数位 4 时：4%2=0 对应下标位置为 0，则获得服务地址为 127.0.0.1:8002
如此类推......

@Configuration
//下面的 value 值大小写一定要和 consul 里面的名字一样，必须一样
//value 的值是指对哪个微服务生效
@LoadBalancerClient(value ="cloud-payment-service", configuration = RestTemplateConfig.class)
public class RestTemplateConfig {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment, LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        //这里切换成了随机算法
        return new RandomLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}

//注入 feign 对象
@Autowired
private PayFeignApi payFeignApi;
@GetMapping("/feign/pay/getall")
public ResultData getPayInfo() {
    ResultData orders = payFeignApi.getOrders();
    List<Pay> payList =(List<Pay>) orders.getData();
    return ResultData.success(payList);
}

@FeignClient("cloud-payment-service")
public interface PayFeignApi {
    //方法上的注解就是被调用方法的请求类型和地址
    //这样他就合成了 http://cloud-payment-service/pay/getall
    @GetMapping("/pay/getall")
    //这里的返回值需要和被调用接口的返回值一致
    ResultData getOrders();
}

//例如：被调用的模块是支付模块，支付模块在注册中心的名字叫 cloud-payment-service
@FeignClient("cloud-payment-service")
public interface PayFeignApi {}

这里以订单模块调用支付模块的接口为例，因此在订单模块中创建

//如果 FeignClient 不在 SpringBootApplication 的扫描范围内可以在@EnableFeignClients 中指定扫描范围
@EnableFeignClients(basePackages="com.example.cloud")

<!--openFeign-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<!--loadbalancer 做负载均衡-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

spring:
  cloud:
    openfeign:
      client:
        config:
          default:
            #指定超时时间最大：3S
            read-timeout: 3000
            #指定连接时间最大：3S
            connect-timeout: 3000

spring:
  cloud:
    openfeign:
      client:
        config:
          #这里将 default 换成微服务的名称
          cloud-payment-service:
            #指定超时时间最大：3S
            read-timeout: 3000
            #指定连接时间最大：3S
            connect-timeout: 3000

//1.创建一个配置类
@Configuration
public class RetryerConfig {
    //2.配置 Retryer
    @Bean
    public Retryer retryer() {
        //3，设置重试机制
        //return Retryer.NEVER_RETRY; 这个是默认的
        //第一个参数是多长时间后开启重试机制：这里设置 100ms
        //第二个参数是重试的间隔：这里设置 1s 一次
        //第三个参数是最大请求次数：3 次【这个次数是一共的，也就是最大请求几次，而不是第一次请求失败后再请求几次】
        return new Retryer.Default(100, 1, 3);
    }
}

spring:
  cloud:
    openfeign:
      httpclient:
        hc5:
          enabled: true

<!-- httpclient5-->
<dependency>
    <groupId>org.apache.httpcomponents.client5</groupId>
    <artifactId>httpclient5</artifactId>
    <version>5.3</version>
</dependency>
<!-- feign-hc5-->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-hc5</artifactId>
    <version>13.1</version>
</dependency>

spring:
  cloud:
    openfeign:
      compression:
        request:
          #开启请求压缩
          enabled: true
          #达到多大才触发压缩
          min-request-size: 2048
          #触发压缩的类型
          mime-types: types=text/xml,application/xml,application/json
        response:
          #开启响应压缩
          enabled: true

Feign 的日志级别：NONE:不记录任何日志信息，这是默认值。BASIC:仅记录请求的方法，URL 以及响应状态码和执行时间 HEADERS:在 BASIC 的基础上，额外记录了请求和响应的头信息 FULL:记录所有请求和响应的明细，包括头信息、请求体、元数据。

logging:
  level:
    #下面是 feign 接口的包
    com.example.cloud.apis.PayFeignApi: debug

public class DefaultFeignConfig {
    @Bean
    public Logger.Level feignLogLevel() {
        return Logger.Level.FULL; //日志级别
    }
}

服务熔断会调用服务降级

断路器有三个普通状态：关闭 CLOSE【正常请求】、开启 OPEN【断电不可用】、半开 HALF_OPEN 
1.当熔断器处于 CLOSE 关闭状态，所有的请求都会通过熔断器。
2.如果失败率超过设定的阈值，熔断器就会从关闭状态【CLOSE】转换到打开状态【OPEN】，这时所有的请求都会被拒绝
3.当处于开启状态【OPEN】一段时间后，熔断器就会从开启状态转换到半开状态【HALF_OPEN】，这时会有一定数量的请求放入，并重新计算失败率
4.如果失败率超过阈值，则会转成打开状态，如果低于阈值，则会变成关闭状态
还有两个特殊状态：DISABLED【始终允许访问】、FORCED_OPEN【始终拒绝访问】【这两个状态再生产中不会使用】

断路器的滑动窗口用来存储和统计调用的结果，可以选择基于调用数量的滑动窗口或者基于时间的滑动窗口：
1.基于时间的滑动窗口：统计最近 N 秒的调用结果
2.基于数量的滑动窗口：统计最近 N 次调用的结果

SpringCloud 学习笔记

一、笔记内容技术选型

二、Spring Cloud 介绍

1.为什么需要 Spring Cloud？

2.相关组件介绍

三、单体项目构建

1.SpringBoot 单体服务

1.1 项目构建

1.2 MyBatis 逆向工程

1.3 编写业务逻辑

1.4 整合 Swager3

1.5 统一返回结果 Result

1.6 优化时间格式

1.7 异常处理

1.8 编写订单模块【模块构建参考上述步骤】

1.9 服务调用 RestTemplate

1.10 重复代码抽取

2.问题引入

四、Consul 服务注册和发现

1.基本介绍

2.下载运行

3.服务注册与发现

4.服务配置

5.动态刷新

6.配置数据持久化

五、LoadBalancer 负载均衡

1.基本介绍

2.基本使用

3.基本原理

4.负载均衡算法

5.负载均衡算法切换

六、OpenFeign 服务接口调用

1.基本介绍

2.能干什么

3.基本使用

4.最佳实践

5.超时控制

5.1 全局配置

5.2 指定配置

6.重试机制

7.连接池

8.请求/响应压缩

9.日志打印

七、CircuitBreaker 断路器

1.基本介绍

2.CircuitBreaker 和 Resilience4 的关系

3.CircuitBreaker 的实现原理

八、Resilience4J

1.基本介绍

2.基本功能

2.1 熔断【服务熔断 + 服务降级】

2.1.1 断路器 3 大状态

2.1.2 断路器状态转换

2.2 限速

2.3 隔离

九、面试题

1.常见的注册中心和他们的特点

2.客户端负载均衡和服务器负载均衡有什么区别？

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具