使用 Spring 构建微服务

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

简介

注意： 2019年7月修订

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

微服务允许大型系统由许多协作组件构成。它在流程级别做了 Spring 一直在组件级别做的事情：松散耦合的流程而不是松散耦合的组件。

例如，想象一个在线商店，它拥有用于用户帐户、产品目录、订单处理和购物车的单独微服务。

不可避免地，您需要设置和配置许多活动部件才能构建这样的系统。如何使它们协同工作并不明显——您需要非常熟悉 Spring Boot，因为 Spring Cloud 非常依赖它，需要几个 Netflix 或其他开源项目，当然，还有一些 Spring 配置“魔法”！

在这篇文章中，我旨在通过逐步构建尽可能简单的系统来阐明事物的工作方式。因此，我只会实现大型系统的一小部分——用户帐户服务。

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

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

其工作原理的描述故意详细。性急的读者可能更愿意只查看代码。请注意，它在一个项目中包含三个微服务。

了解更多

注册参加SpringOne Platform 2019——使用 Spring 构建可扩展微服务应用程序的顶级会议。今年我们在德克萨斯州奥斯汀市，时间为 10 月 7 日至 10 日。使用折扣码S1P_Save200节省门票费用。需要帮助说服您的经理吗？请使用此页面。
获取 Matt Stine 编写的免费电子书迁移到云原生架构
此网络研讨会讨论了帮助您将整体式应用程序重新平台化为现代云环境的工具和方法。

## 更新（2018年6月）

自从我最初撰写这篇博客以来，已经进行了一些更改。

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

使用 Spring Boot 1.5.10 和 Spring Cloud Edgeware SR3 的先前版本可作为 git tag 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://127.0.0.1:1111，显示应用程序的部分将为空。

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

创建微服务：帐户服务

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

使用 Spring 配置应用程序时，我们强调松散耦合和紧密内聚。这些并非新概念（Larry Constantine 被认为在 20 世纪 60 年代后期首次定义了这些概念——参考），但现在我们正在应用它们，不是应用于交互组件（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);
    }
}

注释完成了工作。

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

使之成为微服务的原因是通过@EnableDiscoveryClient向发现服务器注册，并且其 YML 配置完成了设置。

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

# Discovery Server Access
eureka:
  client:
    serviceUrl:
      defaultZone: https://127.0.0.1:1111/eureka/

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

请注意，此文件

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

现在运行AccountsService应用程序并使其完成初始化。刷新仪表板https://127.0.0.1:1111，您应该在“应用程序”下看到 ACCOUNTS-SERVICE 列表。注册最多需要 30 秒（默认情况下），请耐心等待 - 检查RegistrationService的日志输出。

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

更多详情，请访问：https://127.0.0.1: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://127.0.0.1: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。请注意，只有在使用 Cloud Foundry 时才设置spring.application.instance_id，但它方便地为同一应用程序的每个实例提供了一个唯一的 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
    }
}

几点需要注意

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

负载均衡RestTemplate

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

注意：从Brixton发布列车（Spring Cloud 1.1.0.RELEASE）开始，不再自动创建 RestTemplate。最初它是为您创建的，这导致了混乱和潜在的冲突（有时 Spring 可能太有帮助了！）。

请注意，此实例使用@LoadBalanced进行限定。（注解本身使用@Qualifier进行注解 - 详情请参见此处）。因此，如果您有多个 RestTemplate bean，您可以确保注入正确的 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中的相关配置。它用于：

设置应用程序名称
定义访问发现服务器的 URL
将 Tomcat 端口设置为 3333

# Spring Properties
spring:
  application:
     name: web-service

# Discovery Server Access
eureka:
  client:
    serviceUrl:
      defaultZone: https://127.0.0.1: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中可以看到设置start-class的Spring Boot选项。

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

@SpringBootApplication - 将其定义为Spring Boot应用程序。此便捷的注解组合了@EnableAutoConfiguration、@Configuration和@ComponentScan（默认情况下，它会导致Spring搜索包含此类及其子包的包中的组件 - 潜在的Spring Bean：AccountController和AccountRepository）。
@EntityScan("io.pivotal.microservices.accounts") - 因为我使用JPA，所以我需要指定@Entity类的位置。通常，这是在JPA的persistence.xml中或创建LocalContainerEntityManagerFactoryBean时指定的选项。Spring Boot将为我创建此factory-bean，因为spring-boot-starter-data-jpa依赖项位于类路径中。因此，指定查找@Entity类的另一种方法是使用@EntityScan。这将找到Account。
@EnableJpaRepositories("io.pivotal.microservices.accounts") - 查找扩展Spring Data的Repository标记接口的类，并使用JPA自动实现它们 - 请参见Spring Data JPA。
@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 博客