Spring 博客

所有帖子
工程
发布
新闻与活动

使用 Spring 构建微服务

工程 | Paul Chapman | 2015 年 7 月 14 日 | ...

引言

注意： 于 2019 年 7 月修订

一个使用 Spring、Spring Boot 和 Spring Cloud 构建微服务系统的简单示例。

微服务允许大型系统由许多协作组件构建而成。它在进程级别实现了 Spring 在组件级别一直以来所做的事情：松散耦合的进程代替了松散耦合的组件。

Shopping Application

例如，设想一个在线商店，其中包含独立的用户账户、产品目录、订单处理和购物车微服务。

构建这样的系统不可避免地需要设置和配置许多活动部件。如何让它们协同工作并非显而易见——你需要非常熟悉 Spring Boot，因为 Spring Cloud 大量使用了它，还需要一些 Netflix 或其他开源项目，当然，还有一些 Spring 配置的“魔力”！

Demo Application

在本文中，我旨在通过逐步构建最简单的系统来阐明其工作原理。因此，我将只实现大型系统的一小部分——用户账户服务。

Web 应用将使用 RESTful API 向 Account-Service 微服务发出请求。我们还需要添加一个发现服务——以便其他进程可以相互查找。

此应用程序的代码在这里：https://github.com/paulc4/microservices-demo。

本文故意详细描述了其工作原理。不耐烦的读者可能更喜欢直接查看代码。请注意，它在一个项目中包含了三个微服务。

了解更多

## 更新 (2018 年 6 月)

自我最初撰写此博客以来的一些更改

  1. 关于在同一主机上使用同一服务的多个实例的讨论。演示应用程序已更新以匹配。
  2. 关于 @LoadBalanced 的讨论 - 自 Brixton 发布列 (Spring Cloud 1.1.0.RELEASE) 以来，其工作方式已发生变化。
  3. 将账户微服务的配置重构到其自己的类 AccountsConfiguration 中。
  4. 升级到 Spring Boot 2，因此一些 Boot 类的包已更改。
  5. 将演示应用程序升级到 Spring Cloud Finchley 发布列（包括末尾评论中的各种修复 - 感谢反馈）。
  6. Eureka 服务器依赖项已更改为 spring-cloud-starter-netflix-eureka-server。

使用 Spring Boot 1.5.10 和 Spring Cloud Edgeware SR3 的旧版本可作为 git 标签 v1.2.0 获取。

 

好了，我们开始吧...

服务注册

当多个进程协同工作时，它们需要相互查找。如果您曾使用过 Java 的 RMI 机制，您可能会记得它依赖于一个中心注册表，以便 RMI 进程可以相互查找。微服务也有同样的需求。

Netflix 的开发人员在构建他们的系统时遇到了这个问题，并创建了一个名为 Eureka（希腊语意为“我找到了”）的注册服务器。幸运的是，他们将其发现服务器开源，Spring 也将其集成到 Spring Cloud 中，使得运行 Eureka 服务器更加容易。下面是这个完整的发现服务器应用程序

@SpringBootApplication
@EnableEurekaServer
public class ServiceRegistrationServer {

  public static void main(String[] args) {
    // Tell Boot to look for registration-server.yml
    System.setProperty("spring.config.name", "registration-server");
    SpringApplication.run(ServiceRegistrationServer.class, args);
  }
}

就是这么简单！

Spring Cloud 构建在 Spring Boot 之上，并利用了父 POM 和 Starter POM。POM 中的重要部分是

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
    </parent>

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

        <dependency>
            <!-- Setup Spring MVC & REST, use Embedded Tomcat -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

        <dependency>
            <!-- Eureka for service registration -->
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
        </dependency>
    </dependencies>

   <!-- Spring Cloud dependencies -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

此 POM 自我最初撰写本文以来已更改为使用 Spring Boot 作为其父级，而非 Spring Cloud。Spring Cloud 依赖项通过依赖管理部分提供。

