环境信息: Java 8、Spring Boot 2.x、Spring Cloud 2021.x

引言

微服务中的异常传递

在使用Feign进行远程调用、开启了熔断降级且存在全局异常处理时，异常的传递就变得尤为重要。

在微服务架构中，服务之间的调用是通过网络进行的，因此在调用过程中可能会出现各种异常，如网络超时、服务不可用等。

为了保证服务的稳定性，我们需要对这些异常进行处理，以避免异常在服务之间传递，导致整个系统的不稳定。

调用的几种情况

假设此时A服务正在调用B服务，通常会涉及以下几种情况：

1. B服务成功返回
2. B服务抛出异常，被全局异常处理器拦截后正常返回，因为全局异常拦截会将异常封装为统一结果对象返回，此时是不会走降级逻辑的
3. B服务抛出异常，被全局异常处理器拦截后，继续抛出异常，此时会走降级逻辑并返回结果

详细分析

基础准备

• 创建一个SpringCloud项目，并引入OpenFeign、Sentinel或Hystrix依赖，以实现服务间的调用和降级。

• 自定义返回状态码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/**
 * 返回码
 *
 * @author XieYT
 */
@SuppressWarnings("unused")
@Getter
@AllArgsConstructor
public enum ReturnCode {

    /**
     * 成功
     */
    RC200(200, "成功"),
    
    /**
     * 失败
     */
    RC500(500, "网络异常");
}

• 创建统一返回结果类，用于对返回结果进行封装，这里使用R类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

/**
 * 统一结果返回类
 *
 * @author XieYT
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
@SuppressWarnings("unused")
public class R<T> {

    /**
     * 消息
     */
    private String message;

    /**
     * 状态码
     */
    private Integer code;

    /**
     * 数据
     */
    private T data;

    /**
     * 时间戳
     */
    private long timestamp;

    public static <T> R<T> success() {
        return R.<T>builder()
                .code(ReturnCode.RC200.getCode())
                .message(ReturnCode.RC200.getMessage())
                .timestamp(System.currentTimeMillis())
                .build();
    }

    public static <T> R<T> success(T data) {
        return R.<T>builder()
                .code(ReturnCode.RC200.getCode())
                .message(ReturnCode.RC200.getMessage())
                .data(data)
                .timestamp(System.currentTimeMillis())
                .build();
    }

    /**
     * 自定义消息的成功返回
     */
    public static <T> R<T> success(T data, String message) {
        return R.<T>builder()
                .code(ReturnCode.RC200.getCode())
                .message(message)
                .data(data)
                .timestamp(System.currentTimeMillis())
                .build();
    }

    /**
     * 失败
     */
    public static <T> R<T> fail(Integer code, String message) {
        return R.<T>builder()
                .code(code)
                .message(message)
                .timestamp(System.currentTimeMillis())
                .build();
    }

    /**
     * 失败
     */
    public static <T> R<T> fail(ReturnCode returnCode) {
        return R.<T>builder()
                .code(returnCode.getCode())
                .message(returnCode.getMessage())
                .timestamp(System.currentTimeMillis())
                .build();
    }

    /**
     * 失败
     */
    public static <T> R<T> fail(ReturnCode returnCode, String message) {
        return R.<T>builder()
                .code(returnCode.getCode())
                .message(message)
                .timestamp(System.currentTimeMillis())
                .build();
    }


}

• 自定义业务异常类，用于抛出业务异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

/**
 * 基础异常
 *
 * @author XieYT
 */
@SuppressWarnings("unused")
@Data
@EqualsAndHashCode(callSuper = true)
public class ServiceException extends RuntimeException {

    private Integer code;

    private String message;

    public ServiceException(ReturnCode codeEnum) {
        super(codeEnum.getMessage());
        this.code = codeEnum.getCode();
        this.message = codeEnum.getMessage();
    }

    public ServiceException(Integer code, String message) {
        super(message);
        this.code = code;
        this.message = message;
    }
}

• 定义全局异常处理器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/**
 * 全局异常处理器
 *
 * @author XieYT
 */
@Slf4j
@RestControllerAdvice()
public class GlobalExceptionHandler {

    /**
     * 业务异常
     */
    @ExceptionHandler(ServiceException.class)
    public R<String> serviceExceptionHandler(ServiceException e) {
        log.error("业务异常: {} -> {}", Arrays.stream(e.getStackTrace()).findFirst().orElse(null), e.getMessage());
        return R.fail(e.getCode(), e.getMessage());
    }
}

情况一

