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 向 账户服务微服务发出请求。我们还需要添加一个发现服务——以便其他进程可以相互查找。

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

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

了解更多

  • 报名参加 SpringOne Platform 2019 – 使用 Spring 构建可扩展微服务应用程序的顶级会议。今年我们将于 10 月 7 日至 10 日在德克萨斯州奥斯汀举行。使用折扣码 S1P_Save200 节省您的门票费用。需要帮助说服您的经理吗？请使用此页面。
  • 获取 Matt Stine 撰写的免费电子书 《迁移到云原生应用程序架构》
  • 此网络研讨会讨论了可帮助您将单体应用程序重新平台化到现代云环境的工具和方案。
## 更新（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。 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 仪表板：https://:1111，并且显示“应用程序”的部分将为空。

从现在开始，我们将称其为发现服务，因为它可能是 Eureka 或 Consul（请参阅侧面板）。

创建微服务：账户服务

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

Beans vs Processes

在使用 Spring 配置应用程序时，我们强调松散耦合和紧密内聚。这些并不是新概念（Larry Constantine 因在 1960 年代后期首次定义这些概念而受到赞誉——参考），但现在我们将其应用于交互进程，而不是交互组件（Spring Bean）。

在此示例中，我有一个简单的账户管理微服务，它使用 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: https://:1111/eureka/

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

请注意此文件

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

Eureka Dashboard

现在运行 AccountsService 应用程序，让它完成初始化。刷新仪表板 https://:1111，您应该会在应用程序下方看到 ACCOUNTS-SERVICE。注册最多需要 30 秒（默认），所以请耐心等待——检查 RegistrationService 的日志输出

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

要了解更多详细信息，请访问：https://: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>

或者，前往 https://: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 发布列车下，客户端用于向发现服务器注册的实例 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 服务

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

注意：账户微服务通过 HTTP 提供 RESTful 接口，但可以使用任何合适的协议。AMQP 或 JMS 的消息传递是一个明显的替代方案（在这种情况下，不再需要发现服务器——相反，进程需要知道要与之通信的队列名称，可以考虑使用 Spring Cloud 配置服务器来完成此操作）。

可以使用哪些格式取决于类路径中是否存在编组类——例如，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 的服务 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: https://: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。

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

    <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 Boot 应用程序，使用 Spring Data。注解完成了大部分工作

  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 将为我创建这个工厂 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 社区所有即将举行的活动。

查看所有