github 代码中还包含一个示例 gradle 构建文件。

注意： Finchley.RELEASE 是当前的“发布列”——一组协调一致的版本 -- 参见 Spring Cloud 主页上的说明。

默认情况下，Spring Boot 应用程序会查找 application.properties 或 application.yml 文件进行配置。通过设置 spring.config.name 属性，我们可以告诉 Spring Boot 查找不同的文件——当您在同一个项目中有多个 Spring Boot 应用程序时这很有用——我很快就会这样做。

此应用程序查找 registration-server.properties 或 registration-server.yml。以下是 registration-server.yml 中的相关配置

# Configure this Discovery Server
eureka:
  instance:
    hostname: localhost
  client:  # Not a client, don't register with yourself (unless running
           # multiple discovery servers for redundancy)
    registerWithEureka: false
    fetchRegistry: false

server:
  port: 1111   # HTTP (Tomcat) port

默认情况下，Eureka 运行在端口 8761 上，但这里我们将使用端口 1111 代替。此外，通过在我的进程中包含注册代码，我可能是一个服务器或一个客户端。配置指定我不是客户端，并阻止服务器进程尝试向自身注册。

使用 Consul

Spring Cloud 还支持将 Consul 作为 Eureka 的替代方案。您可以使用脚本启动 Consul Agent（其注册服务器），然后客户端使用它来查找其微服务。有关详细信息，请参见这篇博客文章或项目主页。

现在尝试运行 RegistrationServer（有关运行应用程序的帮助，请参见下文）。您可以在此处打开 Eureka 控制面板：http://localhost:1111，显示应用程序的部分将是空的。

从现在开始，我们将称之为发现服务器，因为它可能是 Eureka 或 Consul（参见侧边栏）。

创建一个微服务：Account-Service

微服务是一个独立的进程，用于处理明确定义的需求。

Beans vs Processes

在使用 Spring 配置应用程序时，我们强调松散耦合和紧密内聚。这些并非新概念（Larry Constantine 在 20 世纪 60 年代末首次定义了这些概念 - 参考），但现在我们将它们应用于交互进程，而非交互组件 (Spring Beans)。

在这个示例中，我有一个简单的账户管理微服务，它使用 Spring Data 实现 JPA AccountRepository，并使用 Spring REST 提供账户信息的 RESTful 接口。从大多数方面来看，这是一个直截了当的 Spring Boot 应用程序。

其特别之处在于它在启动时会向发现服务器注册自己。以下是 Spring Boot 的启动类

@EnableAutoConfiguration
@EnableDiscoveryClient
@Import(AccountsWebApplication.class)
public class AccountsServer {

    @Autowired
    AccountRepository accountRepository;

    public static void main(String[] args) {
        // Will configure using accounts-server.yml
        System.setProperty("spring.config.name", "accounts-server");

        SpringApplication.run(AccountsServer.class, args);
    }
}

注解完成了工作

  1. @EnableAutoConfiguration - 将其定义为一个 Spring Boot 应用程序。
  2. @EnableDiscoveryClient - 这启用了服务注册和发现。在这种情况下，此进程使用其应用程序名称（见下文）向发现服务器服务注册自己。
  3. @Import(AccountsWebApplication.class) - 这个 Java 配置类设置了其他所有内容（有关更多详细信息，请参见下文）。

使其成为微服务的是通过 @EnableDiscoveryClient 向发现服务器进行的注册，其 YML 配置完成了设置

# Spring properties
spring:
  application:
     name: accounts-service

# Discovery Server Access
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1111/eureka/

# HTTP Server
server:
  port: 2222   # HTTP (Tomcat) port

请注意，此文件

  1. 将应用程序名称设置为 accounts-service。此服务以该名称注册，也可以通过该名称访问——见下文。
  2. 指定一个自定义端口进行监听 (2222)。我的所有进程都使用 Tomcat，它们不能都监听 8080 端口。
  3. Eureka 服务进程的 URL - 来自上一节。

