三、Eureka服务中心详解

一、Eureka服务治理体系

1.1 服务治理

服务治理是微服务架构中最为核心和基础的模块，它主要用来实现各个微服务实例的自动化注册和发现。
Spring Cloud Eureka是Spring Cloud Netflix微服务套件中的一部分，它基于Netflix Eureka做了二次封装。主要负责完成微服务架构中的服务治理功能。

1.2 服务注册

在服务治理框架中，通常都会构建一个注册中心，每个服务单元向注册中心登记自己提供的服务，包括服务的主机与端口号、服务版本号、通讯协议等一些附加信息。注册中心按照服务名分类组织服务清单，同时还需要以心跳检测的方式去监测清单中的服务是否可用，若不可用需要从服务清单中剔除，以达到排除故障服务的效果。

1.3 服务发现

在服务治理框架下，服务间的调用不再通过指定具体的实例地址来实现，而是通过服务名发起请求调用实现。服务调用方通过服务名从服务注册中心的服务清单中获取服务实例的列表清单，通过指定的负载均衡策略取出一个服务实例位置来进行服务调用。

二、Netflix Eureka

2.1 Netflix Eureka介绍

Spirng Cloud Eureka使用Netflix Eureka来实现服务注册与发现。它既包含了服务端组件，也包含了客户端组件，并且服务端与客户端均采用java编写，所以Eureka主要适用于通过java实现的分布式系统，或是JVM兼容语言构建的系统。Eureka的服务端提供了较为完善的REST API，所以Eureka也支持将非java语言实现的服务纳入到Eureka服务治理体系中来，只需要其他语言平台自己实现Eureka的客户端程序。目前.Net平台的Steeltoe、Node.js的eureka-js-client等都已经实现了各自平台的Ereka客户端组件。

2.2 Eureka服务端

Eureka服务端，即服务注册中心。它同其他服务注册中心一样，支持高可用配置。依托于强一致性提供良好的服务实例可用性，可以应对多种不同的故障场景。
Eureka服务端支持集群模式部署，当集群中有分片发生故障的时候，Eureka会自动转入自我保护模式。它允许在分片发生故障的时候继续提供服务的发现和注册，当故障分配恢复时，集群中的其他分片会把他们的状态再次同步回来。集群中的的不同服务注册中心通过异步模式互相复制各自的状态，这也意味着在给定的时间点每个实例关于所有服务的状态可能存在不一致的现象。

2.3 Eureka客户端

Eureka客户端，主要处理服务的注册和发现。客户端服务通过注册和参数配置的方式，嵌入在客户端应用程序的代码中。在应用程序启动时，Eureka客户端向服务注册中心注册自身提供的服务，并周期性的发送心跳来更新它的服务租约。同时，他也能从服务端查询当前注册的服务信息并把它们缓存到本地并周期行的刷新服务状态。

2.4 服务消费过程

服务治理-服务注册、发现和消费

• Register Service:服务注册中心，它是一个 Eureka Server，提供服务注册和发现的功能。
• Provider Service:服务提供者，它是一个 Eureka Client，提供服务。
• Consumer Service:服务消费者，它是 一个 Eureka Client，消费服务。
  服务消费的基本过程如下:首先前要一个服务注册中心 Eureka Server，服务提供者Eureka Client 向服务注册中心Eureka Server注册，将自己的信息(比如服务名和服务的IP地址等) 通过阻STA凹的形式提交给服务注册中心 EurekaServer。同样，服务消费者Eureka Client也向服务注册中心 Eureka Server注册，同时服务消费者获取一份服务注册列表的信息 ，该列表包含了所有向脱务注册中心Eureka Server注册的服务信息。获取服务注册列表信息之后，服务消费者就知|近服务提供者的IP地址，可以通过Http远程调度来消费服务提供者的服务。

三、案例实践

3.1 Eureka Server

3.1.1 pom配置

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.10.RELEASE</version>
    <relativePath/>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka-server</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-server</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Dalston.RC1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>  

