EurekaClient自动装配及启动流程解析

在上篇文章中,我们简单介绍了EurekaServer自动装配及启动流程解析，本篇文章则继续研究EurekaClient的相关代码

老规矩，先看spring.factories文件，其中引入了一个配置类EurekaDiscoveryClientConfigServiceBootstrapConfiguration

@ConditionalOnClass(ConfigServicePropertySourceLocator.class)
@ConditionalOnProperty(value = "spring.cloud.config.discovery.enabled", matchIfMissing = false)
@Configuration
@Import({ EurekaDiscoveryClientConfiguration.class,
        EurekaClientAutoConfiguration.class })
public class EurekaDiscoveryClientConfigServiceBootstrapConfiguration {
}

上方两个注解则是这个配置类是否能够开启的条件，这里就不再展开，直接看它引入的配置类吧

EurekaDiscoveryClientConfiguration

  1. 细心的读者可能会发现这里又注册了一个Marker类，可以猜测也是某个地方的开关
  2. EurekaClientConfigurationRefresher这个类看名字就知道这是当配置被动态刷新时的一个处理器，这里也不再展开了
  3. EurekaHealthCheckHandlerConfiguration这里面注册了一个Eureka健康检查的处理类，这个健康检查相关的原理分析可以参考这篇文章：SpringBoot健康检查实现原理

EurekaClientAutoConfiguration

这个类里面全是重点，也是我们本文的核心

注解
@Configuration
@EnableConfigurationProperties
@ConditionalOnClass(EurekaClientConfig.class)
@Import(DiscoveryClientOptionalArgsConfiguration.class)
@ConditionalOnBean(EurekaDiscoveryClientConfiguration.Marker.class)
@ConditionalOnProperty(value = "eureka.client.enabled", matchIfMissing = true)
@AutoConfigureBefore({ NoopDiscoveryClientAutoConfiguration.class,
        CommonsClientAutoConfiguration.class, ServiceRegistryAutoConfiguration.class })
@AutoConfigureAfter(name = {"org.springframework.cloud.autoconfigure.RefreshAutoConfiguration",
        "org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration",
        "org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationAutoConfiguration"})

首先可以看到这个类一共包含这些注解，我们来一一解析比较重要的几个注解吧

@Import(DiscoveryClientOptionalArgsConfiguration.class)

引入了两个bean，RestTemplateDiscoveryClientOptionalArgs和MutableDiscoveryClientOptionalArgs ，这两个类的作用暂且不说

@ConditionalOnBean(EurekaDiscoveryClientConfiguration.Marker.class)

刚才说的Marker类的作用出来了

@AutoConfigureBefore

既然必须在这三个类完成自动装配之后才能进行装配，那就代表着这三个类肯定大有用途，研究一下吧

NoopDiscoveryClientAutoConfiguration

故名思意，负责服务发现的类，咱们重点关注一下其中的几个方法

  1. init
@PostConstruct
    public void init() {
        String host = "localhost";
        try {
            host = InetAddress.getLocalHost().getHostName();
        }
        catch (UnknownHostException e) {
            log.warn("Cannot get host info: (" + e.getMessage() + ")");
        }
        int port = findPort();
        this.serviceInstance = new DefaultServiceInstance(
                this.environment.getProperty("spring.application.name", "application"),
                host, port, false);
    }

这里构造了一个DefaultServiceInstance对象，这个对象包含了当前项目的ip+端口+项目名称

  1. 注入beanNoopDiscoveryClient
@Bean
    public DiscoveryClient discoveryClient() {
        return new NoopDiscoveryClient(this.serviceInstance);
    }

再深入看一下这个类

public class NoopDiscoveryClient implements DiscoveryClient {

    public NoopDiscoveryClient(ServiceInstance instance) {
    }

    @Override
    public String description() {
        return "Spring Cloud No-op DiscoveryClient";
    }

    @Override
    public List<ServiceInstance> getInstances(String serviceId) {
        return Collections.emptyList();
    }

    @Override
    public List<String> getServices() {
        return Collections.emptyList();
    }

}

这个类包含了获取当前实例以及当前服务的方法，但是返回的都是空，那么是不是会在后面的某个地方被覆盖呢？

CommonsClientAutoConfiguration

进去深入了解一下，哎哟，注册了几个bean：DiscoveryClientHealthIndicator、DiscoveryCompositeHealthIndicator。原来是健康检查相关的东西，那就忽略了