Eureka Dashboard

现在运行 AccountsService 应用程序并等待其初始化完成。刷新控制面板 http://localhost:1111，您应该在 Applications 下看到 ACCOUNTS-SERVICE。注册最多需要 30 秒（默认），请耐心等待——查看 RegistrationService 的日志输出。

警告：请勿尝试使用 Eclipse/STS 的内部网页查看器显示 XML 输出，因为它无法做到。请改用您喜欢的网页浏览器。

有关更多详细信息，请访问此处：http://localhost:1111/eureka/apps/，您应该看到类似以下内容

<applications>
    <versions__delta>1</versions__delta>
    <apps__hashcode>UP_1_</apps__hashcode>
    <application>
        <name>ACCOUNTS-SERVICE</name>
        <instance>
            <hostName>autgchapmp1m1.corp.emc.com</hostName>
            <app>ACCOUNTS-SERVICE</app>
            <ipAddr>172.16.84.1</ipAddr><status>UP</status>
            <overriddenstatus>UNKNOWN</overriddenstatus>
            <port enabled="true">3344</port>
            <securePort enabled="false">443</securePort>
            ...
        </instance>
    </application>
</applications>

或者访问 http://localhost:1111/eureka/apps/ACCOUNTS-SERVICE，只查看 AccountsService 的详细信息 - 如果未注册，您将收到 404 错误。

配置选项

注册时间：注册最多需要 30 秒，因为这是默认的客户端刷新时间。您可以通过将 eureka.instance.leaseRenewalIntervalInSeconds 属性设置为更小的值来更改此设置（在演示应用程序中我将其设置为 5）。在生产环境中不建议这样做。另请参见此处。

eureka:
  instance:
    leaseRenewalIntervalInSeconds: 5         # DO NOT DO THIS IN PRODUCTION

注册 ID：一个进程（微服务）使用唯一的 ID 向发现服务注册。如果另一个进程使用相同的 ID 注册，则将其视为重新启动（例如某种故障转移或恢复），并且第一个进程的注册将被丢弃。这为我们提供了所需的容错系统。

要运行同一进程的多个实例（用于负载均衡和弹性），它们需要使用唯一的 ID 进行注册。当我第一次撰写这篇博客时，这是自动的，自从 Brixton 发布列以来，它又恢复了自动注册。

在 Angel 发布列下，客户端用于向发现服务器注册的 instance-id 源自客户端的服务名称（与 Spring 应用程序名称相同）以及客户端的主机名。因此，在同一主机上运行的同一进程会具有相同的 ID，所以只能注册一个实例。

幸运的是，您可以通过客户端的 Eureka 元数据映射手动设置 id 属性，如下所示

eureka:
  instance:
    metadataMap:
      instanceId: ${spring.application.name}:${spring.application.instance_id:${server.port}}

自从 Brixton 发布列以来，这现在是默认设置。那么它有什么作用呢？

我们将 instanceId 设置为 application-name:instance_id，但如果 instance_id 未定义，我们将使用 application-name::server-port 代替。请注意，spring.application.instance_id 仅在使用 Cloud Foundry 时设置，但它方便地为同一应用程序的每个实例提供一个唯一的 ID 号。在其他地方运行时，我们可以使用服务器端口做类似的事情（因为同一机器上的不同实例必须监听不同的端口）。您经常看到的另一个示例是 ${spring.application.name}:${spring.application.instance_id:${random.value}}，但我个人认为使用端口号更容易识别每个实例 - 随机值只是没有意义的长字符串。

注意：语法 ${x:${y}} 是 Spring 属性的简写形式，表示 ${x} != null ? ${x} : ${y}。

自 Brixton 版本发布以来，还有一个专门为此目的的属性

