idea中列出的spring依赖（大全）-达维营-前端网

一、Developer Tools

1、Spring Native [Experimental]

1.1 功能简介

依赖说明：支持使用GraaIVM本地映像编译器将Spring 应用程序编译为本地可执行程序。

Spring Native 可以通过 GraalVM 将 Spring 应用程序编译成原生镜像，提供了一种新的方式来部署 Spring 应用。Spring Native 支持 Java 和 Kotlin。

1.2 导入依赖pom.xml

<!--    Spring Native 0.12.0 only supports Spring Boot 2.7.0, so change the version if necessary. -->
<dependency>
    <groupId>org.springframework.experimental</groupId>
    <artifactId>spring-native</artifactId>
    <version>0.12.0</version>
</dependency>

2、Spring Boot DevTools

2.1 功能简介

依赖说明：使 Spring Boot 应用支持热部署，提高开发者的开发效率，无需手动重启 Spring Boot 应用。

2.2 原理

深层原理是使用了两个 ClassLoader，一个 Classloader 加载那些不会改变的类（第三方Jar包），另一个 ClassLoader 加载会更改的类，称为 restart ClassLoader ，这样在有代码更改的时候，原来的 restart ClassLoader 被丢弃，重新创建一个 restart ClassLoader，由于需要加载的类相比较少，所以实现了较快的重启时间。

2.3 导入依赖pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

2.4 说明

Spring Boot DevTools 的用法仅用于开发，而不用于生产。
如果您的应用程序检测到您正在生产中运行，则会自动禁用 DevTools。
配置了后在修改java文件后也就支持了热启动，不过这种方式是属于项目重启（速度比较快的项目重启），
会清空session中的值，也就是如果有用户登陆的话，项目重启后需要重新登陆。
默认情况下，/META-INF/maven，/META-INF/resources，/resources，/static，/templates，/public
这些文件夹下的文件修改不会使应用重启，但是会重新加载（devtools内嵌了一个LiveReload server，当资源发生改变时，浏览器刷新）。

在代码页面 Ctrl + F9 即可快速重新运行项目

3、Lombok

3.1 功能简介

依赖说明：使用注解对实体类对象进行方法生成，如: get/set, toString等

3.2 导入依赖pom.xml

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

3.3 常用注解

@Data：注解在类上，将类提供的所有属性都添加get、set方法，并添加、equals、canEquals、hashCode、toString方法
@Setter：注解在类上，为所有属性添加set方法、注解在属性上为该属性提供set方法
@Getter：注解在类上，为所有的属性添加get方法、注解在属性上为该属性提供get方法
@NotNull：在参数中使用时，如果调用时传了null值，就会抛出空指针异常
@Synchronized 用于方法，可以锁定指定的对象，如果不指定，则默认创建一个对象锁定
@Log: 作用于类，创建一个log属性
@Builder：使用builder模式创建对象
@NoArgsConstructor：创建一个无参构造函数
@AllArgsConstructor：创建一个全参构造函数
@ToStirng：创建一个toString方法
@Accessors(chain = true)使用链式设置属性，set方法返回的是this对象。
@RequiredArgsConstructor：创建对象
@UtilityClass:工具类
@ExtensionMethod:设置父类
@FieldDefaults：设置属性的使用范围，如private、public等，也可以设置属性是否被final修饰。
@Cleanup: 关闭流、连接点。
@EqualsAndHashCode：重写equals和hashcode方法。
@toString：创建toString方法。

3.4 说明：

如果需要用到某些有参构造方法(不是全参构造方法)，需要手动生产

4、Spring Configuration Processor

4.1 功能简介

依赖说明：spring-boot-configuration-processor 即注释处理器

引入后，当你在application.yml或者application.properties中输入时，会有相应的提示，方便我们写配置文件

4.2 说明

如果不引入，则在实体类中可能会收到红色提醒(编码区上方)

Spring Boot Configuration Annotation Proccessor not found in classpath

"spring默认使用yml中的配置，但有时候要用传统的xml或properties配置，
就需要使用spring-boot-configuration-processor了"

在使用@ConfigurationProperties注解时可能会提醒找不到配置文件，查询此注解的使用关于怎么指定classpath，
进而查询location时，发现Spring Boot1.5以上版本@ConfigurationProperties取消location注解

另一个解决方案:
使用@PropertySource注解指明对应的配置文件

4.3 导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

二、Web

5、Spring Web

5.1 功能简介

依赖说明：使用 Spring MVC 构建 Web（包括RESTful）应用程序。使用Apache Tomcat 作为默认的嵌入式容器。

就是 SpringMVC。用于创建WEB项目。内置Tomcat。

关于SpringMVC和内置Tomcat有很多的参考，上面无法满足可自行搜索。

5.2 导入依赖

<!--Srping Web-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency

6、Spring Reactive Web

6.1 功能简介

依赖说明：使用 Spring WebFlux 和 Netty 构建响应式 Web 应用程序。

Reactive Web框架是一个包含了一套完整的服务端技术框架，这里面包括Web容器以及Web应用框架。

Reactive Web指的是Spring WebFlux。Spring WebFlux是基于响应式流的，因此可以用来建立异步的、非阻塞的、事件驱动的服务。它采用Reactor作为首选的响应式流的实现库，不过也提供了对RxJava的支持。

由于响应式编程的特性，Spring WebFlux和Reactor底层需要支持异步的运行环境，比如Netty和Undertow；也可以运行在支持异步I/O的Servlet 3.1的容器之上，比如Tomcat（8.0.23及以上）和Jetty（9.0.4及以上）。

6.2 导入依赖

<!--Spring Reactive Web-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

7、Spring for GraphQL

8、Rest Repositories

8.1 功能简介

依赖说明：通过 Spring Data REST 在 REST 上公开 Spring Data 存储库。

Spring Data REST是基于Spring Data的repository之上，可以把 repository 自动输出为REST资源，目前支持Spring Data JPA、Spring Data MongoDB、Spring Data Neo4j、Spring Data GemFire、Spring Data Cassandra的 repository 自动转换成REST服务。注意是自动。简单点说，Spring Data REST把我们需要编写的大量REST模版接口做了自动化实现。

8.2 导入依赖

<!--Rest Repositories-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>

9、Spring Session

9.1 功能简介

依赖说明：提供用于管理用户会话信息的API和实现。

Spring Session 是 Spring 的项目之一。Spring Session 提供了一套创建和管理 Servlet HttpSession 的方案，默认采用外置的 Redis 来存储 Session 数据，以此来解决 Session 共享的问题。

9.2 导入依赖

<!--Spring Session-->
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-core</artifactId>
</dependency>

10、Rest Repositories HAL Explorer

10.1 功能简介

依赖说明：在浏览器中浏览 Spring Data REST 存储库。

JSON 超文本应用程序语言(HAL) 是一种简单的格式，它提供了一种一致且简单的方法来在我们的 API 中的资源之间进行超链接。在我们的 REST API 中包含 HAL 使其更易于用户探索，并且本质上是自记录的。

10.2 导入依赖

<!--Rest Repositories HAL Explorer-->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-rest-hal-explorer</artifactId>
</dependency>

11、Spring HATEOAS

11.1 功能简介

依赖说明：在使用 Spring / Spring MVC 时，简化遵循 HATEOAS 原则的 RESTful API 的创建。

HATEOAS是Hypertext As The Engine Of Application State的缩写。在Richardson Maturity Model 中, 它是REST的最高级形态。

11.2 导入依赖

<!--Spring HATEOAS-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-hateoas</artifactId>
</dependency>

12、Spring Web Services

12.1 功能简介

依赖说明：促进锲约优先的 SOAP 开发。允许使用操作 XML 有效负载的多种方法之一创建灵活的Web服务。

Spring Web Services（Spring-WS）是Spring社区的产品，致力于创建文档驱动的Web服务。Spring Web Services旨在促进约定优先SOAP服务的开发，从而允许使用多种处理XML有效负载的方式之一来创建灵活的Web服务。该产品基于Spring本身，这意味着您可以将诸如依赖项注入之类的Spring概念用作Web服务的组成部分。

人们使用Spring-WS的原因有很多，但是大多数人在找到了遵循Web服务最佳实践所缺乏的替代SOAP堆栈之后才开始使用它。Spring-WS使最佳实践变得容易。这包括诸如WS-I基本概要文件，合同优先开发之类的实践，以及合同与实施之间的松散耦合。

12.2 导入依赖pom.xml

<!--Spring Web Services-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web-services</artifactId>
</dependency>

13、Jersey

13.1 功能简介

依赖说明：用 Java 开发 RESTful Web 服务的框架，为 JAX-RS API 提供支持。

jersey与resteasy一样都是JAX-RS即Java API for RESTful Web Services标准的实现，spring-boot-starter-jersey提供了对Jersey RESTful Web服务框架的支持，能够让我们轻松的构建RESTful Web工程。

13.2 导入依赖

<!--Jersey-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jersey</artifactId>
</dependency>

14、Vaadin

14.1 功能简介

依赖说明：一个 Web 框架，允许你用纯Java 编写 UI，而不会陷入JS、HTML 和 CSS 的泥潭。

Vaadin的工作方式依赖于服务器端渲染，因此可以自然地集成到诸如Spring之类的框架中。

当您是后端开发人员时，您会听到人们说您无法创建内置HTML的UI页面并且无法使用CSS设置样式时所引起的痛苦。就像成为后端开发人员一样，它具有已知的局限性，即我们可以播放和运行大型生产后端应用程序，但不能创建漂亮的页面来实际显示这些后端应用程序管理的数据。如果您曾经遇到过同样的想法，请不用担心， Vaadin在这里。

使用Vaadin，可以完全使用Java创建应用程序的前端。它提供了高度成熟的服务器端UI创建支持，使我们能够用Java语言编写生产级可重用组件。它具有所有流行的Java开发环境（Eclipse，IntelliJ，NetBeans，Maven等；本教程的示例使用IntelliJ）的支持。我们将首先了解Vaadin的实际工作原理，并遵循Vaadin中存在的各种组件和布局。我们将以出色的示例应用程序结束本课程，该示例应用程序在单个视图中演示事件处理和多种布局。

14.2 导入依赖

<!--Vaadin-->
<dependency>
    <groupId>com.vaadin</groupId>
    <artifactId>vaadin-spring-boot-starter</artifactId>
</dependency>

三、Template Engines 模板引擎

15、Thymeleaf

15.1 功能简介

依赖说明：适用于 Web 和独立环境的现代服务器端 Java 模板引擎。允许 HTML 在浏览器中正确显示并为静态原型。

Thymeleaf 是一个跟 Velocity、FreeMarker 类似的模板引擎，它可以完全替代 JSP 。