B服务成功返回

无须特殊处理，正常返回即可。

情况二

B服务抛出异常，被全局异常处理器拦截后正常返回

当B服务抛出异常时，全局异常处理器会拦截异常，并将异常封装为统一结果对象返回，此时是不会走降级逻辑的。

此时我们可以直接通过R类中的状态码来判断是否成功返回，如下：

1
2
3
4
5
6
7
8
9

R<String> result = service.method();
boolean isSuccess = ReturnCode.RC200.getCode().equals(result.getCode());

if (isSuccess) {
    // do something
} else {
    // 如果想要获取异常信息，可以通过result.getMessage()获取，从而抛出
    throw new ServiceException(result.getCode(), result.getMessage());
}

在上述代码中，我们先判断了是否成功返回，如果成功则继续执行，否则抛出异常。

抛出异常的操作可能会在多个方法中用到，我们不妨将其封装到R类中，以便于调用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class R<T> {

    // 省略其他代码...
    
    /**
     * 成功则返回，否则抛出异常
     */
    @JsonIgnore
    public T getCheckData() {
        checkError();
        return data;
    }

    private void checkError() {
        if (isSuccess()) {
            return;
        }
        throw new ServiceException(code, message);
    }

    private boolean isSuccess() {
        return ReturnCode.RC200.getCode().equals(code);
    }
}

在加入上述代码后，我们就可以直接通过getCheckData()方法来隐藏异常处理逻辑，使代码更加简洁。

1
2
3
4
5

public void getDataFromOtherService() {
    R<String> result = service.method();
    // 如果成功则返回，否则抛出异常并被全局异常处理器拦截
    String data = result.getCheckData();
}

情况三

B服务抛出异常，被全局异常处理器拦截后，继续抛出异常

在情况二中，如果异常被全局异常处理器拦截，那么异常会被封装为统一结果对象返回，此时是不会走降级逻辑的。

所以我们可以定义一个异常来单独处理这种情况，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/**
 * Feign异常
 * <p>
 * 该异常用于处理Feign调用异常
 * <p>
 * 全局异常处理其中不会对该异常进行处理，而是直接抛出
 *
 * @author XieYT
 */
@SuppressWarnings("unused")
@Data
@EqualsAndHashCode(callSuper = true)
public class FeignClientException extends RuntimeException {

    private String message;

    public FeignClientException(String message) {
        super(message);
        this.message = message;
    }
}

并且在全局异常处理器中对该异常进行处理，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

public class GlobalExceptionHandler {

    // 省略其他代码...
    
    /**
     * Feign异常处理
     */
    @ExceptionHandler(value = FeignClientException.class)
    public void defaultExceptionHandler(FeignClientException e) {
        // 在这里直接将异常抛出，以便于走降级逻辑 
        throw e;
    }
}

此时我们在B服务中可以通过如下方式抛出异常：

1
2
3
4
5
6

public Service {
    public String method() {
        // 省略其他代码...
        throw new FeignClientException("Feign调用异常, 该异常会被继续抛出!");
    }
}

此时异常会被全局异常处理器拦截，然后直接抛出，从而走降级逻辑。

总结

在本文中，我们探讨了在使用Spring Cloud中的OpenFeign进行远程服务调用时如何处理异常，特别是当这些异常被全局异常处理器捕获时的情况。

通过实际代码示例，我们演示了如何在微服务架构中适当地传递和封装异常，以保持系统的稳定性和响应性。

什么是依赖注入？

依赖注入（Dependency Injection，简称DI）是一种设计模式，用于实现软件组件之间的松耦合。在面向对象编程中，依赖指一个对象需要另一个对象来完成某项任务。依赖注入的核心思想是，将对象所依赖的其他对象，通过外部传递给它，而不是让对象自己去创建或查找这些依赖。

依赖注入的优点

1. 提高代码的可测试性：依赖注入使得单元测试更加容易，因为可以轻松地使用模拟对象替换真实依赖。
2. 增强组件的可重用性：通过依赖注入，可以轻松替换组件的实现，从而提高代码的可维护性和可扩展性。
3. 减少耦合度：依赖注入促进了松耦合设计，使得组件之间的依赖关系更加清晰和可管理。

Spring框架中的依赖注入

Spring框架通过其IoC（Inversion of Control，控制反转）容器实现了强大的依赖注入功能，极大地简化了对象之间的依赖管理。 IoC容器是依赖注入的核心，负责创建、配置和管理对象的生命周期。容器通过读取配置文件或注解来识别和注入依赖对象。