eureka:
  instance:
    instanceId: ${spring.application.name}:${spring.application.instance_id:${random.value}}

访问微服务：Web-Service

要消费 RESTful 服务，Spring 提供了 RestTemplate 类。它允许您向 RESTful 服务器发送 HTTP 请求，并以多种格式（例如 JSON 和 XML）获取数据。

注意：账户微服务通过 HTTP 提供 RESTful 接口，但可以使用任何合适的协议。使用AMQP或 JMS 进行消息传递是一个显而易见的替代方案（在这种情况下，不再需要发现服务器 - 而是进程需要知道要通信的队列名称，可以考虑使用Spring Cloud Configuration Server来管理）。

可以使用哪种格式取决于类路径中是否存在编组类——例如，JAXB 总是会被检测到，因为它是 Java 的标准部分。如果类路径中存在 Jackson 的 jar 包，则支持 JSON。

微服务（发现）客户端可以使用 RestTemplate，Spring 会自动将其配置为具备微服务感知能力（稍后会详细介绍）。

封装微服务访问

以下是我的客户端应用程序的 WebAccountService 的一部分

@Service
public class WebAccountsService {

    @Autowired        // NO LONGER auto-created by Spring Cloud (see below)
    @LoadBalanced     // Explicitly request the load-balanced template
                      // with Ribbon built-in
    protected RestTemplate restTemplate; 

    protected String serviceUrl;

    public WebAccountsService(String serviceUrl) {
        this.serviceUrl = serviceUrl.startsWith("http") ?
               serviceUrl : "http://" + serviceUrl;
    }

    public Account getByNumber(String accountNumber) {
        Account account = restTemplate.getForObject(serviceUrl
                + "/accounts/{number}", Account.class, accountNumber);

        if (account == null)
            throw new AccountNotFoundException(accountNumber);
        else
            return account;
    }
    ...
}

请注意，我的 WebAccountService 只是一个 RestTemplate 的包装器，用于从微服务中获取数据。有趣的部分是 serviceUrl 和 RestTemplate。

访问微服务

如下所示，serviceUrl 由主程序提供给 WebAccountController（后者又将其传递给 WebAccountService）

@SpringBootApplication
@EnableDiscoveryClient
@ComponentScan(useDefaultFilters=false)  // Disable component scanner
public class WebServer {

    // Case insensitive: could also use: http://accounts-service
    public static final String ACCOUNTS_SERVICE_URL
                                        = "http://ACCOUNTS-SERVICE";

    public static void main(String[] args) {
        // Will configure using web-server.yml
        System.setProperty("spring.config.name", "web-server");
        SpringApplication.run(WebServer.class, args);
    }

    @LoadBalanced    // Make sure to create the load-balanced template
    @Bean
    RestTemplate restTemplate() {
        return new RestTemplate();
    }

    /**
     * Account service calls microservice internally using provided URL.
     */
    @Bean
    public WebAccountsService accountsService() {
        return new WebAccountsService(ACCOUNTS_SERVICE_URL);
    }

    @Bean
    public WebAccountsController accountsController() {
         return new WebAccountsController
                       (accountsService());  // plug in account-service
    }
}

需要注意的几点

  1. WebController 是一个典型的基于视图的 Spring MVC 控制器，返回 HTML。该应用程序使用 Thymeleaf 作为视图技术（用于生成动态 HTML）
  2. WebServer 也是一个 @EnableDiscoveryClient，但在这种情况下，除了向发现服务器注册自己（这不是必需的，因为它不提供自己的服务）之外，它还使用 Eureka 来定位账户服务。
  3. 从 Spring Boot 继承的默认组件扫描器设置会查找 @Component 类，并在此示例中找到我的 WebAccountController 并尝试创建它。然而，我想自己创建它，所以我通过 @ComponentScan(useDefaultFilters=false) 禁用了扫描器。
  4. 我传递给 WebAccountController 的 service-url 是该服务用于向发现服务器注册自己的名称——默认情况下，这与进程的 spring.application.name 相同，即 account-service——参见上面的 account-service.yml。使用大写字母不是必需的，但这有助于强调 ACCOUNTS-SERVICE 是一个逻辑主机（将通过发现获得），而不是实际主机。