15.2 在pom.xml中添加Thymeleaf依赖

<!--thymeleaf模板依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

15.3 在application.properties修改Thymeleaf相关设置

#路径
spring.thymeleaf.prefix=classpath:/templates/
#后缀
spring.thymeleaf.suffix=.html
#编码
spring.thymeleaf.encoding=UTF-8
spring.thymeleaf.mode=HTML5

15.4 编写controller

@Controller
public class TestController {


    @RequestMapping("/test")
    public ModelAndView test(){
        ModelAndView modelAndView=new ModelAndView();
        modelAndView.setViewName("hello");
        List<String> list=new ArrayList<String>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        modelAndView.addObject("list",list);
        return modelAndView;
    }
}

15.5 在src/main/resource/templates下编写hello.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">   <!--需要添加此行标注为thymeleaf模板 -->
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <table border="1px">
            <tr>
                <th>name</th>
            </tr>
            <tr th:each="name:${list}">
                <td th:text="${name}"></td>
            </tr>

        </table>
    </body>
</html>

16、Apache Freemarker

16.1 简介

依赖说明：基于模板和不断变化的数据生成文本输出（HTML网易、电子邮件、配置文件、源代码灯）的 Java 库。

FreeMarker 是一款模板引擎：即一种基于模板和要改变的数据，并用来生成输出文本(HTML网页，电子邮件，配置文件，源代码等)的通用工具。是一个Java类库。

16.2 在pom.xml中添加Apache Freemarker依赖

<!--Apache Freemarker-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>

17、Mustache

17.1 简介

依赖说明：无逻辑模板。没有 if 语句、else 子句或 for 循环。相反，只有标签。

Mustache是基于JavaScript实现的模版引擎，类似于JQuery Template，但是这个模版更加的轻量级，语法更加的简单易用，很容易上手。

17.2 导入依赖

<!--Mustache-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mustache</artifactId>
</dependency>

18、Groovy Templates

18.1 说明

依赖说明： Groovy 模板引擎。

Groovy是构建在JVM上的一个轻量级却强大的动态语言, 它结合了Python、Ruby和Smalltalk的许多强大的特性.

Groovy就是用Java写的 , Groovy语法与Java语法类似, Groovy 代码能够与 Java 代码很好地结合，也能用于扩展现有代码, 相对于Java, 它在编写代码的灵活性上有非常明显的提升，Groovy 可以使用其他 Java 语言编写的库.

18.2 导入依赖

<!--Groovy Templates-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-groovy-templates</artifactId>
</dependency>

四、Security

19、Spring Security

19.1 简介

依赖说明：用于 Spring 应用程序的高度可定制的身份验证和访问控制框架。

Spring Security是 Spring提供的安全认证服务的框架。使用Spring Security可以帮助我们来简化认证和授权的过程。

19.2 导入依赖

<!--Spring Security-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

20、OAuth2 Client

20.1 简介

依赖说明：Spring Security 的 OAuth2/OpenID Connectclient 功能的 Spring Boot 集成。

OAuth（开放授权）是一个开放标准，允许用户授权第三方移动应用访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方移动应用或分享他们数据的所有内容，OAuth2.0是OAuth协议的延续版本，但不向后兼容OAuth 1.0即完全废止了OAuth1.0

20.2 导入依赖

<!--OAuth2 Client-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>

21、OAuth2 Resource Server

21.1 简介

依赖说明：Spring Security 的 OAuth2 资源服务器功能的 Spring Boot 集成。

OAuth（开放授权）是一个开放标准，允许用户授权第三方移动应用访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方移动应用或分享他们数据的所有内容，OAuth2.0是OAuth协议的延续版本，但不向后兼容OAuth 1.0即完全废止了OAuth1.0。

21.2 导入依赖

<!--OAuth2 Resource Server-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>

22、Spring LDAP

22.1 简介

依赖说明：使构建使用轻量级目录访问协议的基于 Spring 的用用程序变得更容易。

DAP的英文全称是Lightweight Directory Access Protocol，简称为LDAP。LDAP是轻量目录访问协议。目录服务是一个特殊的数据库，用来保存描述性的、基于属性的详细信息，支持过滤功能。它成树状结构组织数据，类似文件目录一样。目录数据库和关系数据库不同，它有优异的读性能，但写性能差，并且没有事务处理、回滚等复杂功能，不适于存储修改频繁的数据。所以目录天生是用来查询的，就好象它的名字一样。

22.2 导入依赖

<!--Spring LDAP-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-ldap</artifactId>
</dependency>

23、Okta

23.1 简介

依赖说明：针对 Spring Security/Spring Boot Oauth2 功能的 Okta 特定配置。使你的 Spring Boot 应用程序能够与 Okta Via Oauth 2.0/OIDC。

Okta的软件能让客户的员工很方便地使用单一、安全的账号，登录他们工作中需要使用的各种网络服务，或者供承包商、合作伙伴和客户所使用的网络服务。Okta的主要卖点之一是安全性，企业利用其软件可以让员工和其他人远程访问企业信息，而不会导致企业的敏感信息泄露。

23.2 导入依赖

版本原因，暂无。
需要 Spring Boot Version >= 2.1.2.RELEASE and < 2.7.0.M1

五、SQL

24、JDBC API

24.1 简介

依赖说明：定义客户端如何连接和查询数据库的数据库连接 API。

JDBC API定义了一系列Java类,用来表示数据库连接、SQL语句、结果集、数据库元数据等,能够使Java编程人员发送SQL语句和处理返回结果。

JDBC API由一个驱动程序管理器实现对连接到不同数据库的多个驱动程序的管理。

24.2 导入依赖

<!--JDBC API-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

25、Spring Data JPA

依赖说明：使用 Spring Data 和 Hibernate 使用 Java Persistence API 将 SQL 存储中的数据持久化。

SpringData：其实SpringData就是Spring提供了一个操作数据的框架。而SpringData JPA只是SpringData框架下的一个基于JPA标准操作数据的模块。
SpringData JPA：基于JPA的标准数据进行操作。简化操作持久层的代码。只需要编写接口就可以。

总的来说JPA是ORM规范，Hibernate、TopLink等是JPA规范的具体实现，这样的好处是开发者可以面向JPA规范进行持久层的开发，而底层的实现则是可以切换的。Spring Data Jpa则是在JPA之上添加另一层抽象（Repository层的实现），极大地简化持久层开发及ORM框架切换的成本。

<!--Spring Data JPA-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

26、Spring Data JDBC

依赖说明：使用 Spring Data 使用普通 JDBC 将 SQL 存储汇总的数据持久化。

早期的JPA的特性是懒加载和关联查询，一下能查出所有的关联信息，但我们开发者在查询SQL的时候往往只需要某几个字段，而JPA甚至关联表的所有字段查询出来，如果不需要那么多message,那么查询的性能会大大降低。

Spring官网为此提供了另一个解决方案——spring-data-jdbc，另一种形式的Java持久化的API工具集，相比JPA来讲，更简单，更高效，没有session, 一次查询查询出指定的结果，没有多余数据。

<!--Spring Data JDBC-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>

27、Spring Data R2DBC

依赖说明：提供反应式关系数据库链接，以在反应式应用程序中使用SPring Data 将数据保存在SQL存储中。

Spring Data R2DBC是更大的Spring Data系列的一部分，可以轻松实现基于R2DBC的存储库。 R2DBC代表Reactive Relational Database Connectivity，它是一个使用反应式驱动程序集成关系数据库的孵化器。 Spring Data R2DBC为R2DBC应用熟悉的Spring抽象和存储库支持。它可以更轻松地构建在响应式应用程序堆栈中使用关系数据访问技术的Spring驱动的应用程序。

传统情况Java 使用 JDBC 来操作关系型数据库，而 JDBC 是阻塞的、同步的，即使使用线程池进行改善也是有限的。基于此，Spring官方（Pivotal）提出了R2DBC（Reactive Relational Database Connectivity）。R2DBC是一项API规范计划，它声明了一个反应式API，该方法将由数据库厂商实现以访问其关系数据库。

<!--Spring Data R2DBO-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-r2dbc</artifactId>
</dependency>

28、MyBatis Framework

依赖说明：支持自定义SLQ、存储过程和高级映射。MyBatis 使用 XML 描述符或注解将对象与存储过程或 SQL 语句耦合。

mybatis是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程，它使用了ORM思想实现了结果集的封装。

ORM：Object Relational Mapping（对象关系映射），即：把数据库表和实体类及实体类的属性对应起来，让开发人员可以操作实体类就可以实现对数据库表的操作

<!--MyBatis Framework-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <!--版本根据实际情况调整-->
    <version>2.2.0</version>
</dependency>

29、Liquibase Migration

依赖说明： Liquibase 数据库迁移和源代码控制库。

Liquibase社区版是一个开源项目，可以帮助开发人员快速管理数据库架构更改。跟踪、版本化和部署数据库变更。目前基于Maven插件将Liquibase集成到项目中，可以使数据库可持续开发部署管理。

<!--Liquibase Migration-->
<dependency>
    <groupId>org.liquibase</groupId>
    <artifactId>liquibase-core</artifactId>
</dependency>

30、Flyway Migration

依赖说明：数据库的版本控制，以便你可以从任何版本（包括空数据库）迁移到架构的最新版本。

Flyway 是数据库的版本控制管理工具。当一个团队中，有人对数据库做出了修改，可以同步给团队中的所有人，团队中所有成员的数据库都会得到相应的改动。

<!--Flyway Migration-->
<dependency>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-core</artifactId>
</dependency>

31、JOOQ Access Layer

依赖说明：从你的数据库生成 Java 代码并通过流畅的 API 构建类型安全的 SQL 查询。

JOOQ 是基于Java访问关系型数据库的工具包，轻量，简单，并且足够灵活，可以轻松的使用Java面向对象语法来实现各种复杂的sql。

<!--JOOQ Access Layer-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jooq</artifactId>
</dependency>

32、IBM DB2 Driver

依赖说明：提供对 IBM DB2 的访问的 JDBC 驱动程序。

DB2是IBM推出的第二个关系型数据库，所以称为db2。