依赖注入的类型

构造函数注入

1
2
3
4
5
6
7
8
9
10
11

@Component
public class MyService {

    private final MyRepository repository;

    @Autowired
    public MyService(MyRepository repository) {
        this.repository = repository;
    }
    
}

优点：

• 强制依赖：所有依赖在对象创建时必须提供，确保对象处于完整的初始化状态。
• 不可变性：有助于创建不可变对象，增强线程安全性。
• 简化测试：便于使用模拟对象进行单元测试。

缺点：

• 复杂性：当依赖较多时，构造函数参数列表可能变得冗长且难以维护。
• 灵活性较低：所有依赖必须在对象创建时提供，不能在对象生命周期中动态修改。

Setter方法注入

1
2
3
4
5
6
7
8
9
10
11

@Component
public class MyService {

    private MyRepository repository;

    @Autowired
    public void setRepository(MyRepository repository) {
        this.repository = repository;
    }
    
}

优点：

• 灵活性：允许在对象创建后设置或更改依赖，适合可选依赖或需要后期配置的场景。
• 可读性：Setter方法使代码更具可读性，特别是当依赖较多时。

缺点：

• 测试复杂性：需要分别设置每个依赖，增加测试复杂度。
• 未设置依赖的风险：在对象使用前，可能会有未设置依赖的风险。

字段注入

1
2
3
4
5
6
7

@Component
public class MyService {

    @Autowired
    private MyRepository repository;
    
}

优点：

• 简单直接：无需构造函数或Setter方法，直接在字段上使用注解，代码简洁。
• 快速开发：适合快速原型开发，减少样板代码。

缺点：

• 难以测试：无法通过构造函数或Setter方法注入模拟对象，单元测试较为困难。
• 隐式依赖：依赖关系不明显，可能导致维护困难。

总结

Windows PowerShell 是一种命令行脚本语言和脚本环境，它是 Windows 系统中的一个强大工具，可以帮助用户更高效地管理和操作系统。在 PowerShell 中，我们可以通过定义和调用函数来实现代码的复用和模块化。

本文将介绍如何在 PowerShell 中定义和调用函数。

需求说明

在使用Git时，在 PowerShell 中定义一个函数，实现对Git的http代理进行便捷的设置和取消。

注意：该代理为http代理，而非ssh代理。

实现步骤

定义函数

在 PowerShell 中，我们可以通过 function 关键字来定义函数，函数的基本语法如下：

1
2
3

function 函数名 {
    # 函数体
}

下面是一个设置和取消 Git 代理的函数的示例，请注意端口按需修改：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

function gitProxy {
    param([string]$status)
    switch ($status) {
        "on" {
            git config --global http.proxy 'http://127.0.0.1:7890'
            Write-Host "Git proxy has been turned ON."
        }
        "off" {
            git config --global --unset http.proxy
            Write-Host "Git proxy has been turned OFF."
        }
        default {
            Write-Host "Use 'on' to turn on the proxy or 'off' to turn off the proxy."
        }
    }
}

在上面的代码中，我们定义了一个名为 gitProxy 的函数，该函数接受一个参数 $status，根据参数的值来设置或取消 Git 代理。

我们只需要将上面的代码粘贴到 PowerShell 中并回车，就可以定义一个名为 gitProxy 的函数。

调用函数

定义好函数之后，我们可以通过函数名来调用函数，传入参数来执行函数的逻辑。

1

gitProxy on

上面的代码调用了 gitProxy 函数，并传入了参数 on，表示要设置 Git 代理。

此时，我们可以查看 Git 的配置列表，可以看到 Git 代理已经被设置。

1

git config --global --list

1

gitProxy off

上面的代码调用了 gitProxy 函数，并传入了参数 off，表示要取消 Git 代理。

持久化函数

上面的函数是临时定义的，只在当前 PowerShell 会话中有效。如果我们希望函数在每次启动 PowerShell 时都能使用，可以将函数定义保存到 PowerShell 配置文件中。

注意：以下命令需要使用管理员权限启动PowerShell，由于该命令属于常用命项，依据Windows官方建议，将函数保存到$PROFILE.AllUsersAllHosts配置文件中。

检查配置文件是否存在，如果不存在则创建配置文件：

1

if (!(Test-Path -Path $PROFILE.AllUsersAllHosts)) { New-Item -Type File -Path $PROFILE.AllUsersAllHosts -Force }

打开并编辑配置文件：

1

notepad $USERPROFILE.AllUsersAllHosts