3.1.2 添加启动代码中添加@EnableEurekaServer注解

@SpringBootApplication
@EnableEurekaServer
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
 }

3.1.3 application.properties配置

在application.properties添加以下配置：

spring.application.name=spring-cloud-eureka
server.port=8080
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.serviceUrl.defaultZone=http://localhost:${server.port}/eureka/
#eureka.server.enable-self-preservation=false    #设为false，关闭自我保护(默认开启)

• eureka.client.register-with-eureka ：表示是否将自己注册到Eureka Server，默认为true。
• eureka.client.fetch-registry ：表示是否从Eureka Server获取注册信息，默认为true。
• eureka.client.serviceUrl.defaultZone ：设置与Eureka Server交互的地址，查询服务和注册服务都需要依赖这个地址。默认是http://localhost:8761/eureka ；多个地址可使用 , 分隔。
• eureka.server.enable-self-preservation：配置自我保护模式，设置为false时会使Eureka Server清理无效节点。（测试时可关闭，生产环境不建议关闭）

启动工程后，访问:http://localhost:8080/，可以看到下面的页面，其中还没有发现任何服务

3.2 Eureka Client

3.2.1 pom配置

 pom文件与EurekaServer的pom文件相同

3.2.2 添加启动代码中添加@EnableEurekaClient注解

@SpringBootApplication
@EnableEurekaClient
public class DemoApplication {
public static void main(String[] args) {
    SpringApplication.run(DemoApplication.class, args);
    }
}

3.2.3 application.properties配置

在application.properties添加以下配置：

server.port=8081
eureka.client.serviceUrl.defaultZone=http://localhost:8080/eureka/
spring.application.name=spring-cloud-eureka-client

启动工程后，访问:http://localhost:8080/，可以看到下面的页面，发现服务已经注册成功了。

3.3 Eureka 服务提供与消费

3.3.1 服务提供

我们假设服务提供者有一个hello方法，可以根据传入的参数，提供输出“Hello xxx，this is first messge”的服务

（1）pom配置

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.10.RELEASE</version>
</parent>
<dependencies>
       <dependency>
           <groupId>org.springframework.cloud</groupId>
           <artifactId>spring-cloud-starter-eureka</artifactId>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
       </dependency>
 </dependencies>
 <dependencyManagement>
       <dependencies>
           <dependency>
               <groupId>org.springframework.cloud</groupId>
               <artifactId>spring-cloud-dependencies</artifactId>
               <version>Dalston.RC1</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>
       </dependencies>
 </dependencyManagement>

（2）application.properties配置

application.properties配置如下：

spring.application.name=spring-cloud-producer
server.port=8082
eureka.client.serviceUrl.defaultZone=http://localhost:8080/eureka/

（3）启动类

启动类中添加@EnableDiscoveryClient注解

@SpringBootApplication
@EnableDiscoveryClient
public class ProducerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProducerApplication.class, args);
    }
}

添加@EnableDiscoveryClient注解后，项目就具有了服务注册的功能。
@EnableDiscoveryClient与@EnableEurekaClient区别 : https://www.jianshu.com/p/f6db3117864f

(4) Controller

提供hello服务

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String index(@RequestParam String name) {
        return "Hello " + name + "，this is first messge";
    }
}

启动工程后，就可以在注册中心的页面看到SPRING-CLOUD-PRODUCER服务。

到此服务提供者配置就完成了。

3.3.2 服务调用

（1）pom配置

 和服务提供者一致

（2）application.properties配置

application.properties配置如下：

spring.application.name=spring-cloud-producer
server.port=8083
eureka.client.serviceUrl.defaultZone=http://localhost:8080/eureka/

（3）启动类

启动类添加@EnableDiscoveryClient和@EnableFeignClients注解。

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class ConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
}

• @EnableDiscoveryClient :启用服务注册与发现
• @EnableFeignClients：启用Feign进行远程调用

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

（4）Feign调用实现

@FeignClient(name = "spring-cloud-producer")
public interface HelloRemote {