IBM DB2 是美国IBM公司开发的一套关系型数据库管理系统，它主要的运行环境为UNIX（包括IBM自家的AIX）、Linux、IBM i（旧称OS/400）、z/OS，以及Windows服务器版本。
DB2主要应用于大型应用系统，具有较好的可伸缩性，可支持从大型机到单用户环境，应用于所有常见的服务器操作系统平台下。 DB2提供了高层次的数据利用性、完整性、安全性、可恢复性，以及小规模到大规模应用程序的执行能力，具有与平台无关的基本功能和SQL命令。DB2采用了数据分级技术，能够使大型机数据很方便地下载到LAN数据库服务器，使得客户机/服务器用户和基于LAN的应用程序可以访问大型机数据，并使数据库本地化及远程连接透明化。 DB2以拥有一个非常完备的查询优化器而著称，其外部连接改善了查询性能，并支持多任务并行查询。 DB2具有很好的网络支持能力，每个子系统可以连接十几万个分布式用户，可同时激活上千个活动线程，对大型分布式应用系统尤为适用。

<!--IBM DB2 Driver-->
<dependency>
    <groupId>com.ibm.db2</groupId>
    <artifactId>jcc</artifactId>
    <scope>runtime</scope>
</dependency>

33、Apache Derby Database

依赖说明：一个完全用 Java 实现的开源关系数据库。

Apache Derby 项目的目标是构建一个完全用 Java 编程语言编写的、易于使用却适合大多数应用程序的开放源码数据库。

<!--Apache Derby Database-->
<dependency>
    <groupId>org.apache.derby</groupId>
    <artifactId>derby</artifactId>
    <scope>runtime</scope>
</dependency>

34、H2 Database

依赖说明：提供支持 JDBC API 和 R2DBC 访问的快速内存数据库，占用空间小（2MB）。支持嵌入式和服务器模式以及基于浏览器的控制台应用程序。

H2 Database是一个开源的嵌入式数据库引擎，采用java语言编写，不受平台的限制，同时H2 Database提供了一个十分方便的web控制台用于操作和管理数据库内容。H2 Database还提供兼容模式，可以兼容一些主流的数据库，因此采用H2 Database作为开发期的数据库非常方便。

<!--H2 Database-->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

35、HyperSQL Database

依赖说明：轻量级 100% java SQL 数据库引擎。

HSQLDB（HyperSQL 数据库）是一位接近地遵照SQL的现代的实体-关系型的数据库管理。

<!--HyperSQL Database-->
<dependency>
    <groupId>org.hsqldb</groupId>
    <artifactId>hsqldb</artifactId>
    <scope>runtime</scope>
</dependency>

36、MariaDB Driver

依赖说明：MariaDB JDBC 和 R2DBC 驱动程序。

MariaDB数据库管理系统是MySQL的一个分支，主要由开源社区在维护，采用GPL授权许可MariaDB的目的是完全兼容MySQL，包括API和命令行，使之能轻松成为MySQL的代替品。

<!--MariaDB Driver-->
<dependency>
    <groupId>org.mariadb.jdbc</groupId>
    <artifactId>mariadb-java-client</artifactId>
    <scope>runtime</scope>
</dependency>

37、MS SOL Server Driver

依赖说明：一个 JDBC 和 R2DBC 驱动程序，提供从任何Java 应用程序对 Microsoft SQL Server 和 Azure SQL 数据库的访问。

SQL Server 是Microsoft 公司推出的关系型数据库管理系统。

Azure SQL数据库是一种云计算数据库服务（数据库即服务），由Microsoft Azure平台提供，可帮助在云中托管和使用关系SQL数据库，而无需安装任何硬件或软件。

<!--MS SQL Server Driver-->
<dependency>
    <groupId>com.microsoft.sqlserver</groupId>
    <artifactId>mssql-jdbc</artifactId>
    <scope>runtime</scope>
</dependency>

38、MySQL Driver

依赖说明：MySQL JDBC 和 R2DBC 驱动程序。

MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，属于 Oracle 旗下产品。MySQL 是最流行的关系型数据库管理系统之一，在 WEB 应用方面，MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一。
MySQL 比较流行，资源比较多，自行搜索。

<!--MySQL Driver-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

39、Oracle Driver

依赖说明：提供对 Oracle 的访问的 JDBC 驱动程序。

Oracle Database，又名Oracle RDBMS，或简称Oracle。是甲骨文公司的一款关系数据库管理系统。它是在数据库领域一直处于领先地位的产品。可以说Oracle数据库系统是世界上流行的关系数据库管理系统，系统可移植性好、使用方便、功能强，适用于各类大、中、小微机环境。它是一种高效率的、可靠性好的、适应高吞吐量的数据库方案。

Oracle 不过多赘述，比较流行，资源非常多。

<!--Oracle Driver-->
<dependency>
    <groupId>com.oracle.database.jdbc</groupId>
    <artifactId>ojdbc8</artifactId>
    <scope>runtime</scope>
</dependency>

40、PostgreSQL Driver

依赖说明：一个 JDBC 和 R2DBC 驱动程序，它允许 Java 程序使用标准的、独立于数据库的 Java 代码连接到 PostgreSLQ 数据库

PostgreSQL是由 PostgreSQL 社区全球志愿者开发团队开发/维护的对象-关系型数据库管理系统(Object-Relational DataBase Management System).

<!--PostgresQL Driver-->
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

六、NoSQL

41、Spring Data Redis(Access+Driver)

依赖说明：用于同步、异步和反应式使用的高级和线程安全 Java Redis 客户端。支持集群、哨兵、流水线、自动重新连接、编解码器等。

Redis是用C语言开发的一个开源的高性能基于内存运行的键值对NoSQL数据库

<!--Spring Data Redis (Access + Driver)-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

42、Spring Data Reactive Redis

依赖说明：使用 Spring Data Redis 以响应方式访问 Redis 键值数据存储。

Redis是用C语言开发的一个开源的高性能基于内存运行的键值对NoSQL数据库

<!--Spring Data Reactive Redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

43、Spring Data MongoDB

依赖说明：将数据存储在灵活的、类似 JSON 的文档中，这意味着字段可以因文档而异，并且数据结构可以随着时间的推移而改变。

MongoDB是NoSQL数据库的一种，是一种文档型数据库，它使用的是一种类似于JSON的数据结构既BSON。

<!--Spring Data MongoDB-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

44、Spring Data Reactive MongoDB

依赖说明：为 MongoDB 提供异步流处理和非阻塞回压。

MongoDB是NoSQL数据库的一种，是一种文档型数据库，它使用的是一种类似于JSON的数据结构既BSON。

<!--Spring Data Reactive MongoDB-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb-reactive</artifactId>
</dependency>

45、Spring Data Elasticsearch(Access+Driver)

依赖说明：带有 Spring Data Elasticsearch 的分布式 RESTful 搜索和分析引擎。

ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。官方客户端在Java、.NET（C#）、PHP、Python、Apache Groovy、Ruby和许多其他语言中都是可用的。根据DB-Engines的排名显示，Elasticsearch是最受欢迎的企业搜索引擎，其次是Apache Solr，也是基于Lucene。

<!--Spring Data Elasticsearch (Access+Driver)-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

46、Spring Data for Apache Cassandra

依赖说明：一个免费的开源分布式 NoSQL 数据库管理系统，可提供高可扩展性和高性能。

Apache Cassandra 是一个开源的、分布式、无中心、弹性可扩展、高可用、容错、一致性可调、面向行的数据库，它基于 Amazon Dynamo 的分布式设计和 Google Bigtable 的数据模型，由 Facebook 创建，在一些最流行的网站中得到应用

<!--Spring Data for Apache Cassandra-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-cassandra</artifactId>
</dependency>

47、Spring Data Reactive for Apache Cassandra

依赖说明：以反应方式访问 Cassandra NoSQL 数据库。

<!--Spring Data Reactive for Apache Cassandra-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-cassandra-reactive</artifactId>
</dependency>

48、Spring for Apache Geode

依赖说明：Apache Geode 是一个数据管理平台，可帮助用户大规模构建与 Pivotal Cloud Cache 兼容的实时、高并发、高性能和可靠的 Spring Boot 应用程序。

Apache Geode是一个数据管理平台，可在广泛分布的云架构中提供对数据密集型应用程序的实时，一致的访问。

Geode跨多个进程汇集内存，CPU，网络资源和可选的本地磁盘，以管理应用程序对象和行为。它使用动态复制和数据分区技术来实现高可用性，改进的性能，可伸缩性和容错性。除了作为分布式数据容器之外，Geode还是一个内存数据管理系统，可提供可靠的异步事件通知和有保证的消息传递。

<!--Spring for Apache Geode-->
<dependency>
    <groupId>org.springframework.geode</groupId>
    <artifactId>spring-geode-starter</artifactId>
</dependency>

49、Spring Data Couchbase

依赖说明：NoSQL 面向文档的数据库，提供内存优先架构、地理分布式部署和工作负载隔离。

CouchBase是一款开源的、分布式的、面向文档的NoSQL数据库，主要用于分布式缓存和数据存储领域。能够通过manage cache提供快速的亚毫米级别的k-v存储操作，并且提供快速的查询和其功能强大的能够指定SQL-like查询的查询引擎。

<!--Spring Data Couchbase-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-couchbase</artifactId>
</dependency>

50、Spring Data Reactive Couchbase

依赖说明：使用 Spring Data Couchbase 以反应方式访问 Couchbase NoSQL 数据库。

<!--Spring Data Reactive Couchbase-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-couchbase-reactive</artifactId>
</dependency>

51、Spring Data Neo4j

依赖说明：一个开源的 NoSQL 数据库，它存储结构化为由节点组成的图形的数据，通过关系连接。

Neo4j是一个高性能的NOSQL图形数据库，它将结构化数据存储在网络上而不是表中。它是一个嵌入式的、基于磁盘的、具备完全的事务特性的Java持久化引擎，但是它将结构化数据存储在网络（从数学角度叫做图）上而不是表中。Neo4j也可以被看作是一个高性能的图引擎，该引擎具有成熟数据库的所有特性。程序员工作在一个面向对象的、灵活的网络结构下，而不是严格、静态的表中。但是他们可以享受到具备完全的事务特性、企业级的数据库的所有好处。Neo4j因其嵌入式、高性能、轻量级等优势，越来越受到关注。

<!--Spring Data Neo4j-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-neo4j</artifactId>
</dependency>

七、Messaging

52、Spring Integration

依赖说明：添加对企业集成模式的支持。通过声明式适配器启用轻量级消息传递并支持与外部系统的集成。

spring-integration是一个功能强大的EIP(Enterprise Integration Patterns)，即企业集成模式。其实spring integeration就类似一个水电系统，总闸，各层楼的控制，分流，聚合，过滤，沉淀，消毒，排污这里的每一个环节都类似一个系统服务，可能是jms,可能是redis,可能是MongoDB，可能是Tcp/UDP，可能是job,可能是我们系统服务的任何一个模块
那么Spring Integration扮演的角色就是将这些功能能够连接起来组成一个完整的服务系统，实现企业系统的集成的解决方案。就像管道一样将各个模块连接到一起，管道能够连接到千家万户需要很多零件水表，分头管，水龙头，管道开关等等这些就是Spring Integration的主要组件。