在打开的配置文件中，我们可以将前面函数粘贴到文件末尾，保存并关闭文件。

关闭并重新打开新的 PowerShell 窗口，我们就可以直接调用 gitProxy 函数了。

总结

本文介绍了如何在 PowerShell 中通过 function 关键字定义函数，并通过函数名调用函数。同时介绍了如何将函数保存到 PowerShell 配置文件中，以便在每次启动 PowerShell 时都能使用。

整形类型

整形中分为signed有符号(默认)和unsigned无符号。

• 一般情况下不建议设置为无符号，因为会导致一些问题

  例如：MySQL要求设置为unsigned的两个值相减的结果仍然为unsigned，否则会导致抛出[22001][1690] Data truncation: BIGINT UNSIGNED value is out of range in 'xxx'异常。
  如果确实要使用，可以通过设置SET sql_mode='NO_UNSIGNED_SUBTRACTION';来关闭这个检查。

• 自增类型作为主键时，务必要使用BIGINT，而不是INT

  因为INT最大值为2147483647，很容易达到上限，达到上限后再次插入会导致主键冲突。

• MySQL8.0之前，自增整型会有回溯问题

  当删除ID为4的记录后，如果MySQL服务器重启，那么下一个插入的ID依旧可能为4

浮点类型和高精度类型

• 浮点类型：FLOAT和DOUBLE在存储时会有精度问题，且在MySQL后续版本中可能会被废弃，建议使用高精度DECIMAL类型

  DECIMAL类型在存储时通过DECIMAL(precision,scale)来设置其长度和小数点后的位数。

• 涉及到金额的字段，建议使用BIGINT整型类型，而不是高精度DECIMAL类型

  使用DECIMAL类型时，其长度不好确定，导致存储空间碎片化，而使用整型，其长度统一，便于数据库整理。
  
  同时，整型类型的计算速度更快。

字符串类型

• 一般情况下，建议使用VARCHAR类型，而不是CHAR类型，因为对于变长字符集utf8mb4来说，底层都是变长存储

• 默认情况下，VARCHAR类型可以设置在最大字符数为65535/所选字符集下一个字符存储的字节数

  例如：当选用utf8mb4字符集时，一个字符使用4个字节存储，当设置的长度超过65535/4=16383时，会抛出［42000]［1074］ Column length too big for column 'xxx' (max=16383); use BLOB or TEXT instead.异常。

• 建议将字符集设置为utf8mb4，以支持emoji表情等特殊字符

• 排序规则一般选用大小写不敏感的utf8mb4_0900_ai_ci

  ci：大小写不敏感(默认)
  cs：大小写敏感
  ai：重音不敏感
  as：重音敏感
  bin：二进制排序

• 修改表和字段字符集的命令

  1	ALTER TABLE `table_name` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;

• MySQL高版本中，性别字段建议使用char(1)类型，并通过check约束来限制其值

  1	CONSTRAINT `user_chk_1` CHECK (((`sex`=_utf8mb4'F') OR (`sex`=_utf8mb4'M')))

• 密码等隐私字段，建议通过动态盐+动态加密算法来加密存储

日期时间类型

• TIMESTAMP最大的优点是带有时区信息，如果业务需要不同国家的时间，建议使用TIMESTAMP类型

• TIMESTAMP类型存储上限为2038-01-19 03:14:07，需要注意潜在风险

• 使用TIMESTAMP类型时，建议显式设置时区，不要使用默认系统时区，会存在较大的性能问题

  推荐在配置文件中设置time_zone='+8:00'

• 如无特殊需求，日期建议使用DATETIME类型，而不是TIMESTAMP和INT类型

  在使用时可以通过DATETIME(N)中的N来设置毫秒的精度，N的范围为0-6，默认为0
  插入或更新时的默认时间可以通过CURRENT_TIMESTAMP(N)来设置
  TIMESTAMP如果设置毫秒数则占用7个字节，而DATETIME无论是否设置毫秒数都占用8个字节，所以在存储空间上几乎没有太大区别

什么是 SpringBoot-Starter

Spring Boot Starter 是 Spring Boot 框架中的一个重要概念，它是一种用于简化项目配置和依赖管理的方式。在 Spring Boot 中，应用程序通常需要引入许多依赖库和配置，以实现特定的功能或集成特定的技术栈。Spring Boot Starter 通过预定义的依赖和配置来简化这个过程，让开发人员能够更轻松地搭建和配置应用程序。

为什么要自定义 Starter