    @RequestMapping(value = "/hello")
    String hello(@RequestParam(value = "name") String name);
}

（5）Web层调用远程服务

将HelloRemote注入到controller层，像普通方法一样去调用即可。

@RestController
public class ConsumerController {

    @Autowired
    private HelloRemote helloRemote;

    @RequestMapping(value = "/hello/{name}")
    public String index(@PathVariable("name") String name){
        return helloRemote.hello(name);
    }
}

到此，最简单的一个服务注册与调用的例子就完成了。

3.3.3测试

简单调用

依次启动spring-cloud-eureka、spring-cloud-producer、spring-cloud-consumer三个项目
先输入：http://localhost:8082/hello?name=ben 检查spring-cloud-producer服务是否正常
返回：hello ben，this is first messge
说明spring-cloud-producer正常启动，提供的服务也正常。
浏览器中输入：http://localhost:8083/hello/ben
返回：hello ben，this is first messge
说明客户端已经成功的通过feign调用了远程服务hello，并且将结果返回到了浏览器。

负载均衡

将以上面spring-cloud-producer为例子修改，其中的controller改动如下：

@RestController
public class HelloController {
    
    @RequestMapping("/hello")
    public String index(@RequestParam String name) {
        return "Hello "+name+"，this is producer 2  send first messge";
    }
}

在配置文件中改动端口：

spring.application.name=spring-cloud-consumer
server.port=8084
eureka.client.serviceUrl.defaultZone=http://localhost:8080/eureka/

打包启动后，在eureka就会发现两个服务提供者，如下图：

然后在浏览器再次输入：http://localhost:8083/hello/ben 进行测试：
第一次返回结果：Hello ben，this is first messge
第二次返回结果：Hello ben，this is producer 2 send first messge
不断的进行测试下去会发现两种结果交替出现，说明两个服务中心自动提供了服务均衡负载的功能。如果我们将服务提供者的数量在提高为N个，测试结果一样，请求会自动轮询到每个服务端来处理。

3.4 搭建高可用的Eureka Server集群

注册中心这么关键的服务，如果是单点话，遇到故障就是毁灭性的。在一个分布式系统中，服务注册中心是最重要的基础部分，理应随时处于可以提供服务的状态。为了维持其可用性，使用集群是很好的解决方案。Eureka通过互相注册的方式来实现高可用的部署，所以我们只需要将Eureke Server配置其他可用的serviceUrl就能实现高可用部署。

3.4.1 application.yml配置

在生产中我们可能需要多台注册中心来保证服务的稳定性，配置的原理其实都一样，将注册中心分别指向其它的注册中心。这里只介绍三台集群的配置情况，只要将每台注册中心分别又指向其它两个节点即可，使用application.yml来配置。

spring:
  application:
    name: spring-cloud-eureka
  profiles: peer1
server:
  port: 8001
eureka:
  instance:
    hostname: peer1
  client:
    serviceUrl:
      defaultZone: http://peer2:8002/eureka/,http://peer3:8003/eureka/
---
spring:
  application:
    name: spring-cloud-eureka
  profiles: peer2
server:
  port: 8002
eureka:
  instance:
    hostname: peer2
  client:
    serviceUrl:
      defaultZone: http://peer1:8001/eureka/,http://peer3:8003/eureka/
---
spring:
  application:
    name: spring-cloud-eureka
  profiles: peer3
server:
  port: 8003
eureka:
  instance:
    hostname: peer3
  client:
    serviceUrl:
      defaultZone: http://peer1:8001/eureka/,http://peer2:8002/eureka/

3.4.2 host转换

本地搭建集群需要对host进行转换，修改hosts文件，添加如下内容：

127.0.0.1 peer1  
127.0.0.1 peer2 
127.0.0.1 peer3

3.4.3 打包启动

#打包
mvn clean package
# 分别以peer1、peer2和peer3 配置信息启动eureka
java -jar eureka-cluster.jar --spring.profiles.active=peer1
java -jar eureka-cluster.jar --spring.profiles.active=peer2
java -jar eureka-cluster.jar --spring.profiles.active=peer3