<!--Spring Integration-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-integration</artifactId>
</dependency>

53、Spring for RabbitMQ

依赖说明：为你的应用程序提供一个通用平台来发送和接收消息，并为你的消息提供一个安全的地方，直到收到为止。

MQ全称为Message Queue，即消息队列。“消息队列”是在消息的传输过程中保存消息的容器。它是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。

<!--Spring for RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

54、Spring for Apache Kafka

依赖说明：发布、订阅、存储和处理记录流。

Kafka 是一个消息系统，原本开发自 LinkedIn，用作 LinkedIn 的活动流（Activity Stream）和运营数据处理管道（Pipeline）的基础。现在它已被多家不同类型的公司作为多种类型的数据管道和消息系统使用。

<!--Spring for Apache Kafka-->
<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>

55、Spring for Apache Kafka Streams

依赖说明：使用 Apache Kafka Streams 构建流处理应用程序。

Kafka Streams。Apache Kafka开源项目的一个组成部分。是一个功能强大，易于使用的库。用于在Kafka上构建高可分布式、拓展性，容错的应用程序。

<!--Spring for Apache Kafka Streams-->
<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-streams</artifactId>
</dependency>

56、Spring for Apache ActiveMQ5

依赖说明：Spring JMS 支持 Apache ActiveMQ ‘Classic’

Apache ActiveMQ是Apache软件基金会所研发的开放源代码消息中间件；由于ActiveMQ是一个纯Java程序，因此只需要操作系统支持Java虚拟机，ActiveMQ便可执行。

MQ全称是MessageQueue（消息队列），是一个消息的接收和转发的容器，主要用于消息的推送。ActiveMQ是Apache提供的一个开源消息中间件，纯Java技术实现。

<!--Spring for Apache ActiveMQ 5-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>

57、Spring for Apache ActiveMQ Artemis

依赖说明：Apache ActiveMQ Artemis 的 Spring JMS 支持。

ActiveMQ 是一款基于 Java 的消息服务器，它使用行业标准协议，支持我们把各种语言和平台开发的系统连接在一起。目前 ActiveMQ 分为两个版本：ActiveMQ 5 和 ActiveMQ Artemis (下一代ActiveMQ)。当 ActiveMQ Artemis 达到 ActiveMQ 功能时当会变为 ActiveMQ 6 。
Spring JMS 是专门用来处理 Spring 消息的模块。它支持主流的消息中间键，能完美结合 ActiveMQ 。Spring Boot 应用通过集成 Spring JMS 模块整合 ActiveMQ ，本文涉及 ActiveMQ 5 和 ActiveMQ Artemis 两种配置方法，跟据项目实际使用 ActiveMQ 的版本，采取一种配置即可。

<!--Spring for Apache ActiveMQ Artemis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-artemis</artifactId>
</dependency>

58、WebSocket

依赖说明：使用 SockS 和 STOMP 构建 WebSocket 应用程序。

WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的应用层的协议。在 WebSocket API 中，浏览器和服务器只需要做一个握手的动作，然后，浏览器和服务器之间就创建了持久性的连接，两者之间就直接可以进行双向数据传输。

所有浏览器都支持 WebSocket ，目的是在服务器可以在任意时刻发消息给浏览器，不需要等待浏览器的请求。
浏览器通过 JavaScript 向服务器发出建立 WebSocket 连接的请求，连接建立以后，客户端和服务器端就可以通过 TCP 连接直接交换数据。

<!--WebSocket-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

59、RSocket

依赖说明：带有 Spring Messaging 和 Netty 的 RSocket.io 应用程序

RSocket是一个二进制的协议，以异步消息的方式提供4种对等的交互模型，以字节流的方式运行在TCP, WebSockets, Aeron等传输层之上。RSocket专门设计用于与Reactive风格应用配合使用，这些应用程序基本上是非阻塞的，并且通常（但不总是）与异步行为配对。它是传输无关的，支持 TCP、WebSocket和Aeron UDP协议，并支持无语义损失的混合传输协议——回压和流量控制仍然有效。

它还支持连接恢复。当你建立 RSocket 连接时，你可以指定前一个连接的 ID，如果流仍然在服务器的内存中，则你可以继续消费你的流。

<!--RSocket-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-rsocket</artifactId>
</dependency>

60、Apache Camel

依赖说明：Apache Camel 是一个开源集成框架，使你能够快速轻松地集成时候用或生成数据的各种系统。

Apache Camel 是一个非常强大的基于规则的路由以及媒介引擎，该引擎提供了一个基于POJO的企业应用模式(Enterprise Integration Patterns)的实现，你可以采用其异常强大且十分易用的API (可以说是一种Java的领域定义语言 Domain Specific Language)来配置其路由或者中介的规则。
通过这种领域定义语言，你可以在你的IDE中用简单的Java Code就可以写出一个类型安全并具有一定智能的规则描述文件。

<!--Apache Camel-->
版本问题，后期补充
要求Spring Boot Version >= 2.0.0.M1 and < 2.7.0.M1

61、Solace PubSub+

依赖说明：连接到 Solace PubSub+ 高级事件代理以发布、订阅、请求/回复和存储/重播消息。

一个完整的实时企业事件流和管理平台。PubSub+ 平台可帮助企业跨混合云、多云和物联网环境设计、部署和管理事件驱动架构 (EDA)，从而使它们能够更加集成和事件驱动。

https://www.solace.dev/start-spring-io-help/

<!--Solace PubSub+-->
版本问题，后期补充
要求Spring Boot Version >= 2.2.0.RELEASE and < 2.7.0.M1

八、I/O

62、Spring Batch

依赖说明：具有事务、重试/跳过和基于块的处理的批处理应用程序。

Spring Batch是一个轻量级，全面的批处理框架，旨在开发对企业系统日常运营至关重要的强大批处理应用程序。 Spring Batch构建了人们期望的Spring Framework特性（生产力，基于POJO的开发方法和一般易用性），同时使开发人员可以在必要时轻松访问和利用更高级的企业服务。 Spring Batch不是一个schuedling的框架。

Spring Batch提供了可重用的功能，这些功能对于处理大量的数据至关重要，包括记录/跟踪，事务管理，作业处理统计，作业重启，跳过和资源管理。它还提供更高级的技术服务和功能，通过优化和分区技术实现极高容量和高性能的批处理作业。 Spring Batch可用于两种简单的用例（例如将文件读入数据库或运行存储过程）以及复杂的大量用例（例如在数据库之间移动大量数据，转换它等等）上）。大批量批处理作业可以高度可扩展的方式利用该框架来处理大量信息。

<!--Spring Batch-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-batch</artifactId>
</dependency>

63、Validation

依赖说明：使用 Hibernate 验证器进行 Bean 验证。

validation bean 是基于JSR-303标准开发出来的，使用注解方式实现，及其方便，但是这只是一个接口，没有具体实现

<!--Validation-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

64、Java Mail Sender

依赖说明：使用Java Mail 和 Spring Framework 的 JavaMailSender 发送电子邮件。

JavaMailSender是Spring封装的邮件发送封装类，支持普通文本、附件、html等格式。另外关于POP3、SMTP、IMAP、免费邮箱客户端授权码等概念自行百度了解。

<!--Java Mail Sender-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

65、Quartz Scheduler

依赖说明：使用 Quartz 安排作业。

quartz 是一款开源且丰富特性的“任务调度库”，能够集成与任何的java 应用，下到独立应用，大到电子商业系统。quartz就是基于java实现的任务调度框架，用于执行你想要执行的任何任务。

什么是任务调度？任务调度就是我们系统中创建了 N 个任务，每个任务都有指定的时间进行执行，而这种多任务的执行策略就是任务调度。

quartz 的作用就是让任务调度变得更加丰富，高效，安全，而且是基于 Java 实现的，这样子开发者只需要调用几个接口坐下简单的配置，即可实现上述需求。

核心
1）任务 Job
我们想要调度的任务都必须实现 org.quartz.job 接口，然后实现接口中定义的 execute( ) 方法即可

2）触发器 Trigger
Trigger 作为执行任务的调度器。我们如果想要凌晨1点执行备份数据的任务，那么 Trigger 就会设置凌晨1点执行该任务。其中 Trigger 又分为 SimpleTrigger 和 CronTrigger 两种

3）调度器 Scheduler
Scheduler 为任务的调度器，它会将任务 Job 及触发器 Trigger 整合起来，负责基于 Trigger 设定的时间来执行 Job

调度器（Scheduler）是Quartz框架的心脏，用来管理触发器和Job，并保证Job能被触发执行。程序员与框架内部之间的调用都是通过org.quartz.Scheduler接口来完成的。对于Scheduler接口的实现，其实只是核心调度（org.quartz.core.QuartzScheduler）的一个代理，对代理的方法进行调用时会传递到底层核心调度实例上。QuartzScheduler处于Quartz框架的根位置，驱动着整个Quartz框架。

<!--Quartz Scheduler-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

66、Spring cache abstraction

依赖说明：提供与缓存相关的操作，例如更新缓存内容的能力，但不提供实际的数据存储。

Spring Cache提供了对底层缓存使用的抽象，通过注解的方式使用缓存，减少了对原有的侵入性，通过一个抽象层，分离了不同后端缓存的实现，在不改变代码的前提下，可以切换底层缓存的实现。
Cache只有应用于幂等性的方法，即同样的输入，返回同样的数据（在数据没有变更时）。

在多线程的情况下，由Cache底层实现类保存线程安全。

<!--Spring cache abstraction-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

67、Picocli

依赖说明：使用Picocli 构建命令行应用程序。

Picocli 是一个单文件框架，用于创建几乎为零代码的 Java 命令行应用程序。它支持多种命令行语法样式，包括 POSIX、GNU、MS-DOS 等。它生成高度可定制的使用帮助消息，这些消息使用 ANSI 颜色和样式来对比重要元素并减少用户的认知负担。

基于 Picocli 的应用程序可以具有命令行 TAB补全，显示可用选项、选项参数和子命令，适用于任何级别的嵌套子命令。基于 Picocli 的应用程序可以提前编译为本机映像，具有极快的启动时间和较低的内存要求，可以作为单个可执行文件分发。

官网：https://picocli.info/

<dependency>
  <groupId>info.picocli</groupId>
  <artifactId>picocli-spring-boot-starter</artifactId>
  <version>4.6.3</version>
</dependency>

九、Ops

68、Spring Boot Actuator

依赖说明：支持内置（或自定义）端点，可让你监控和管理应用程序。例如应用程序运行状态、指标、会话等。