1. 模块化和复用性： 自定义 Starter 允许你将通用功能封装为可重用的模块。这可以使你在多个项目中轻松地使用相同的功能，减少重复代码的编写。
2. 内部标准化： 如果你的组织内部有一些通用的技术选型、配置和最佳实践，你可以创建自定义 Starter 来强制执行这些标准，从而提高代码的一致性和可维护性。
3. 简化团队开发： 自定义 Starter 可以帮助团队成员更容易地使用相同的技术栈和配置，减少了新成员加入或跨项目切换时的学习曲线。
4. 定制化需求： 你可以根据项目的特定需求创建自定义 Starter，将其与通用功能集成，从而更好地满足项目的独特要求。
5. 隐藏复杂性： 如果你的项目需要集成多个组件或依赖项，你可以通过自定义 Starter 来隐藏底层的复杂性，提供一个更简洁的界面供开发人员使用。
6. 提高开发效率： 自定义 Starter 可以减少项目配置的工作量，使开发人员能够更快速地启动和开发应用程序。
7. 促进规范： 自定义 Starter 可以推动项目内部遵循特定的架构、模式和规范，从而促进代码质量和一致性。
8. 对外开放： 如果你的项目提供一些可扩展的功能或插件，你可以将其封装为自定义 Starter，方便其他开发人员在他们的项目中使用。

命名规范

• SpringBoot官方提供的Starter的命名规则：spring-boot-starter-{name}，其中{name}为自定义的 Starter 名称。

• 自定义Starter的命名规则：{name}-spring-boot-starter，其中{name}为自定义的 Starter 名称。

自动装配原理

• Spring Boot 会扫描类路径下的META-INF/spring.factories文件，这个文件列出了可用的自动配置类。
• 配置类通过条件注解来判断这个配置类是否生效，如果生效，就会自动配置。例如：@ConditionalOnClass注解表示当类路径下有指定的类时，配置类才会生效。

如何自定义Starter

创建 Maven 项目

新建一个空的 Maven 项目：

Spring Boot Starter 项目无需启动类，且通常不包含任何代码，只包含一些依赖和配置。

添加依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

<?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>

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

    <groupId>com.cloud.billow</groupId>
    <artifactId>notify-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>

        <!-- Spring Boot 自动配置 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>

        <!-- Spring Boot 配置处理器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- 其他依赖项 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

</project>

编写配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

/**
 * 通知配置类
 *
 * @author CloudBillow
 * @since 2023/08/14 14:29
 */
@Data
@EnableConfigurationProperties(NotifyProperties.class)
@ConfigurationProperties(prefix = NotifyProperties.NOTIFY_PREFIX)
public class NotifyProperties {

    public static final String NOTIFY_PREFIX = "notify";

    /**
     * 发送人
     */
    private String from;

    /**
     * 接收人
     */
    private String to;

}

编写 Service 类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/**
 * 微信通知类
 *
 * @author CloudBillow
 * @since 2023/08/14 14:34
 */
@Data
public class WXNotifyService implements NotifyService {

    private NotifyProperties notifyProperties;

    @Override
    public boolean sendNotify(String content) {
        try {
            String from = notifyProperties.getFrom();
            String to = notifyProperties.getTo();
            System.out.println("from: " + from + ", to: " + to + ", content: " + content);
        } catch (Exception e) {
            return false;
        }
        return true;
    }
}

编写自动配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/**
 * 通知自动配置类
 *
 * @author CloudBillow
 * @since 2023/08/14 14:32
 */
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(name = "com.cloud.billow.properties.NotifyProperties")
@EnableConfigurationProperties(NotifyProperties.class)
public class NotifyAutoConfiguration implements InitializingBean {

    private final NotifyProperties notifyProperties;

    public NotifyAutoConfiguration(NotifyProperties notifyProperties) {
        this.notifyProperties = notifyProperties;
    }

    @Bean
    @ConditionalOnMissingBean
    public NotifyService notifyService() {
        WXNotifyService wxNotifyService = new WXNotifyService();
        wxNotifyService.setNotifyProperties(notifyProperties);
        return wxNotifyService;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // 校验参数
    }
}

编写 spring.factories 文件

在src/main/resources目录下创建META-INF/spring.factories文件，内容如下：

1
2

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.cloud.billow.configuration.NotifyAutoConfiguration

使用Maven打包

使用自定义 Starter

引入自定义 Starter 依赖：

1
2
3
4
5

<dependency>
    <groupId>com.cloud.billow</groupId>
    <artifactId>notify-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>

配置自定义 Starter：