ServiceRegistryAutoConfiguration

这个配置类中主要注册了一个bean：ServiceRegistryEndpoint这个类主要是对外提供对与Eureka状态的检查

@ReadOperation
    public ResponseEntity getStatus() {
        if (this.registration == null) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("no registration found");
        }

        return ResponseEntity.ok().body(this.serviceRegistry.getStatus(this.registration));
    }

而Eureka的状态则是通过serviceRegistry对象获取的，这个对象会再下方详细分析

注册bean

接着来看这个类注入的几个bean

EurekaClientConfigBean
@Bean
    @ConditionalOnMissingBean(value = EurekaClientConfig.class, search = SearchStrategy.CURRENT)
    public EurekaClientConfigBean eurekaClientConfigBean(ConfigurableEnvironment env) {
        EurekaClientConfigBean client = new EurekaClientConfigBean();
        if ("bootstrap".equals(this.env.getProperty("spring.config.name"))) {
            client.setRegisterWithEureka(false);
        }
        return client;
    }

这个bean中包含了eureka.client.xxx系列的一些配置，详细的配置信息可以参考这里：https://github.com/shiyujun/syj-study-demo/blob/master/src/main/java/cn/shiyujun/EurekaConfig.md

EurekaInstanceConfigBean

这个bean中主要是包含eureka实例（eureka.instance.xxx系列）的一些配置信息，详细的配置信息同上

RefreshableEurekaClientConfiguration.DiscoveryClient
        @Bean(destroyMethod = "shutdown")
        @ConditionalOnMissingBean(value = EurekaClient.class, search = SearchStrategy.CURRENT)
        @org.springframework.cloud.context.config.annotation.RefreshScope
        @Lazy
        public EurekaClient eurekaClient(ApplicationInfoManager manager, EurekaClientConfig config, EurekaInstanceConfig instance) {
            manager.getInfo(); // force initialization
            return new CloudEurekaClient(manager, config, this.optionalArgs,
                    this.context);
        }

其中CloudEurekaClient是DiscoveryClient的子类，而DiscoveryClient则是EurekaClient的核心类

    public CloudEurekaClient(ApplicationInfoManager applicationInfoManager,
                             EurekaClientConfig config,
                             AbstractDiscoveryClientOptionalArgs<?> args,
                             ApplicationEventPublisher publisher) {
                             //这里会调用父类DiscoveryClient的构造方法
        super(applicationInfoManager, config, args);
        this.applicationInfoManager = applicationInfoManager;
        this.publisher = publisher;
        this.eurekaTransportField = ReflectionUtils.findField(DiscoveryClient.class, "eurekaTransport");
        ReflectionUtils.makeAccessible(this.eurekaTransportField);
    }

父类的构造方法中执行的代码块比较长，一些赋值操作等就忽略了,这里只摘出比较重要的部分

  1. 初始化拉取监控和心跳监控
       if (config.shouldFetchRegistry()) {
            this.registryStalenessMonitor = new ThresholdLevelsMetric(this, METRIC_REGISTRY_PREFIX + "lastUpdateSec_", new long[]{15L, 30L, 60L, 120L, 240L, 480L});
        } else {
            this.registryStalenessMonitor = ThresholdLevelsMetric.NO_OP_METRIC;
        }

        if (config.shouldRegisterWithEureka()) {
            this.heartbeatStalenessMonitor = new ThresholdLevelsMetric(this, METRIC_REGISTRATION_PREFIX + "lastHeartbeatSec_", new long[]{15L, 30L, 60L, 120L, 240L, 480L});
        } else {
            this.heartbeatStalenessMonitor = ThresholdLevelsMetric.NO_OP_METRIC;
        }
  1. 当当前实例不需要注册到EurekaServer时，构造方法走到这里就结束了

        if (!config.shouldRegisterWithEureka() && !config.shouldFetchRegistry()) {
            logger.info("Client configured to neither register nor query for data.");
            scheduler = null;
            heartbeatExecutor = null;
            cacheRefreshExecutor = null;
            eurekaTransport = null;
            instanceRegionChecker = new InstanceRegionChecker(new PropertyBasedAzToRegionMapper(config), clientConfig.getRegion());
            DiscoveryManager.getInstance().setDiscoveryClient(this);
            DiscoveryManager.getInstance().setEurekaClientConfig(config);

            initTimestampMs = System.currentTimeMillis();
            logger.info("Discovery Client initialized at timestamp {} with initial instances count: {}",
                    initTimestampMs, this.getApplications().size());

            return;
        }
  1. 初始化心跳线程和刷新线程以及它们的调度器
  try {
            scheduler = Executors.newScheduledThreadPool(2,
                    new ThreadFactoryBuilder()
                            .setNameFormat("DiscoveryClient-%d")
                            .setDaemon(true)
                            .build());

            heartbeatExecutor = new ThreadPoolExecutor(
                    1, clientConfig.getHeartbeatExecutorThreadPoolSize(), 0, TimeUnit.SECONDS,
                    new SynchronousQueue<Runnable>(),
                    new ThreadFactoryBuilder()
                            .setNameFormat("DiscoveryClient-HeartbeatExecutor-%d")
                            .setDaemon(true)
                            .build()
            );  

            cacheRefreshExecutor = new ThreadPoolExecutor(
                    1, clientConfig.getCacheRefreshExecutorThreadPoolSize(), 0, TimeUnit.SECONDS,
                    new SynchronousQueue<Runnable>(),
                    new ThreadFactoryBuilder()
                            .setNameFormat("DiscoveryClient-CacheRefreshExecutor-%d")
                            .setDaemon(true)
                            .build()
            );
  1. 从EurekaServer拉取注册信息
 if (clientConfig.shouldFetchRegistry() && !fetchRegistry(false)) {
            fetchRegistryFromBackup();
        }

这里fetchRegistry是第一次拉取注册信息，如果拉取不成功的话则执行fetchRegistryFromBackup从备份注册中心获取，同样，拉取的信息会放在之后的文章中

  1. 注册之前的扩展点
  if (this.preRegistrationHandler != null) {
            this.preRegistrationHandler.beforeRegistration();
        }

这里是个空的实现，可以通过实现PreRegistrationHandler接口做些什么操作

  1. 向EurekaServer发起注册
 if (clientConfig.shouldRegisterWithEureka() && clientConfig.shouldEnforceRegistrationAtInit()) {
            try {
                if (!register() ) {
                    throw new IllegalStateException("Registration error at startup. Invalid server response.");
                }
            } catch (Throwable th) {
                logger.error("Registration error at startup: {}", th.getMessage());
                throw new IllegalStateException(th);
            }
        }

注册方法为register，同样这里先不展开

  1. 初始化几个定时任务
initScheduledTasks();

private void initScheduledTasks() {
   // 从 EurekaServer 拉取注册信息
   if (clientConfig.shouldFetchRegistry()) {
       int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
       int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
       scheduler.schedule(
               new TimedSupervisorTask(
                       "cacheRefresh",
                       scheduler,
                       cacheRefreshExecutor,
                       registryFetchIntervalSeconds,
                       TimeUnit.SECONDS,
                       expBackOffBound,
                       new CacheRefreshThread()
               ),
               registryFetchIntervalSeconds, TimeUnit.SECONDS);
   }

   // 向 EurekaServer 发送续租心跳
   if (clientConfig.shouldRegisterWithEureka()) {
       int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
       int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
       logger.info("Starting heartbeat executor: " + "renew interval is: " + renewalIntervalInSecs);

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

       instanceInfoReplicator = new InstanceInfoReplicator(
               this,
               instanceInfo,
               clientConfig.getInstanceInfoReplicationIntervalSeconds(),
               2); 

       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()) {
                   logger.warn("Saw local status change event {}", statusChangeEvent);
               } else {
                   logger.info("Saw local status change event {}", statusChangeEvent);
               }
               instanceInfoReplicator.onDemandUpdate();
           }
       };

       if (clientConfig.shouldOnDemandUpdateStatusChange()) {
       //注册状态监听器
           applicationInfoManager.registerStatusChangeListener(statusChangeListener);
       }

       instanceInfoReplicator.start(clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
   } else {
       logger.info("Not registering with Eureka server per configuration");
   }
}

至此，EurekaClient的自动装配与启动流程就解析完毕了

本文由博客一文多发平台 OpenWrite 发布！

原文地址：https://www.cnblogs.com/zhixiang-org-cn/p/11689212.html

时间： 2024-11-09 09:36:25

EurekaClient自动装配及启动流程解析的相关文章

EurekaServer自动装配及启动流程解析

在开始本篇文章之前,我想你对SpringCloud和SpringBoot的基本使用已经比较熟悉了,如果不熟悉的话可以参考我之前写过的文章 本篇文章的源码基于SpringBoot2.0,SpringCloud的Finchley.RELEASE @EnableEurekaServer注解 我们知道,在使用Eureka作为注册中心的时候,我们会在启动类中增加一个@EnableEurekaServer注解,这个注解我们是一个自定义的EnableXXX系列的注解,主要作用我们之前也多次提到了,就是引入配置

Arm启动流程解析

谈到arm的启动流程不得不说的是bootloader,但是我这篇文章主要来谈谈arm启动流程的,所以bootloader只是跟大家简介一下就ok.这篇文章我会谈到以下内容: 1.bootloader简介以及其作用 2.2440.6410.210当下比较常见的3款处理器的启动流程进行简单分析,通过这三款处理器的分析希望大家掌握arm处理器的启动分析. Ok我们进入主题 l  Bootloader简介及其作用 在我看来bootloader的作用是初始化必要的硬件,引导内核启动.(当然这是主要作用,今

Nginx（一）：启动流程解析

nginx作为高效的http服务器和反向代理服务器,值得我们深入了解. 我们带着几个问题,深入了解下nginx的工作原理.首先是开篇:nginx是如何启动的? nginx是用c写的软件,github地址: https://github.com/nginx/nginx 其目录结构如下,我们主要关注 src 目录下的文件. nginx.c 是main函数入口,我们也是通过这里进行启动流程分析的. 零.启动流程时序图 我们先通过一个时序图进行全局观察nginx是如何跑起来的,然后后续再稍微深入了解些细

“无处不在” 的系统核心服务 —— ActivityManagerService 启动流程解析

本文基于 Android 9.0 , 代码仓库地址 : android_9.0.0_r45 系列文章目录: Java 世界的盘古和女娲 -- Zygote Zygote 家的大儿子 -- SystemServer Android 世界中,谁喊醒了 Zygote ? 文中相关源码链接: SystemServer.java ActivityManagerService.java 之前介绍 SystemServer 启动流程 的时候说到,SystemServer 进程启动了一系列的系统服务,Activ

庖丁解牛 Activity 启动流程

前言 这是 Android 9.0 AOSP 系列 的第五篇了,先来回顾一下前面几篇的大致内容. Java 世界的盘古和女娲 -- Zygote 主要介绍了 Android 世界的第一个 Java 进程 Zygote 的启动过程. 注册服务端 socket,用于响应客户端请求 各种预加载操作,类,资源,共享库等 强制 GC 一次 fork SystemServer 进程 循环等待客户端发来的 socket 请求(请求 socket 连接和请求 fork 应用进程) Zygote家的大儿子 --

SpringBoot启动流程分析（五）：SpringBoot自动装配原理实现

SpringBoot系列文章简介 SpringBoot源码阅读辅助篇: Spring IoC容器与应用上下文的设计与实现 SpringBoot启动流程源码分析: SpringBoot启动流程分析(一):SpringApplication类初始化过程 SpringBoot启动流程分析(二):SpringApplication的run方法 SpringBoot启动流程分析(三):SpringApplication的run方法之prepareContext()方法 SpringBoot启动流程分析(四

跟跟Springboot启动容器，自动装配的过程

-----------------------------------------------------本文只作为跟代码的一个参考,建议可以根据思路在指定类中断点调试学习------------------------------------------------------------ 运行被@SpringBootApplication修饰的程序入口,执行main方法,调用SpringApplication的run方法. 下面是从创建controller层bean的方法调用链如下:(备注:

android源码解析之（十四）--&gt;Activity启动流程

好吧,终于要开始讲解Activity的启动流程了,Activity的启动流程相对复杂一下,涉及到了Activity中的生命周期方法,涉及到了Android体系的CS模式,涉及到了Android中进程通讯Binder机制等等, 首先介绍一下Activity,这里引用一下Android guide中对Activity的介绍: An activity represents a single screen with a user interface. For example, an email appl

android源码解析之（八）--&gt;Zygote进程启动流程

大家都知道android系统的Zygote进程是所有的android进程的父进程,包括SystemServer和各种应用进程都是通过Zygote进程fork出来的.Zygote(孵化)进程相当于是android系统的根进程,后面所有的进程都是通过这个进程fork出来的,而Zygote进程则是通过linux系统的init进程启动的,也就是说,android系统中各种进程的启动方式 init进程 –> Zygote进程 –> SystemServer进程 –>各种应用进程 init进程:li