生产系统中，往往需要对系统实际运行的情况（例如cpu、io、disk、db、业务功能等指标）进行监控运维。在SpringBoot项目中Actuator模块提供了众多HTTP接口端点（Endpoint），来提供应用程序运行时的内部状态信息。

Actuator模块提供了一个监控和管理生产环境的模块，可以使用http、jmx、ssh、telnet等来管理和监控应用。包括应用的审计（Auditing）、健康（health）状态信息、数据采集（metrics gathering）统计等监控运维的功能。同时，提供了可以扩展 Actuator端点（Endpoint）自定义监控指标。这些指标都是以JSON接口数据的方式呈现。

<!--Spring Boot Actuator-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

69、Codecentric’s Spring Boot Admin(Client)

依赖说明：您的应用程序需要想 Codecentric 的 Spring Boot Admin Server 实例注册。

Spring Boot Admin是一个开源社区项目，是用来管理 Spring Boot 应用程序的一个简单的界面。应用程序作为Spring Boot Admin Client向为Spring Boot Admin Server注册（通过HTTP）或使用SpringCloud注册中心（例如Eureka，Consul）发现。 UI只是Spring Boot Actuator端点之上的Vue.js应用程序，展示Spring Boot Admin Client的Actuator端点上的一些监控。

pom

版本问题，后期补充
要求Spring Boot Version >= 2.0.0.RELEASE AND < 2.7.0.M1

70、Codecentric’s Spring Boot Admin(Server)

依赖说明：一个用于管理和监控 Spring Boot 应用程序的社区项目。在 Spring Boot Actuator 端点之上提供一个UI

POM

版本问题，后期补充.
要求Spring Boot Version >= 2.0.0.RELEASE AND < 2.7.0.M1

十、Observability

71、Datadog

依赖说明：将 Micrometer 指标发布到 Datadog，这是一种具有内置仪表板和警报的维度时间序列SaaS。

DataDog是一家专注于数字性能监控的厂商，产品范围包括应用性能监控、基础设施监控、组件监控及日志监控等，产品的形态是SAAS交付.

SaaS：说白了就是把网页形式的软件。PC软件变网站类型软件。

<!--Datadog-->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-datadog</artifactId>
    <scope>runtime</scope>
</dependency>

72、Influx

依赖说明：将 Micrometer 指标发布到 InfluxDB，这是一个支持实时数据流处理的维度时间序列服务器。

InfluxDb是一个高性能的时序数据库

首先简单介绍一下时序数据库的概念，时序数据库就是按照时间顺序存储的数据的数据库。在这个数据库里，时间是一个主要维度，存储的数据大多都是按照时间变化而变化的数据

时间序列是指将某种现象某一个统计指标在不同时间上的各个数值,按时间先后顺序排列而形成的序列。

<!--Influx-->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-influx</artifactId>
    <scope>runtime</scope>
</dependency>

73、Graphite

依赖说明：将 Micrometer 指标发布到 Graphite ，这是一个由固定大小数据库支持的分层指标系统。

Graphite是一个开源实时的、显示时间序列度量数据的图形系统。Graphite并不收集度量数据本身，而是像一个数据库，通过其后端接收度量数据，然后以实时方式查询、转换、组合这些度量数据。Graphite支持内建的Web界面，它允许用户浏览度量数据和图。

<!--Graphite-->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-graphite</artifactId>
    <scope>runtime</scope>
</dependency>

74、New Relic

依赖说明：将 Micrometer 指标发布到 New Relid ，这是一种具有完整 UI 和称为 NRQI 的查询语言的SaaS产品。（SaaS:通俗讲就是将软件用网站的形式表现。网页代替本地软件安装）

New Relic 是一个很强大的服务器性能监控工具，New Relic目前专注于SaaS和App性能管理业务，它支持支持agent和API传送数据，能够对部署在本地或在云中的web应用程序进行监控、故障修复、诊断、线程分析以及容量计划。

New Relic APM将你没有发现的问题暴漏出来，帮助团队减少问题解决的时间，从而集中精力写出更多的代码，而不是一直在停留在故障排除。

端对端事务跟踪：跟踪一个关键事务的性能，这个事务贯穿在整个面向服务应用程序环境。
代码级的可见性：深入洞察特定代码段和SQL语句对性能的影响。
关键事务：标记你的最关键的事务，当响应时间、调用、错误率等这些表现不佳的时候可以迅速的发现。
X光会话：通过展示事务跟踪长期分析的结果，来获得对一个关键事务性能更深入的了解。

<!--New Relid-->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-new-relic</artifactId>
    <scope>runtime</scope>
</dependency>

75、Prometheus

依赖说明：以 Prometheus 格式公开 Micrometer 指标，这是一个内存维度时间序列数据库，具有简单的内置UI、自定义查询语言和数学运算。

Prometheus 是一套开源的系统监控报警框架。它启发于 Google 的 borgmon 监控系统，由工作在 SoundCloud 的 google 前员工在 2012 年创建，作为社区开源项目进行开发，并于 2015 年正式发布。2016 年，Prometheus 正式加入 Cloud Native Computing Foundation，成为受欢迎度仅次于 Kubernetes 的项目。

<!--Prometheus-->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
    <scope>runtime</scope>
</dependency>

76、Sleuth

依赖说明：使用Spring Cloud Sleuth 通过日志进行分布式跟踪。

Spring Cloud Sleuth是一个在应用中实现日志跟踪的强有力的工具。使用Sleuth库可以应用于计划任务、多线程服务或复杂的Web请求，尤其是在一个由多个服务组成的系统中。当我们在这些应用中来诊断问题时，即使有日志记录也很难判断出一个请求需要将哪些操作关联在一起。

如果想要诊断复杂操作，通常的解决方案是在请求中传递唯一的ID到每个方法来识别日志。而Sleuth可以与日志框架Logback、SLF4J轻松地集成，通过添加独特的标识符来使用日志跟踪和诊断问题。

<!--Sleuth-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

77、Wavefront

依赖说明：将 Micrometer 指标发布到 Tanzu Observability by Wavefront ,这是一个基于 SaaS 的指标监控和分析平台，可让您对整个堆栈中的数据进行可视化、查询和警报。

Wavefront 以 SaaS 形式提供监控和分析功能，它就是为了监控云端服务而设计的，当然它也可以监控私有云中的传统系统和应用；Wavefront 从各个云服务收集详尽的性能数据和日志，供用户在此基础上分析应用的性能瓶颈所在、快速排除应用故障。

Wavefront 可以供应用平台管理员 SRE (Site Reliability Engineer) 、开发人员、系统管理员等各种角色所使用。使用者通过 Wavefront Query Language 来对 Wavefront 所收集的数据进行挖掘和分析，分析的结果以图形化的结果展现，便于使用者进行分析和比对。

Wavefront 支持分布式追踪技术，追踪是指记录并展示应用执行过程的能力，Wavefront 中的分布式追踪技术能够以图形化的方式来展示各个微服务之间的调用关系以及详细的运行参数，从而帮助使用者快速发现问题、定位失败原因、找到性能提升的瓶颈所在。

目前Wavefront 相关技术文章非常少，应该与使用的人较少有关。后续说不定会抛弃。

https://docs.wavefront.com/wavefront_springboot.html

版本问题，后期补充.
要求Spring Boot Version >= 2.3.0.M1 AND < 2.7.0.M1

78、Zipkin Client

依赖说明：使用现有 Zipkin 安装和 Spring Cloud Sleuth Zipkin 进行分布式跟踪。

在微服务系统中，随着业务的发展，系统会变得越来越大，那么各个服务之间的调用关系也就变得越来越复杂。一个 HTTP 请求会调用多个不同的微服务来处理返回最后的结果，在这个调用过程中，可能会因为某个服务出现网络延迟过高或发送错误导致请求失败，这个时候，对请求调用的监控就显得尤为重要了。

ZipKin入门介绍

Zipkin是一款开源的分布式实时数据追踪系统（Distributed Tracking System），基于 Google Dapper的论文设计而来，由 Twitter 公司开发贡献。其主要功能是聚集来自各个异构系统的实时监控数据。分布式跟踪系统还有其他比较成熟的实现，例如：Naver的Pinpoint、Apache的HTrace、阿里的鹰眼Tracing、京东的Hydra、新浪的Watchman，美团点评的CAT，skywalking等。

ZipKin架构

ZipKin可以分为两部分，一部分是zipkin server，用来作为数据的采集存储、数据分析与展示；zipkin client是zipkin基于不同的语言及框架封装的一些列客户端工具，这些工具完成了追踪数据的生成与上报功能。

<!--Zipkin Client-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

十一、Testing

79、Spring REST Docs

依赖说明：通过结合使用 Ascidoctor 手写和使用 Spring MVC 测试生成的自动生成的片段来记录 RESTful 服务。

Spring REST Docs 是一个为 Spring 项目生成 API 文档的框架，它通过在单元测试中额外添加 API 信息描述，从而自动生成对应的文档片段。

Spring REST Docs 可以生成准确可读的RESTful Service文档（当然一般的API文档同样得心应手）。

Spring 官方文档都是用 Spring REST Docs 生成的，其简洁性和可读性也是大家都认可的，不过 Spring REST Docs 的优势远不止于此：

代码无污染：Spring REST Docs 基于单元测试生成文档片段（snippets），不会侵入到源码中，所以就不会使得源码变得越来越臃肿。
单元测试：因为文档的生成是依赖单元测试的，以此可以矫正一些不爱写单元测试的程序员小哥哥。
支持 markdown：修改一行配置代码即可支持生成 MarkDown 语法的文档片段（不过要生成html文档目前官方只支持adoc文档）。
文档自动更新：文档自动更新？文档自动更新！默认的，在构建的时候，会首先运行单元测试，此时便生成了文档片段，然后在打包时，通过添加 asciidoctor-maven-plugin 插件即可生成最终的文档，只要是规范的开发过程，文档都会随版本的每次发布而自动更新！
可读性高：Spring 官方文档就是个例子。

<!--Spring REST Docs-->
<dependency>
    <groupId>org.springframework.restdocs</groupId>
    <artifactId>spring-restdocs-mockmvc</artifactId>
    <scope>test</scope>
</dependency>

80、Testcontainers

依赖说明：提供通用数据库、Selenium Web 浏览器或任何其他可以在 Docker 容器中运行的轻量级、一次性示例。
Testcontainers是一个Java库，支持JUnit测试，它提供了常见的数据库，Selenium Web浏览器或其他可以在Docker容器中运行的轻型，一次性实例。

<!--Testcontainers-->
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>junit-jupiter</artifactId>
    <scope>test</scope>
</dependency>

81、Contract Verifier

依赖说明：通过启用消费者驱动的合同（CDC）开发，将TDD移至软件架构级别。

测试是软件流程中非常重要，不可或缺的一个环节。一般的测试分为单元测试，集成测试，端到端的手工测试，这也是构成测试金字塔的三个层级。

<!--Contract Verifier-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-contract-verifier</artifactId>
    <scope>test</scope>
</dependency>

82、Contract Stub Runner

依赖说明：用于基于HTTP/消息的通信的Stub Runner。允许从 RestDocs 测试创建 WireMock 存根。

使用Spring Cloud Contract验证程序时可能遇到的一个问题是将生成的WireMock JSON存根从服务器端传递到客户端（或各种客户端）。在消息传递的客户端生成方面也是如此。

复制JSON文件/手动设置客户端进行消息传递是不成问题的。这就是为什么我们会介绍可以为您自动下载和运行存根的Spring Cloud Contract Stub Runner。

<!--Contract Stub Runner-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-contract-stub-runner</artifactId>
    <scope>test</scope>
</dependency>

83、Embedded LDAP Server

依赖说明：提供在单元测试中运行 LDAP 服务器的平台中立方式。

LDAP（Light Directory Access Portocol）是开放的Internet标准，支持跨平台的Internet协议，只需要通过LDAP做简单的配置就可以与服务器做认证交互。“简单粗暴”，可以大大降低重复开发和对接的成本。目录数据库(ldap)和关系数据库不同，它有优异的读性能，但写性能差，并且没有事务处理、回滚等复杂功能，不适于存储修改频繁的数据。所以目录天生是用来查询的。

LDAP服务器简单来说它是一种得到某些数据的快捷方式，同时LDAP服务器也是一个协议，它经常被用作集体的地址本使用，甚至可以做到更加庞大。它是一种特殊的数据库，与一般的数据库相比有很大的差距，LDAP服务器的读性与一般服务器相比更加优秀。同时LDAP服务器在查询上总了很多的优化，所以利用它可以快速查询出想要得到的结果，当然它也有缺陷，比如在更新方面，它会更新的很慢。

LDAP服务器的目录有哪些优势和特点，第一个特点就是LDAP服务器目录可以帮助大多数的用户解决网络服务的账户问题。第二个特点就是LDAP服务器目录它可以很好地保证了数据的完整性，因为你在LDAP服务器目录中规定了统一的数据库，从而可以实现资源的统一性。LDAP服务器目录的最后一个优势就是它的设计可以适用多种行业的服务组织。

使用LDAP服务器的格式，在LDAP服务器中会采用一种命名格式，这种常见的命名格式一般有两种，一种为RFC822命名法，它的标准格式是object_name@domain_name，这种命名方式非常像邮件的形式。另一种命名格式是LDAP URL和X.500，这种命名法也叫做属性化命名法，它可以包括服务对象的属性和活动目录所在的服务器。

<!--Embedded LDAP Server-->
<dependency>
    <groupId>com.unboundid</groupId>
    <artifactId>unboundid-ldapsdk</artifactId>
    <scope>test</scope>
</dependency>

84、Embedded MongoDB Database

依赖说明：提供在单元测试中运行 MongoDB 的平台中立方式。

资料不多。对MongoDB操作进行mock，便于本地或CI/CD环境的质量测试、覆盖率测试。

<!--Embedded MongoDB Database-->
<dependency>
    <groupId>de.flapdoodle.embed</groupId>
    <artifactId>de.flapdoodle.embed.mongo</artifactId>
    <scope>test</scope>
</dependency>

十二、Spring Cloud

85、Cloud Bootstrap

依赖说明：非特定Spring Cloud 功能，与外部库或集成无关（例如 Bootstrap 上下文和@RefreshScope）。

暂无找到匹配的相关资料。

<!--Cloud Bootstrap-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter</artifactId>
</dependency>

86、Function

依赖说明：通过函数促进业务逻辑的实现，并支持跨无服务器提供商的统一编程模型，以及独立运行（本地或在PaaS中）的能力。

SpringCloud Function作为SpringCloud家族成员最早在2017年提出，项目主要负责人为Mark Fisher，目前已经来到了3.0版本。SpringCloud Function的出现旨在为快速发展的Serverless市场提供一个Spring的接入路径，使用SpringCloud Function进行无服务（我这里直接称为函数式编程）的项目开发可以大大节约成本，同时对于SpringBoot熟悉的人可以迅速上手。

<!--Function-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-function-context</artifactId>
</dependency>

87、Task

依赖说明：允许用户使用Spring Clound 开发和运行短期微服务。在本地、云环境和Spring Cloud Data Flow 上运行他们。

Spring Cloud Task的目标是为Spring Boot应用程序提供创建短运行期微服务的功能。在Spring Cloud Task中，我们可以灵活地动态运行任何任务，按需分配资源并在任务完成后检索结果。Tasks是Spring Cloud Data Flow中的一个基础项目，允许用户将几乎任何Spring Boot应用程序作为一个短期任务执行。

<!--Task-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-task</artifactId>
</dependency>

十三、Spring Cloud Tools

88、Open Service Broker

依赖说明：用于构建实现Open Service Broker API的Spring Boot 应用程序的框架，该框架可以向在Cloud Foundry、Kubernetes和OpenShift等云原生平台中运行的应用程序提供服务。

Spring Cloud Open Service Broker是一个用于构建实现Open Service Broker API的Spring Boot应用程序的框架。

Open Service Broker API项目允许开发人员为云本地平台（如Cloud Foundry，Kubernetes和OpenShift）中运行的应用程序提供服务。 Spring Cloud Open Service Broker提供了一个基于Spring Boot的框架，使您能够在支持Open Service Broker API的平台上为您自己的托管服务快速创建服务代理。

版本问题，后期补充。
要求Spring Boot Version >= 2.0.0.RELEASE and <2.7.0.M1

十四、Spring Cloud Config

89、Config Client

依赖说明：连接到 Spring Cloud Config Server 以获取应用程序配置的客户端。

每个项目的配置文件都在自己的项目中配置，这样，在生产环境中，会带来很多麻烦，每改动一个配置可能要修改很多个项目，被修改的项目可能都要重新打包，重新部署。那能不能有一种方法，统一部署Spring Cloud 中的各个微服务的配置呢？这就是Spring Cloud Config。 Spring Cloud Config 是一种用来动态获取Git、SVN、本地的配置文件的一种工具。

怎么说呢？就好比每个项目都比如一个房间，每个房间都需要一把钥匙才能开启。而config 则是管理这些钥匙的，好比钥匙链，想要启动那个项目，就需要先从config中获取对应的钥匙，然后启动项目。

配置中心分为服务端和客户端，和eureka 有点像，服务端是一个单独的项目，用来管理其他服务的配置，其他的服务就是客户端。

一个配置中心提供的核心功能

提供服务端和客户端支持
集中管理各环境的配置文件
配置文件修改之后，可以快速的生效
可以进行版本管理
支持大的并发查询
支持各种语言

<!--Config Client-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

90、Config Server

依赖说明：通过 Git、SVN 或 HashiCorp Vault 对配置进行集中管理。

每个项目的配置文件都在自己的项目中配置，这样，在生产环境中，会带来很多麻烦，每改动一个配置可能要修改很多个项目， 被修改的项目可能都要重新打包，重新部署。那能不能有一种方法，统一部署Spring Cloud 中的各个微服务的配置呢？这就是Spring Cloud Config。 Spring Cloud Config 是一种用来动态获取Git、SVN、本地的配置文件的一种工具。

怎么说呢？就好比每个项目都比如一个房间，每个房间都需要一把钥匙才能开启。而config 则是管理这些钥匙的，好比钥匙链，想要启动那个项目，就需要先从config中获取对应的钥匙，然后启动项目。

配置中心分为服务端和客户端，和eureka 有点像，服务端是一个单独的项目，用来管理其他服务的配置，其他的服务就是客户端。

一个配置中心提供的核心功能

提供服务端和客户端支持
集中管理各环境的配置文件
配置文件修改之后，可以快速的生效
可以进行版本管理
支持大的并发查询
支持各种语言

<!--Config Server-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

91、Vault Configuration

依赖说明：为分布式系统中的外部化配置提供客户端支持。使用HashiCorp的Vault，您可以在一个中心位置管理所有环境中应用程序的外部机密属性。

Hashicorp Vault解决了管理敏感信息的问题 —— 在Vault的用语中使用“secret”。在这种情况下，“管理”意味着Vault控制敏感信息的所有方面：它的生成，存储，使用以及最后它的撤销。

Hashicorp提供两种版本的Vault。本文中使用的开源版本可以免费使用，即使在商业环境中也是如此。同时还提供付费版本，其中包括不同SLA的技术支持和其他功能，例如HSM（硬件安全模块）支持。

<!--Vault Confiquration-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-vault-config</artifactId>
</dependency>

92、Apache Zookeeper Configuration

依赖说明：在您的应用程序中启用和配置通用模式，并使用基于Apache Zookeeper的组件构建大型分布式系统。提供的模式包括服务发现和配置。

项目中常用的一些配置，例如数据库的配置等，一般都是直接写死在项目中。如若更改，简单暴力的办法就是修改配置文件后再上传。单个或小型分布式项目部署的微服务所需的配置都很少，但集群若有上百台或者更多的机器，一个个地修改可就不那么好办了，因此使用配置中心作统一的配置管理是非常有必要的。

Zookeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包裹：配置维护、域名服务、分布式同步、组服务等。

<!--Apache Zookeeper Confiquration-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zookeeper-config</artifactId>
</dependency>

93、Consul Configuration

依赖说明：使用Hashicorp的Consul启用和配置应用程序中的通用模式并构建大型分布式系统。提供的模式包括服务发现、分布式配置和控制总线。

Consul是HashiCorp公司推出的开源软件，使用GO语言编写，提供了分布式系统的服务注册和发现、配置等功能，这些功能中的每一个都可以根据需要单独使用，也可以一起使用以构建全方位的服务网格。Consul不仅具有服务治理的功能，而且使用分布式一致协议RAFT算法实现，有多数据中心的高可用方案，并且很容易和Spring Cloud等微服务框架集成，使用起来非常的简单，具有简单、易用、可插排等特点。使用简而言之，Consul提供了一种完整的服务网格解决方案。

<!--Consul Configuration-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-consul-config</artifactId>
</dependency>

十五、Spring Cloud Discovery

94、Eureka Discovery Client

依赖说明：一种基于REST的服务，用于定位服务，以实现中间层服务器的负载平衡和故障转移。

Eureka是一种基于REST（Representational State Transfer）的服务，主要用于AWS云，用于定位服务，以实现中间层服务器的负载平衡和故障转移。我们将此服务称为Eureka Server。Eureka还附带了一个基于Java的客户端组件Eureka Client，它使与服务的交互变得更加容易。客户端还有一个内置的负载均衡器，可以进行基本的循环负载均衡。在Netflix，一个更复杂的负载均衡器包含Eureka基于流量，资源使用，错误条件等多种因素提供加权负载平衡，以提供卓越的弹性。

Eureka Client 在 Eureka Server 注册，然后Eureka Client 每30秒向 Eureka Server 发送一次心跳来更新一次租约。如果 Eureka Client 无法续订租约几次，则会在大约90秒内 Eureka Server 将其从服务器注册表中删除。注册信息和续订将复制到群集中的所有 Eureka Server 节点。来自任何区域的客户端都可以查找注册表信息（每30秒发生一次）根据这些注册表信息，Application Client 可以远程调用 Applicaton Service 来消费服务。

<!--Eureka Discovery Client-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

94、Eureka Server

依赖说明：Spirng Cloud Eureka使用Netflix Eureka来实现服务注册与发现。它既包含了服务端组件，也包含了客户端组件，并且服务端与客户端均采用java编写，所以Eureka主要适用于通过java实现的分布式系统，或是JVM兼容语言构建的系统。

Eureka的服务端提供了较为完善的REST API，所以Eureka也支持将非java语言实现的服务纳入到Eureka服务治理体系中来，只需要其他语言平台自己实现Eureka的客户端程序。目前.Net平台的Steeltoe、Node.js的eureka-js-client等都已经实现了各自平台的Ereka客户端组件。

<!--Eureka Server-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

96、Apache Zookeeper Discovery

依赖说明：使用Apache Zookeeper进行服务发现。

Zookeeper是一个高性能，分布式的，开源分布式应用协调服务。它提供了简单原始的功能，分布式应用可以基于它实现更高级的服务，比如同步，配置管理，集群管理，名空间。它被设计为易于编程，使用文件系统目录树作为数据模型。

<!--Apache Zookeeper Discovery-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
</dependency>

97、Cloud Foundry Discovery

依赖说明：使用Cloud Foundry发现服务。

没有找到准确匹配的，先找相似匹配的，后期根据情况再做调整。

Spring Cloud for Cloudfoundry可以轻松地在Cloud Foundry（平台即服务）中运行Spring Cloud应用程序。Cloud Foundry具有“服务”的概念，即“绑定”到应用程序的middlware，实质上为其提供包含凭据的环境变量（例如，用于服务的位置和用户名）。
该spring-cloud-cloudfoundry-discovery项目提供了Spring Cloud Commons的实现，DiscoveryClient因此您可以@EnableDiscoveryClient提供您的凭据spring.cloud.cloudfoundry.discovery.[email,password]，然后您可以DiscoveryClient直接使用或通过LoadBalancerClient（*.url如果您没有连接到Pivotal Web服务）.

<!--Cloud Foundry Discovery-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-cloudfoundry-discovery</artifactId>
</dependency>

98、Consul Discovery

依赖说明：使用Hashicorp Consul发现服务。

Consul 是 HashiCorp 公司推出的开源工具，用于实现分布式系统的服务发现与配置。与其它分布式服务注册与发现的方案，Consul 的方案更“一站式”，内置了服务注册与发现框架、分布一致性协议实现、健康检查、Key/Value 存储、多数据中心方案，不再需要依赖其它工具（比如 ZooKeeper 等）。使用起来也较为简单。Consul 使用 Go 语言编写，因此具有天然可移植性(支持Linux、windows和Mac OS X)；安装包仅包含一个可执行文件，方便部署，与 Docker 等轻量级容器可无缝配合。

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

十六、Spring Cloud Routing

99、Gateway

依赖说明：提供一种简单而有效的方法来路由到API并为他们提供跨领域的关注点，例如安全性、监控/指标和弹性。

Spring Cloud Gateway 是 Spring Cloud 的一个全新项目，该项目是基于 Spring 5.0，Spring Boot 2.0 和 Project Reactor 等技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。

Spring Cloud Gateway 作为 Spring Cloud 生态系统中的网关，目标是替代 Netflix Zuul，其不仅提供统一的路由方式，并且基于 Filter 链的方式提供了网关基本的功能，例如：安全、监控、埋点和限流等。

<!--Gateway-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

100、OpenFeign

依赖说明：声明式REST客户端。OpenFeign创建了一个用JAX-RS或Spring MVC注释修饰的接口的动态实现。

OpenFeign是一个声明式WebService客户端。使用Feign能让编写Web Service客户端更加简单，它的使用方法就是定义一个接口，然后在上面添加注解，同时也支持JAX-RS标准的注解。Feign也支持可插拔式的编码器和解码器。SpringCloud对Feign进行了封装，使其支持了Spring MVC标准注解和HttpMessageConverters。Feign可以与Eureka和Ribbon组合使用以支持负载均衡。

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

101、Cloud LoadBalancer

依赖说明：使用Spring Cloud LoadBalancer进行客户端负载平衡。

Spring Cloud LoadBalancer是一个客户端负载均衡器，类似于Ribbon，但是由于Ribbon已经进入维护模式，并且Ribbon 2并不与Ribbon 1相互兼容，所以Spring Cloud全家桶在Spring Cloud Commons项目中，添加了Spring cloud Loadbalancer作为新的负载均衡器，并且做了向前兼容，就算你的项目中继续用 Spring Cloud Netflix 套装（包括Ribbon，Eureka，Zuul，Hystrix等等）让你的项目中有这些依赖，你也可以通过简单的配置，把ribbon替换成Spring Cloud LoadBalancer。

<!--Cloud LoadBalancer-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

十七、Spring Cloud Circuit Breaker

102、Resilience4J

依赖说明：以Resilience4J作为底层实现的Spring Cloud断路器。

熔断器：当某个机器接口失败率达到某一条件（比如失败率>50%），就可以采用熔断器将服务器从集群机器中移除，或者采用自定义的业务逻辑降级方案，比如从一个接口转到另一个接口。熔断器只是一个工具，重要的是业务逻辑。

Resilience4j 是受Netflix的Hysrix项目启发，专门为Java 8 和函数式编程设计的轻量级容错框架。Resilicenes4j 仅使用了一个第三方开源库Vavr，Vavr不依赖其他库。相比较而言，Netflix Hysrix对Archaius存在编译依赖，Archaius有许多外部依赖，比如Guava和Apache Commons Configuration。Resilience4j 按模块发布，可以有选择的使用其中某些功能而无需引入全部的Resilience4j 组件。

<!--Resilience4J-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-circuitbreaker-resilience4j</artifactId>
</dependency>

十八、Spring Cloud Messaging

103、Cloud Bus

依赖说明：将分布式系统的节点与轻量级消费代理链接，该消息代理可用于广播状态更改或其他管理指令（需要绑定程序，例如Apache Kafka 或 RabbitMQ）。

Spring Cloud Bus（消息总线）通过一个轻量级的消息中间件可以连接分布式系统中的各个节点。可以使用该总线来广播某些状态的改变（比如配置信息发生变更）或其他管理指令。可以说，消息总线是spring boot应用扩展“道路”上的推进器，而且也把它用来作应用间相互通信的消息管道。

<!--Cloud Bus-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-bus</artifactId>
</dependency>

104、Cloud Stream

依赖说明：用于构建与共享消息系统相连接的高度可伸缩的事件驱动微服务的框架（需要一个绑定器，比如Apache Kafka，RabbitMQ或Solace PubSub+）。

Spring Cloud Stream 是一个用来为微服务应用构建消息驱动能力的框架。它可以基于 Spring Boot 来创建独立的、可用于生产的 Spring 应用程序。Spring Cloud Stream 为一些供应商的消息中间件产品提供了个性化的自动化配置实现，并引入了发布-订阅、消费组、分区这三个核心概念。通过使用 Spring Cloud Stream，可以有效简化开发人员对消息中间件的使用复杂度，让系统开发人员可以有更多的精力关注于核心业务逻辑的处理。但是目前 Spring Cloud Stream 只支持 RabbitMQ 和 Kafka 的自动化配置。

<!--Cloud Stream-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-stream</artifactId>
</dependency>

十九、VMware Tanzu Application Service

105、Config Client(TAS)

依赖说明：在VMware Tanzu 应用服务商配置客户端。

VMware Tanzu Application Service：是一个现代化的应用平台，适用于那些想要跨云持续交付和运行微服务的企业。

TAS(test-and-set)：在计算机科学中，test-and-set指令是一种用来将1 (set)写入一个内存位置，并以单个原子的形式返回其旧值的指令。,不可中断)操作。AS特点是自旋，也就是循环，每次尝试去设置值，如果设置成功则会返回，如果没有返回就会一直自旋，知道设置成功值。此时进入临界区，执行完临界区数据，再设置bool变量为false。从而让其他线程拿到锁。

<!--Config Client-->
版本问题，后期补充
要求Spring Boot Version >= 2.0.0.M1 and < 2.7.0.M1

106、Service Registry (TAS)

依赖说明：VMware Tanzu Application Service上的Eureka 服务发现客户端。

VMware Tanzu Application Service：是一个现代化的应用平台，适用于那些想要跨云持续交付和运行微服务的企业。

Service Registry：服务注册中心，它是服务，其实例及元数据的数据库。服务实例在启动时注册到服务注册表，并在关闭时注销。服务和路由器的客户端查询服务注册表以查找服务的可用实例。服务注册中心可能会调用服务实例的健康检查 API 来验证它是否能够处理请求。

<!--Service Registry-->
版本问题，后期补充
要求Spring Boot Version >= 2.0.0.M1 and < 2.7.0.M1

二十、Microsoft Azure

https://microsoft.github.io/spring-cloud-azure/current/reference/html/index.html

107、Azure Support

依赖说明： Azure服务（服务总线、存储、Active Directory、KeyVault等）的自动配置。

Azure：微软云计算服务，云计算的开发者能使用微软全球数据中心的储存、计算能力和网络基础服务。Azure Support是一个支持微软云计算服务的依赖，属于综合性的一个依赖。

<properties>
    <java.version>11</java.version>
    <repackage.classifier/>
    <spring-cloud-azure.version>4.2.0</spring-cloud-azure.version>
</properties>

<dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-dependencies</artifactId>
    <version>${spring-cloud-azure.version}</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

108、Azure Active Directory

依赖说明：Spring Security 与 Azure Active Directory集成以进行身份验证。

Azure Active Directory ( Azure AD ) 是一种基于 REST 的现代化服务，可提供对云应用程序的标识管理和访问控制功能。现在，您可以针对 Azure、Microsoft Office 365、Dynamics CRM Online、Windows Intune 和其他第三方云服务使用同一种标识服务。Azure Active Directory 提供云端标识提供程序，可以与本地部署 AD 轻松集成，且完全支持第三方标识提供程序。
利用 Azure AD 可以执行以下操作：与本地部署的 Azure Active Directory 集成、为应用程序提供访问控制、在企业内建立社交关系。

<dependencies>
    <dependency>
        <groupId>com.azure.spring</groupId>
        <artifactId>spring-cloud-azure-starter-active-directory</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-client</artifactId>
    </dependency>
</dependencies>

109、Azure Cosmos DB

依赖说明：用于现代应用程序开发的完全托管的NoSQL数据库服务，包括Spring Data支持。

Azure Cosmos DB是微软公司打造的一项全球分布式、横向分区、多模型数据库服务。该服务允许客户弹性（及独立形式）跨越任意数量地理服务区对吞吐量与存储进行扩展。Azure Cosmos DB可立足第99百分位比例提升99.99%高可用性水平，提供可预测吞吐量以及多套经过明确定义的一致性模型，从而保证实现低延迟表现。Azure Cosmos DB亦当前行业中第一项，同时也是惟一一项全球分布式数据库服务。其可提供全面的服务水平协议（简称SLA），其中涵盖客户最为关心的四大维度：吞吐量、第99百分位比例延迟表现、可用性以及一致性。

<dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter-cosmos</artifactId>
</dependency>

110、Azure Key Vault

依赖说明：Manage application secrets（管理应用程序的秘钥）。

Azure Key Vault是一个用来存放加密后秘钥和数据的数字库。秘钥可以通过统一资源标识符（URI）进行调用，Azure Key Vault可以用来对基于云的应用进行签名和加密。这意味着秘钥可以在不被从数字库删除的前提下进行引用。

<dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter-keyvault-secrets</artifactId>
</dependency>

111、Azure Storage

附pom.xml

<?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 https://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.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demotest</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demotest</name>
    <description>demotest</description>
    <properties>
        <java.version>11</java.version>
        <repackage.classifier/>
        <spring-cloud-azure.version>4.2.0</spring-cloud-azure.version>
        <spring-cloud.version>2021.0.3</spring-cloud.version>
        <spring-geode.version>1.7.0</spring-geode.version>
        <spring-native.version>0.12.0</spring-native.version>
        <testcontainers.version>1.17.2</testcontainers.version>
        <vaadin.version>23.0.10</vaadin.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-activemq</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-artemis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-batch</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-cassandra</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-cassandra-reactive</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-couchbase</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-couchbase-reactive</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-ldap</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb-reactive</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-neo4j</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-r2dbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-rest</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-graphql</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-groovy-templates</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-hateoas</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-integration</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jersey</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jooq</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mustache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-oauth2-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-rsocket</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web-services</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <dependency>
            <groupId>com.azure.spring</groupId>
            <artifactId>spring-cloud-azure-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.azure.spring</groupId>
            <artifactId>spring-cloud-azure-starter-active-directory</artifactId>
        </dependency>
        <dependency>
            <groupId>com.azure.spring</groupId>
            <artifactId>spring-cloud-azure-starter-data-cosmos</artifactId>
        </dependency>
        <dependency>
            <groupId>com.azure.spring</groupId>
            <artifactId>spring-cloud-azure-starter-keyvault-secrets</artifactId>
        </dependency>
        <dependency>
            <groupId>com.azure.spring</groupId>
            <artifactId>spring-cloud-azure-starter-storage-blob</artifactId>
        </dependency>
        <dependency>
            <groupId>com.vaadin</groupId>
            <artifactId>vaadin-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>info.picocli</groupId>
            <artifactId>picocli-spring-boot-starter</artifactId>
            <version>4.6.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-streams</artifactId>
        </dependency>
        <dependency>
            <groupId>org.flywaydb</groupId>
            <artifactId>flyway-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.liquibase</groupId>
            <artifactId>liquibase-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-bus</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-cloudfoundry-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-function-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-sleuth-zipkin</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-circuitbreaker-reactor-resilience4j</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-consul-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-consul-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-task</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-vault-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zookeeper-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream-binder-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream-binder-kafka-streams</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream-binder-rabbit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-rest-hal-explorer</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.experimental</groupId>
            <artifactId>spring-native</artifactId>
            <version>${spring-native.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.geode</groupId>
            <artifactId>spring-geode-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-gemfire</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-jms</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-mail</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-r2dbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-rsocket</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-stomp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-websocket</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-ws</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-messaging</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-rsocket</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.session</groupId>
            <artifactId>spring-session-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.session</groupId>
            <artifactId>spring-session-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.thymeleaf.extras</groupId>
            <artifactId>thymeleaf-extras-springsecurity5</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.ibm.db2</groupId>
            <artifactId>jcc</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.microsoft.sqlserver</groupId>
            <artifactId>mssql-jdbc</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.oracle.database.jdbc</groupId>
            <artifactId>ojdbc8</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-datadog</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-graphite</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-influx</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-new-relic</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-prometheus</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.r2dbc</groupId>
            <artifactId>r2dbc-h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.r2dbc</groupId>
            <artifactId>r2dbc-mssql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.derby</groupId>
            <artifactId>derby</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.hsqldb</groupId>
            <artifactId>hsqldb</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.mariadb</groupId>
            <artifactId>r2dbc-mariadb</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.mariadb.jdbc</groupId>
            <artifactId>mariadb-java-client</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>r2dbc-postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.unboundid</groupId>
            <artifactId>unboundid-ldapsdk</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>de.flapdoodle.embed</groupId>
            <artifactId>de.flapdoodle.embed.mongo</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.rest-assured</groupId>
            <artifactId>spring-web-test-client</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.batch</groupId>
            <artifactId>spring-batch-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-contract-stub-runner</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-contract-verifier</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream</artifactId>
            <scope>test</scope>
            <classifier>test-binder</classifier>
            <type>test-jar</type>
        </dependency>
        <dependency>
            <groupId>org.springframework.graphql</groupId>
            <artifactId>spring-graphql-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.restdocs</groupId>
            <artifactId>spring-restdocs-webtestclient</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>cassandra</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>couchbase</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>db2</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>elasticsearch</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>kafka</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>mariadb</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>mongodb</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>mssqlserver</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>mysql</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>neo4j</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>oracle-xe</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>postgresql</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>r2dbc</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>rabbitmq</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.geode</groupId>
                <artifactId>spring-geode-bom</artifactId>
                <version>${spring-geode.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.azure.spring</groupId>
                <artifactId>spring-cloud-azure-dependencies</artifactId>
                <version>${spring-cloud-azure.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.vaadin</groupId>
                <artifactId>vaadin-bom</artifactId>
                <version>${vaadin.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.testcontainers</groupId>
                <artifactId>testcontainers-bom</artifactId>
                <version>${testcontainers.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-contract-maven-plugin</artifactId>
                <version>3.1.3</version>
                <extensions>true</extensions>
                <configuration>
                    <testFramework>JUNIT5</testFramework>
                    <testMode>WEBTESTCLIENT</testMode>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.asciidoctor</groupId>
                <artifactId>asciidoctor-maven-plugin</artifactId>
                <version>1.5.8</version>
                <executions>
                    <execution>
                        <id>generate-docs</id>
                        <phase>prepare-package</phase>
                        <goals>
                            <goal>process-asciidoc</goal>
                        </goals>
                        <configuration>
                            <backend>html</backend>
                            <doctype>book</doctype>
                        </configuration>
                    </execution>
                </executions>
                <dependencies>
                    <dependency>
                        <groupId>org.springframework.restdocs</groupId>
                        <artifactId>spring-restdocs-asciidoctor</artifactId>
                        <version>${spring-restdocs.version}</version>
                    </dependency>
                </dependencies>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                    <classifier>${repackage.classifier}</classifier>
                    <image>
                        <builder>paketobuildpacks/builder:tiny</builder>
                        <env>
                            <BP_NATIVE_IMAGE>true</BP_NATIVE_IMAGE>
                        </env>
                    </image>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.experimental</groupId>
                <artifactId>spring-aot-maven-plugin</artifactId>
                <version>${spring-native.version}</version>
                <executions>
                    <execution>
                        <id>test-generate</id>
                        <goals>
                            <goal>test-generate</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>generate</id>
                        <goals>
                            <goal>generate</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.hibernate.orm.tooling</groupId>
                <artifactId>hibernate-enhance-maven-plugin</artifactId>
                <version>${hibernate.version}</version>
                <executions>
                    <execution>
                        <id>enhance</id>
                        <goals>
                            <goal>enhance</goal>
                        </goals>
                        <configuration>
                            <failOnError>true</failOnError>
                            <enableLazyInitialization>true</enableLazyInitialization>
                            <enableDirtyTracking>true</enableDirtyTracking>
                            <enableAssociationManagement>true</enableAssociationManagement>
                            <enableExtendedEnhancement>false</enableExtendedEnhancement>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>spring-releases</id>
            <name>Spring Releases</name>
            <url>https://repo.spring.io/release</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-releases</id>
            <name>Spring Releases</name>
            <url>https://repo.spring.io/release</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>

    <profiles>
        <profile>
            <id>production</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>com.vaadin</groupId>
                        <artifactId>vaadin-maven-plugin</artifactId>
                        <version>${vaadin.version}</version>
                        <executions>
                            <execution>
                                <id>frontend</id>
                                <phase>compile</phase>
                                <goals>
                                    <goal>prepare-frontend</goal>
                                    <goal>build-frontend</goal>
                                </goals>
                                <configuration>
                                    <productionMode>true</productionMode>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
        <profile>
            <id>native</id>
            <properties>
                <repackage.classifier>exec</repackage.classifier>
                <native-buildtools.version>0.9.11</native-buildtools.version>
            </properties>
            <dependencies>
                <dependency>
                    <groupId>org.junit.platform</groupId>
                    <artifactId>junit-platform-launcher</artifactId>
                    <scope>test</scope>
                </dependency>
            </dependencies>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.graalvm.buildtools</groupId>
                        <artifactId>native-maven-plugin</artifactId>
                        <version>${native-buildtools.version}</version>
                        <extensions>true</extensions>
                        <executions>
                            <execution>
                                <id>test-native</id>
                                <phase>test</phase>
                                <goals>
                                    <goal>test</goal>
                                </goals>
                            </execution>
                            <execution>
                                <id>build-native</id>
                                <phase>package</phase>
                                <goals>
                                    <goal>build</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>

</project>

2022 年 6 月
一	二	三	四	五	六	日
	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