依次启动完成后，浏览器输入：http://localhost:8001/ 效果图如下：

可以在peer1中看到了peer2、peer3的相关信息，同理，访问http://localhost:8002/和http://localhost:8003/ 也可以看到对应信息。至此eureka集群也已经完成了。

四、源码解析Eureka注册发现

4.1 Eureka 的一些概念
4.1.1 Register一一服务注册
当 Eureka Client 向 Eureka Server 注册时 ， 端口、运行状况H1标的 Uri、 主页地址等信息。
Eureka Client 提供自身的元数据，比如 IP 地址、端口、运行状况指标的Url、 主页地址等信息。
4.1.2 Renew一一服务续约
Eureka Client在默认的情况下会每隔30秒发送一次心跳来进行服务续约。通过服务续约来告知 EurekaServer该 EurekaClient仍然可用，没有出现故障。正常情况下，如果EurekaServer 在90秒内没有收到EurekaClient的心跳， EurekaServer会将EurekaClient实例从注册列表中删除。注意:管网建议不要更改服务续约的间隔时间。
4.1.3 Fetch Registries一一获取服务注册列表信息
Eureka Client从EurekaServer获取服务注册表信息，井将其缓存在本地。EurekaClient会使用服务注册列表信息查找其他服务的信息，从而进行远程调用。该注册列表信息定时(每30秒)更新一次，每次返回注册列表信息可能与EurekaClient的缓存信息不同， EurekaClient会自己处理这些信息。如呆由于某种原因导致注册列表信息不能及时匹配，EurekaClient会重新获取整个注册表信息。 EurekaServer缓存了所有的服务注册列表信息，并将整个注册列表以及每个应用程序的信息进行了压缩 ，压缩内容和没有压缩的内容完全相同。 EurekaClient和EurekaServer可以使用JSON和XML数据格式进行通信。在默认的情况下，EurekaClient使用JSON格式的方式来获取服务注册列表的信息。
4.1.4 Cancel一一服务下线
Eureka Client在程序关闭时可 以向 Eureka Server发送下线请求 。发送请求后，该客户端的 实例信息将从EurekaServer的服务注册列表中删除。该下线请求不会自动完成，需要在程序 关闭时调用以下代码:
DiscoveryManager.getinstance().shutdownComponent();
4.1.5 Eviction一一服务剔除
在默认情况下，当EurekaClient连续90秒没有向EurekaServer发送服务续约(即心跳)时， Eureka Server会将该服务实例从服务注册列表删除，即服务剔除。

Eureka包含如上很多功能，这里主要进行最常用的服务注册发现的源码解析。

4.2 Eureka服务注册发现源码解析

服务注册，即 Eureka Client向Eureka Server提交自己的服务信息 ， 包括IP地址、端口、 Serviceld等信息。 如果EurekaClient在配置文件中没有配置Serviceld，则默认为配置文件中 配置的服务名 ，即${spring.application.name}的值。当EurekaClient启动时，会将自身的服务信息发送到EurekaServer。 这个过程其实非常简单， 现在来从源码的角度分析服务注册的过程。 在工程的Maven的依赖包下，找到 eureka-client-1.6.2.jar包。在 com.netflix.discovery包下有一个 DiscoveryClient类，该类包含了EurekaClient向EurekaServer注册的相关方法。其中，DiscoveryClient实现了EurekaClient接
口，并且它是一个单例模式 ，而EurekaClient继承了LookupService 接口 。它们之间的关系如 图下图所示。

DiscoveryClient、EurekaClient、LookupService的关系

在 DiscoveryClient类中有一个服务注册的方法 register()， 该方法通过 Http请求向 Eureka
Server 注 册， 其 代 码 如 下 :

/**
 * Register with the eureka service by making the appropriate REST call.
 */
boolean register() throws Throwable {
      logger.info(PREFIX + appPathIdentifier + ": registering service...");
      EurekaHttpResponse<Void> httpResponse;
      try {
          httpResponse = eurekaTransport.registrationClient.register(instanceInfo);
      } catch (Exception e) {
          logger.warn("{} - registration failed {}", PREFIX + appPathIdentifier, e.getMessage(), e);
            throw e;
     }
     if (logger.isInfoEnabled()) {
         logger.info("{} - registration status: {}", PREFIX + appPathIdentifier, httpResponse.getStatusCode());
     }
        return httpResponse.getStatusCode() == 204;
}

在DiscoveryClient类下继续追踪register()方法 ，这个方法被InstancelnfoReplicator类 的 run() 方法调用， 其中InstancelnfoReplicator实现了Runnable接口，run()方法代码如下:

public void run() {
        try {
            discoveryClient.refreshInstanceInfo();

            Long dirtyTimestamp = instanceInfo.isDirtyWithTime();
            if (dirtyTimestamp != null) {
                discoveryClient.register();
                instanceInfo.unsetIsDirty(dirtyTimestamp);
            }
        } catch (Throwable t) {
            logger.warn("There was a problem with the instance info replicator", t);
        } finally {
            Future next = scheduler.schedule(this, replicationIntervalSeconds, TimeUnit.SECONDS);
            scheduledPeriodicRef.set(next);
        }
    }

而 InstancelnfoReplicator 类是在 DiscoveryClient 初始化过程中使用的， 其中有一个 initScheduledTasks()方法 ， 该方法主要开启了获取服务注册列表的信息。 如果需要向EurekaServer注册，则开启注册，同时开启了定时任务向EurekaServer服务续约，具体代码如下:

    /**
     * Initializes all scheduled tasks.
     */
    private void initScheduledTasks() {
        if (clientConfig.shouldFetchRegistry()) {
            ... //省略了任务调度获取注册列表 的代码
        if (clientConfig.shouldRegisterWithEureka()) {
            int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
            int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
            logger.info("Starting heartbeat executor: " + "renew interval is: " + renewalIntervalInSecs);

            // Heartbeat timer
            scheduler.schedule(
                    new TimedSupervisorTask(
                            "heartbeat",
                            scheduler,
                            heartbeatExecutor,
                            renewalIntervalInSecs,
                            TimeUnit.SECONDS,
                            expBackOffBound,
                            new HeartbeatThread()
                    ),
                    renewalIntervalInSecs, TimeUnit.SECONDS);

            // InstanceInfo replicator
            instanceInfoReplicator = new InstanceInfoReplicator(
                    this,
                    instanceInfo,
                    clientConfig.getInstanceInfoReplicationIntervalSeconds(),
                    2); // burstSize

            statusChangeListener = new ApplicationInfoManager.StatusChangeListener() {
                @Override
                public String getId() {
                    return "statusChangeListener";
                }

                @Override
                public void notify(StatusChangeEvent statusChangeEvent) {
                    if (InstanceStatus.DOWN == statusChangeEvent.getStatus() ||
                            InstanceStatus.DOWN == statusChangeEvent.getPreviousStatus()) {
                        // log at warn level if DOWN was involved
                        logger.warn("Saw local status change event {}", statusChangeEvent);
                    } else {
                        logger.info("Saw local status change event {}", statusChangeEvent);
                    }
                    instanceInfoReplicator.onDemandUpdate();
                }
            };
            ...
    }

再来跟踪 Eurekaserver端的代码，在Maven的eureka-core:1丘2 的jar包下。 打开com.netflix. eureka包，会发现有一个EurekaBootStrap的类，BootStrapContext类在程序启动时具有最先初始化的权限，代码如下:

protected void initEurekaServerContext() throws Exception {
        ...//省略代码
        Object registry;
        if (this.isAws(applicationInfoManager.getInfo())) {
            ... //省略代码，如果是 AWS 的代码
        } else {
            registry = new PeerAwareInstanceRegistryImpl(eurekaServerConfig, this.eurekaClient.getEurekaClientConfig(), serverCodecs, this.eurekaClient);
        }

        PeerEurekaNodes peerEurekaNodes = this.getPeerEurekaNodes((PeerAwareInstanceRegistry)registry, eurekaServerConfig, this.eurekaClient.getEurekaClientConfig(), serverCodecs, applicationInfoManager);
        this.serverContext = new DefaultEurekaServerContext(eurekaServerConfig, serverCodecs, (PeerAwareInstanceRegistry)registry, peerEurekaNodes, applicationInfoManager);
        EurekaServerContextHolder.initialize(this.serverContext);
        this.serverContext.initialize();
        logger.info("Initialized server context");
        int registryCount = ((PeerAwareInstanceRegistry)registry).syncUp();
        ((PeerAwareInstanceRegistry)registry).openForTraffic(applicationInfoManager, registryCount);
        EurekaMonitors.registerAllStats();
    }

其中， PeerAwarelnstanceRegistryImpI和PeerEurekaNod由两个类从其命名上看， 应该和服务注册以及EurekaServer高可用有关。先追踪PeerAwarelnstanceRegistryImpI类， 在该类中有一个register()方法，该方法提供了服务注册，并且将服务注册后的信息同步到其他的 EurekaServer服务中。代码如下:

    @Override
    public void register(final InstanceInfo info, final boolean isReplication) {
        int leaseDuration = Lease.DEFAULT_DURATION_IN_SECS;
        if (info.getLeaseInfo() != null && info.getLeaseInfo().getDurationInSecs() > 0) {
            leaseDuration = info.getLeaseInfo().getDurationInSecs();
        }
        super.register(info, leaseDuration, isReplication);
        replicateToPeers(Action.Register, info.getAppName(), info.getId(), info, null, isReplication);
    }

点击其中的super.register(info,leaseDuration,isReplication)方法，进入其父类 Abstractlnstance­Registry可以发现更多细节，注册列表的信息被保存在一个Map中。 PeerAwarelnstanceRegistryImpI类的replicateToPeers()方法用于将注册列表信息同步到其他 EurekaServer的其他 Peers节点，追踪代码，发现该方法会循环遍历向所有的Peers节点注册， 最终执行类PeerEurekaNodes的register()方法，该方法通过执行一个任务向其他节点同步该注册信息，代码如下:

public void register(final InstanceInfo info) throws Exception {
        long expiryTime = System.currentTimeMillis() + getLeaseRenewalOf(info);
        batchingDispatcher.process(
                taskId("register", info),
                new InstanceReplicationTask(targetHost, Action.Register, info, null, true) {
                    public EurekaHttpResponse<Void> execute() {
                        return replicationClient.register(info);
                    }
                },
                expiryTime
        );
    }

经过一系列的源码追踪，可以发现PeerAwarelnstanceRegistryImpI类的 register()方法实现了服 务的注册，并且向其他EurekaServer的Peer节点同步了该注册信息，那么register()方法被谁调用了呢? 在前文中有关EurekaClient的分析中可以知道，EurekaClient是通过Http来向EurekaServer注册的，那么Eureka Server 肯定会提供一个服务注册的API接口给EurekaClient 调用，PeerAwarelnstanceRegistryImpI的 register()方法最终肯定会被暴露的Http接口所调用。在IDEA开发工具中，同时按住“ Alt”+鼠标左键(查看某个类被谁调用的快捷键)，ApplicationResour类的addlnstance()方法，即服务注册的接口，其代码如下:

@POST
    @Consumes({"application/json", "application/xml"})
    public Response addInstance(InstanceInfo info,
                                @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication) {
        ...//省略代码
        registry.register(info, "true".equals(isReplication));
        return Response.status(204).build();  // 204 to be backwards compatible
    }

总结：这一章节主要学习了Eureka注册中心的搭建、集群的搭建以及服务的提供和调用，并简单使用了Feign进行服务调用以及Eureka服务注册发现的源码解析。
github源码地址