负载均衡的 RestTemplate

RestTemplate bean 将被 Spring Cloud 拦截并自动配置（由于 @LoadBalanced 注解），以使用一个自定义的 HttpRequestClient，该客户端使用 Netflix Ribbon 进行微服务查找。Ribbon 也是一个负载均衡器，因此如果一个服务有多个可用实例，它会为您选择一个。（Eureka 和 Consul 本身都不执行负载均衡，所以我们使用 Ribbon 来完成）。

注意：从 Brixton 发布列 (Spring Cloud 1.1.0.RELEASE) 开始，RestTemplate 不再自动创建。最初它是为您创建的，这导致了混淆和潜在的冲突（有时 Spring 会过于乐于助人！）。

请注意，此实例使用 @LoadBalanced 进行了限定。（该注解本身被 @Qualifier 注解 - 有关详细信息，请参见此处）。因此，如果您有多个 RestTemplate bean，可以确保注入正确的那个，如下所示

    @Autowired
    @LoadBalanced     // Make sure to inject the load-balanced template
    protected RestTemplate restTemplate;

如果您查看 RibbonClientHttpRequestFactory，您将看到以下代码

    String serviceId = originalUri.getHost();
    ServiceInstance instance =
             loadBalancer.choose(serviceId);  // loadBalancer uses Ribbon
    ... if instance non-null (service exists) ...
    URI uri = loadBalancer.reconstructURI(instance, originalUri);

loadBalancer 接收逻辑服务名称（已向发现服务器注册）并将其转换为所选微服务的实际主机名。

RestTemplate 实例是线程安全的，可用于访问应用程序不同部分的任意数量的服务（例如，我可能有一个 CustomerService 包装同一个 RestTemplate 实例，访问客户数据微服务）。

配置

下面是来自 web-server.yml 的相关配置。它用于

  1. 设置应用程序名称
  2. 定义访问发现服务器的 URL
  3. 将 Tomcat 端口设置为 3333
# Spring Properties
spring:
  application:
     name: web-service

# Discovery Server Access
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1111/eureka/

# HTTP Server
server:
  port: 3333   # HTTP (Tomcat) port
# 如何运行演示

此系统的小型演示位于 http://github.com/paulc4/microservices-demo。克隆它并加载到您喜欢的 IDE 中，或直接使用 maven。关于如何运行演示的建议包含在项目主页的 README 中。

额外说明

关于这些应用程序使用 Spring Boot 的一些说明。如果您不熟悉 Spring Boot，这解释了一些“魔力”！

视图模板引擎

Eureka 控制面板（在 RegistrationServer 内部）使用 FreeMarker 模板实现，而另外两个应用程序使用 Thymeleaf。为了确保每个应用程序使用正确的视图引擎，每个 YML 文件中都有额外的配置。

这在 registration-server.yml 的末尾，用于禁用 Thymeleaf。

...
# Discovery Server Dashboard uses FreeMarker.  Don't want Thymeleaf templates
spring:
  thymeleaf:
    enabled: false     # Disable Thymeleaf spring:

由于 AccountService 和 WebService 都使用 thymeleaf，我们还需要将每个应用程序指向其自己的模板。以下是 account-server.yml 的一部分

# Spring properties
spring:
  application:
     name: accounts-service  # Service registers under this name
  freemarker:
    enabled: false      # Ignore Eureka dashboard FreeMarker templates
  thymeleaf:
    cache: false        # Allow Thymeleaf templates to be reloaded at runtime
    prefix: classpath:/accounts-server/templates/
                        # Template location for this application only
...

web-server.yml 类似，但其模板由以下内容定义

   prefix: classpath:/web-server/templates/

请注意每个 spring.thymeleaf.prefix 类路径末尾的 / - 这是关键。

命令行执行

编译后的 jar 包在命令行调用时会自动运行 io.pivotal.microservices.services.Main - 参见 Main.java。

在 POM 中可以看到 Spring Boot 设置 start-class 的选项

    <properties>
        <!-- Stand-alone RESTFul application for testing only -->
        <start-class>io.pivotal.microservices.services.Main</start-class>
    </properties>

AccountsConfiguration 类

@SpringBootApplication
@EntityScan("io.pivotal.microservices.accounts")
@EnableJpaRepositories("io.pivotal.microservices.accounts")
@PropertySource("classpath:db-config.properties")
public class AccountsWebApplication {
...
}

这是 AccountService 的主要配置类，它是一个使用 Spring Data 的经典 Spring Boot 应用程序。注解完成了大部分工作

  1. @SpringBootApplication - 将其定义为一个 Spring Boot 应用程序。这个便捷注解结合了 @EnableAutoConfiguration、@Configuration 和 @ComponentScan（后者默认会使 Spring 扫描包含此类的包及其子包，查找组件——潜在的 Spring Bean：AccountController 和 AccountRepository）。
  2. @EntityScan("io.pivotal.microservices.accounts") - 因为我使用 JPA，我需要指定 @Entity 类在哪里。通常这是您在 JPA 的 persistence.xml 或创建 LocalContainerEntityManagerFactoryBean 时指定的选项。Spring Boot 会为我创建这个 factory-bean，因为 spring-boot-starter-data-jpa 依赖项在类路径上。所以指定查找 @Entity 类的另一种方法是使用 @EntityScan。它将找到 Account。
  3. @EnableJpaRepositories("io.pivotal.microservices.accounts") - 查找扩展 Spring Data 的 Repository 标记接口的类，并使用 JPA 自动实现它们——参见Spring Data JPA。
  4. @PropertySource("classpath:db-config.properties") - 用于配置我的 DataSource 的属性——参见 db-config.properties。

配置属性

如上所述，Spring Boot 应用程序会查找 application.properties 或 application.yml 来配置自身。由于此应用程序中使用的所有三个服务器都在同一个项目中，它们会自动使用相同的配置。

为避免这种情况，每个应用程序都通过设置 spring.config.name 属性来指定一个替代文件。

例如，以下是 WebServer.java 的一部分。

public static void main(String[] args) {
  // Tell server to look for web-server.properties or web-server.yml
  System.setProperty("spring.config.name", "web-server");
  SpringApplication.run(WebServer.class, args);
}

运行时，应用程序将在 src/main/resources 中找到并使用 web-server.yml。

日志记录

Spring Boot 默认将 Spring 的日志级别设置为 INFO。由于我们需要检查日志以确认微服务是否正常工作，我已将级别提高到 WARN 以减少日志量。

为此，需要在每个 xxxx-server.yml 配置文件中指定日志级别。这通常是定义它们的最佳位置，因为日志属性不能在属性文件中指定（日志在处理 @PropertySource 指令之前就已经初始化了）。在 Spring Boot 手册中有一个关于这方面的说明，但很容易忽略。

我没有在每个 YAML 文件中重复日志配置，而是选择将其放在 logback 配置文件中，因为 Spring Boot 使用 logback - 请参阅 src/main/resources/logback.xml。所有三个服务将共享同一个 logback.xml。

获取 Spring 新闻通讯

订阅 Spring 新闻通讯，保持联系

订阅

取得领先

VMware 提供培训和认证，助您加速前进。

了解更多

获取支持

Tanzu Spring 通过一个简单的订阅即可为 OpenJDK™、Spring 和 Apache Tomcat® 提供支持和二进制文件。

了解更多

即将举行的活动

查看 Spring 社区所有即将举行的活动。

查看全部