1
2
3

notify:
  to: 小明
  from: 小红

由于引入了configuration-processor依赖，所以在配置文件中输入notify前缀时，会有提示，如下图所示

使用自定义 Starter：

1
2
3
4
5

@GetMapping(value = "/test")
public String test() {
    boolean isSuccess = notifyService.sendNotify("这个是消息的内容");
    return String.valueOf(isSuccess);
}

输出

对SpringBoot应用程序进行Docker容器化是软件开发者的一项基本技能，因为它可以在容器化环境中高效部署和管理应用程序。同时将SpringBoot应用打包到Docker容器中可以确保跨平台的一致性且便于后期扩展。

准备工作

首先准备一个SpringBoot项目，在项目中添加一个接口用于测试。

1
2
3
4
5
6
7
8

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello Docker!";
    }
}

启动项目，访问http://localhost:8080/hello，确保接口可以正确响应。

1

$ mvn clean spring-boot:run

1

$ curl -v localhost:8080/hello

执行上述命令后将看到如下输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

curl -v localhost:8080/hello
*   Trying [::1]:8080...
* Connected to localhost (::1) port 8080
> GET /hello HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/8.4.0
> Accept: */*
> 
< HTTP/1.1 200 
< Content-Type: text/plain;charset=UTF-8
< Content-Length: 13
< Date: Mon, 15 Apr 2024 06:56:56 GMT
< 
* Connection #0 to host localhost left intact
Hello Docker!%

添加Dockerfile配置文件

接下来，在项目根目录下创建一个Dockerfile，并添加下面的配置：

1
2
3
4
5
6

FROM openjdk:17
VOLUME /tmp
EXPOSE 8080
ARG JAR_FILE=target/spring-boot-to-docker-0.0.1-SNAPSHOT.jar
ADD ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

下面是配置的简单说明：

• FROM openjdk:17：使用openjdk:17作为基础镜像。
• VOLUME /tmp：创建一个/tmp目录作为容器的临时目录。
• EXPOSE 8080：容器运行时监听的端口。
• ARG JAR_FILE=target/spring-boot-docker.jar：定义一个变量JAR_FILE，用于指定要添加到容器中的jar文件。
• ADD ${JAR_FILE} app.jar：将JAR_FILE指定的jar文件添加到容器中，并重命名为app.jar。
• ENTRYPOINT ["java","-jar","/app.jar"]：指定容器启动时执行的命令。

生成jar包

通过maven命令生成jar包：

1

$ mvn clean package

此时在target目录下会生成一个spring-boot-to-docker-0.0.1-SNAPSHOT.jar文件。

构建Docker镜像

确保已经安装了Docker，然后在项目根目录下执行下面的命令构建Docker镜像：

1

docker build -t spring-boot-to-docker:spring-docker .

build 命令将通过我们在 Dockerfile 中的配置构建一个镜像，而 -t 标志则用于为我们的镜像添加一个标签。

等待几分钟后，我们可以通过docker image ls | grep spring-boot-to-docker命令查看镜像是否创建成功。

运行Docker容器

运行下面的命令启动Docker容器：

1

docker run -p 9090:8080 spring-boot-to-docker:spring-docker

run 命令用于启动一个容器，而 -p 标志则用于将容器的端口映射到主机的端口。

运行成功后，可以通过http://localhost:9090/hello访问接口，确保接口可以正确响应。

1

$ curl -v localhost:9090/hello

CompletableFuture类提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。

总结

在CompletableFuture中如果使用没有指定线程池的方法，则会使用ForkJoinPool.commonPool()作为它的线程池执行异步代码。

创建异步任务

不支持返回值

• 方法签名

  1 2 3 4

  // 使用默认线程池中的线程 public static CompletableFuture<Void> runAsync(Runnable runnable); // 使用自定义线程池中的线程 public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor);

• 示例代码

  1 2 3

  CompletableFuture.runAsync(() -> { // TODO 执行任务 });

支持返回值

• 方法签名

  1 2 3 4

  // 使用默认线程池中的线程 public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier); // 使用自定义线程池中的线程 public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor);

• 示例代码

  1 2 3 4

  CompletableFuture.supplyAsync(() -> { // TODO 执行任务 return null; });

任务完成时回调方法

当CompletableFuture任务执行完成或者抛出异常的时候，可以执行特定的回调方法。

不接参数、无返回值

前一个任务执行完成后执行；任务之间无参数传递，回调方法无返回值

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public CompletableFuture<Void> thenRun(Runnable action); // 使用默认线程池中的线程 public CompletableFuture<Void> thenRunAsync(Runnable action); // 使用自定义线程池中的线程 public CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor);

• 示例代码

  1 2 3 4

  CompletableFuture.runAsync(() -> { }).thenRun(() -> { // TODO 执行任务 });

接返回值、无返回值

前一个任务执行完成后执行；前一个任务会将执行结果作为参数，传递到回调方法中，回调方法无返回值

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public CompletableFuture<Void> thenAccept(Consumer<? super T> action); // 使用默认线程池中的线程 public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action); // 使用自定义线程池中的线程 public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor);

• 示例代码

  1 2 3 4 5

  CompletableFuture.supplyAsync(() -> { return "Result"; }).thenAccept((result) -> { // TODO 执行任务 });

接返回值、有返回值

前一个任务执行完成后执行；前一个任务会将执行结果作为参数，传递到回调方法中，并且会调方法有返回值

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn); // 使用默认线程池中的线程 public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn); // 使用自定义线程池中的线程 public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn, Executor executor);

• 示例代码

  1 2 3 4 5 6

  CompletableFuture.supplyAsync(() -> { return "Result_1"; }).thenApply(() -> { // TODO 执行任务 return "Result_2"; });

接异常、有返回值

某个任务执行异常时执行；异常任务抛出的异常作为参数，传递到回调方法中，并且会调方法有返回值

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn); // 使用默认线程池中的线程 public CompletableFuture<T> exceptionallyAsync(Function<Throwable, ? extends T> fn); // 使用自定义线程池中的线程 public CompletableFuture<T> exceptionallyAsync(Function<Throwable, ? extends T> fn, Executor executor);

• 示例代码

  1 2 3 4 5 6

  CompletableFuture.runAsync(() -> { throw new RuntimeException(); }).exceptionally((exception) -> { // TODO 处理异常 return "ERROR!"; });

接返回值和异常、无返回值

前一个任务执行完成或出现异常时执行；前一个任务会将结果或抛出的异常作为参数，传递到回调方法中，回调方法无返回值

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action); // 使用默认线程池中的线程 public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action); // 使用自定义线程池中的线程 public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action, Executor executor);

• 示例代码

  1 2 3 4 5 6 7 8 9

  CompletableFuture.supplyAsync(() -> { throw new RuntimeException(); }).whenCompleteAsync((result, exception) -> { if (exception != null) { // TODO 处理异常 } else { // TODO 执行任务 } });

接返回值和异常、有返回值

前一个任务执行完成后执行；前一个任务会将结果或抛出的异常作为参数，传递到回调方法中，回调方法有返回值

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn); // 使用默认线程池中的线程 public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn); // 使用自定义线程池中的线程 public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor);

• 示例代码

  1 2 3 4 5 6 7 8 9 10 11

  CompletableFuture.supplyAsync(() -> { throw new RuntimeException(); }).handleAsync((result, exception) -> { if (exception != null) { // TODO 处理异常 return "ERROR!"; } else { // 执行任务 return "SUCCESS!"; } });

两个任务组合

任务转化

将前一个任务的执行结果作为参数进行处理，处理后返回一个新的任务

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn); // 使用默认线程池中的线程 public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn); // 使用自定义线程池中的线程 public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn, Executor executor);

• 示例代码

  1 2 3 4 5 6 7 8 9 10

  CompletableFuture<String> task = CompletableFuture.supplyAsync(() -> { return "任务一的结果"; }); CompletableFuture<String> stringCompletableFuture = CompletableFuture.supplyAsync(() -> { return "任务二的结果"; }).thenComposeAsync((result) -> { // TODO 执行任务 return task; });

“且”组合、接返回值、有返回值

将两个任务组合，当两个任务都正常执行完了，将两个任务的结果作为参数，传递到回调方法中，回调方法有返回值

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn); // 使用默认线程池中的线程 public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn); // 使用自定义线程池中的线程 public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn, Executor executor);

• 示例代码

  1 2 3 4 5 6 7 8 9 10

  CompletableFuture.supplyAsync(() -> { // TODO 任务一 return "任务一的结果"; }).thenCombineAsync(CompletableFuture.supplyAsync(() -> { // TODO 任务二 return "任务二的结果"; }), (result1, result2) -> { // 任务一和任务二都完成时执行的回调方法 return null; });

“且”组合、接返回值、无返回值

将两个任务组合，当两个任务都正常执行完了，将两个任务的结果作为参数，传递到回调方法中，回调方法无返回值

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public <U> CompletableFuture<Void> thenAcceptBoth(CompletionStage<? extends U> other, BiConsumer<? super T, ? super U> action); // 使用默认线程池中的线程 public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T, ? super U> action); // 使用自定义线程池中的线程 public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T, ? super U> action, Executor executor);

• 示例代码

  1 2 3 4 5 6 7 8 9

  CompletableFuture.supplyAsync(() -> { // TODO 任务一 return "任务一的结果"; }).thenAcceptBothAsync(CompletableFuture.supplyAsync(() -> { // TODO 任务二 return "任务二的结果"; }), (result1, result2) -> { // TODO 任务一和任务二都完成时执行的回调方法 });

“且”组合、不接参数、无返回值

将两个任务组合，当两个任务都正常执行完了，执行回调方法，回调方法无返回值

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public CompletableFuture<Void> runAfterBoth(CompletionStage<?> other, Runnable action); // 使用默认线程池中的线程 public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action); // 使用自定义线程池中的线程 public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor);

• 示例代码

  1 2 3 4 5 6 7 8 9

  CompletableFuture.supplyAsync(() -> { // TODO 任务一 return "任务一的结果"; }).runAfterBothAsync(CompletableFuture.supplyAsync(() -> { // TODO 任务二 return "任务二的结果"; }), () -> { // TODO 任务一和任务二都完成时执行的回调方法 });

“或”组合、接返回值、有返回值

将两个任务组合，其中任意一个任务执行完成，将该任务的结果作为参数，传递到回调方法中，回调方法有返回值

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public <U> CompletableFuture<U> applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn); // 使用默认线程池中的线程 public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn); // 使用自定义线程池中的线程 public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn, Executor executor);

• 示例代码

  1 2 3 4 5 6 7 8 9 10

  CompletableFuture.supplyAsync(() -> { // TODO 任务一 return "任务一的结果"; }).applyToEitherAsync(CompletableFuture.supplyAsync(() -> { // TODO 任务二 return "任务二的结果"; }), (result) -> { // TODO 任务一和任务二任意一个执行完成时执行的回调方法 return "SUCCESS"; });

“或”组合、接返回值、无返回值

将两个任务组合，其中任意一个任务执行完成，将该任务的结果作为参数，传递到回调方法中，回调方法无返回值

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action); // 使用默认线程池中的线程 public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action); // 使用自定义线程池中的线程 public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action, Executor executor);

• 示例代码

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  CompletableFuture.supplyAsync(() -> { // TODO 任务一 try { Thread.sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } return "任务一的结果"; }).acceptEitherAsync(CompletableFuture.supplyAsync(() -> { // TODO 任务二 return "任务二的结果"; }), (result) -> { // TODO 任务一和任务二任意一个执行完成时执行的回调方法 });

“或”组合、不接参数、无返回值

将两个任务组合，其中任意一个任务执行完成，执行回调方法，回调方法无返回值

• 方法签名

  1 2 3 4 5 6

  // 使用调用它的线程上运行（一般是主线程） public CompletableFuture<Void> runAfterEither(CompletionStage<?> other, Runnable action); // 使用默认线程池中的线程 public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other, Runnable action); // 使用自定义线程池中的线程 public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other, Runnable action, Executor executor);

• 示例代码

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  CompletableFuture.supplyAsync(() -> { // TODO 任务一 try { Thread.sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } return "任务一的结果"; }).runAfterEitherAsync(CompletableFuture.supplyAsync(() -> { // TODO 任务二 return "任务二的结果"; }), () -> { // TODO 任务一和任务二任意一个执行完成时执行的回调方法 });

多个任务组合

“任意一个”组合

将多个任务组合，其中任意一个任务执行完成即可拿到该任务的执行结果（执行结果为Object类型），或执行接下来的任务

• 方法签名

  1	public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs);

• 示例代码

  1 2 3 4 5 6 7 8 9

  CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> { return "任务一的结果"; }); CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> { return "任务二的结果"; }); Object result = CompletableFuture.anyOf(task1, task2).join();

“所有”组合

将多个任务组合，当所有任务都执行完成后执行接下来的任务

• 方法签名

  1	public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs);

• 示例代码

  1 2 3 4 5 6 7 8 9

  CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> { return "任务一的结果"; }); CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> { return "任务二的结果"; }); Object join = CompletableFuture.allOf(task1, task2).join();

Quick Start

Create a new post

1

$ hexo new "New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Clean cache

1

$ hexo clean

More info: Commands Clean

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment