eureka客户端源码解析

最新推荐文章于 2024-07-30 15:29:38 发布
最新推荐文章于 2024-07-30 15:29:38 发布
阅读量3.4k 收藏 2
点赞数 2
分类专栏： spring cloud Spring boot相关实战知识的专栏 文章标签： eureka客户端 eureka客户端源码

原文：https://blog.tookbra.com/2017/08/25/Spring-Cloud-Eureka-Client-Source/

源码目录结构

.
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── org
    │   │       └── springframework
    │   │           └── cloud
    │   │               └── netflix
    │   │                   ├── eureka
    │   │                   │   ├── CloudEurekaClient.java
    │   │                   │   ├── CloudEurekaInstanceConfig.java
    │   │                   │   ├── CloudEurekaTransportConfig.java
    │   │                   │   ├── EnableEurekaClient.java
    │   │                   │   ├── EurekaClientAutoConfiguration.java
    │   │                   │   ├── EurekaClientConfigBean.java
    │   │                   │   ├── EurekaConstants.java
    │   │                   │   ├── EurekaDiscoveryClient.java
    │   │                   │   ├── EurekaDiscoveryClientConfiguration.java
    │   │                   │   ├── EurekaHealthCheckHandler.java
    │   │                   │   ├── EurekaHealthIndicator.java
    │   │                   │   ├── EurekaInstanceConfigBean.java
    │   │                   │   ├── InstanceInfoFactory.java
    │   │                   │   ├── MutableDiscoveryClientOptionalArgs.java
    │   │                   │   ├── config
    │   │                   │   │   ├── DiscoveryClientOptionalArgsConfiguration.java
    │   │                   │   │   ├── EurekaClientConfigServerAutoConfiguration.java
    │   │                   │   │   ├── EurekaDiscoveryClientConfigServiceAutoConfiguration.java
    │   │                   │   │   └── EurekaDiscoveryClientConfigServiceBootstrapConfiguration.java
    │   │                   │   ├── http
    │   │                   │   │   ├── EurekaApplications.java
    │   │                   │   │   ├── RestTemplateDiscoveryClientOptionalArgs.java
    │   │                   │   │   ├── RestTemplateEurekaHttpClient.java
    │   │                   │   │   ├── RestTemplateTransportClientFactories.java
    │   │                   │   │   └── RestTemplateTransportClientFactory.java
    │   │                   │   └── serviceregistry
    │   │                   │       ├── EurekaAutoServiceRegistration.java
    │   │                   │       ├── EurekaRegistration.java
    │   │                   │       └── EurekaServiceRegistry.java
    │   │                   └── ribbon
    │   │                       └── eureka
    │   │                           ├── DomainExtractingServerList.java
    │   │                           ├── EurekaRibbonClientConfiguration.java
    │   │                           ├── EurekaServerIntrospector.java
    │   │                           ├── RibbonEurekaAutoConfiguration.java
    │   │                           └── ZoneUtils.java
    │   └── resources
    │       └── META-INF
    │           └── spring.factories
    └── test
        ├── java
        │   └── org
        │       └── springframework
        │           └── cloud
        │               └── netflix
        │                   ├── eureka
        │                   │   ├── ConditionalOnRefreshScopeTests.java
        │                   │   ├── EurekaClientAutoConfigurationTests.java
        │                   │   ├── EurekaClientConfigBeanTests.java
        │                   │   ├── EurekaHealthCheckHandlerTests.java
        │                   │   ├── EurekaInstanceConfigBeanTests.java
        │                   │   ├── InstanceInfoFactoryTests.java
        │                   │   ├── config
        │                   │   │   ├── ConfigRefreshTests.java
        │                   │   │   ├── DiscoveryClientConfigServiceAutoConfigurationTests.java
        │                   │   │   ├── EurekaClientConfigServerAutoConfigurationTests.java
        │                   │   │   ├── JerseyOptionalArgsConfigurationTest.java
        │                   │   │   └── RestTemplateOptionalArgsConfigurationTest.java
        │                   │   ├── healthcheck
        │                   │   │   └── EurekaHealthCheckTests.java
        │                   │   ├── http
        │                   │   │   ├── EurekaServerMockApplication.java
        │                   │   │   ├── RestTemplateEurekaHttpClientTest.java
        │                   │   │   ├── RestTemplateTransportClientFactoriesTest.java
        │                   │   │   └── RestTemplateTransportClientFactoryTest.java
        │                   │   ├── sample
        │                   │   │   ├── ApplicationTests.java
        │                   │   │   ├── EurekaSampleApplication.java
        │                   │   │   └── RefreshEurekaSampleApplication.java
        │                   │   └── serviceregistry
        │                   │       └── EurekaServiceRegistryTests.java
        │                   └── ribbon
        │                       └── eureka
        │                           ├── DomainExtractingServerListTests.java
        │                           ├── EurekaDisabledRibbonClientIntegrationTests.java
        │                           ├── EurekaRibbonClientConfigurationTests.java
        │                           ├── EurekaRibbonClientPreprocessorIntegrationTests.java
        │                           ├── EurekaRibbonClientPropertyOverrideIntegrationTests.java
        │                           ├── RibbonClientPreprocessorIntegrationTests.java
        │                           ├── RibbonEurekaAutoConfigurationTests.java
        │                           └── ZoneUtilsTests.java
        └── resources
            └── application.yml

客户端启动分析

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

EnableDiscoveryClient类

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({EnableDiscoveryClientImportSelector.class})
public @interface EnableDiscoveryClient {
    boolean autoRegister() default true;
}

@Order(Ordered.LOWEST_PRECEDENCE - 100)
public class EnableDiscoveryClientImportSelector
        extends SpringFactoryImportSelector<EnableDiscoveryClient> {

    @Override
    public String[] selectImports(AnnotationMetadata metadata) {
        String[] imports = super.selectImports(metadata);

        AnnotationAttributes attributes = AnnotationAttributes.fromMap(
                metadata.getAnnotationAttributes(getAnnotationClass().getName(), true));

        boolean autoRegister = attributes.getBoolean("autoRegister");

        if (autoRegister) {
            List<String> importsList = new ArrayList<>(Arrays.asList(imports));
            importsList.add("org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationConfiguration");
            imports = importsList.toArray(new String[0]);
        }

        return imports;
    }

    ...

}

eureka客户端只要在启动类中加上@EnableDiscoveryClient注解，便表示这是一个eureka客户端
在EnableDiscoveryClient类中，可以看到引入了EnableDiscoveryClientImportSelector类
在super.selectImports方法中加载了META-INF目录下有spring.factories文件中的org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.netflix.eureka.config.EurekaClientConfigServerAutoConfiguration,\
org.springframework.cloud.netflix.eureka.config.EurekaDiscoveryClientConfigServiceAutoConfiguration,\
org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration,\
org.springframework.cloud.netflix.ribbon.eureka.RibbonEurekaAutoConfiguration

org.springframework.cloud.bootstrap.BootstrapConfiguration=\
org.springframework.cloud.netflix.eureka.config.EurekaDiscoveryClientConfigServiceBootstrapConfiguration

org.springframework.cloud.client.discovery.EnableDiscoveryClient=\
org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration

@Order(2147483547)
public class EnableDiscoveryClientImportSelector extends SpringFactoryImportSelector<EnableDiscoveryClient> {
    public EnableDiscoveryClientImportSelector() {
    }

    //返回需要加载的EurekaDiscoveryClientConfiguration bean
    public String[] selectImports(AnnotationMetadata metadata) {
        //org.springframework.cloud.client.discovery.EnableDiscoveryClient=\org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration
        String[] imports = super.selectImports(metadata);
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(this.getAnnotationClass().getName(), true));
        boolean autoRegister = attributes.getBoolean("autoRegister");
        if(autoRegister) {
            List<String> importsList = new ArrayList(Arrays.asList(imports));
            importsList.add("org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationConfiguration");
            imports = (String[])importsList.toArray(new String[0]);
        }

        return imports;
    }

    protected boolean isEnabled() {
        return ((Boolean)(new RelaxedPropertyResolver(this.getEnvironment())).getProperty("spring.cloud.discovery.enabled", Boolean.class, Boolean.TRUE)).booleanValue();
    }

    protected boolean hasDefaultFactory() {
        return true;
    }
}

spring-boot在启动过程中通过加载、解析spring.factories文件中的信息，对一些bean进行自动装配，在这里我们就不关注了spring-boot 自动配置
在EurekaServerAutoConfiguration类中

@Configuration
@EnableConfigurationProperties
@ConditionalOnClass(EurekaClientConfig.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")
public class EurekaClientAutoConfiguration {
   ...

   @Bean
       public DiscoveryClient discoveryClient(EurekaInstanceConfig config,
               EurekaClient client) {
           return new EurekaDiscoveryClient(config, client);
       }

       @Configuration
    @ConditionalOnRefreshScope
    protected static class RefreshableEurekaClientConfiguration {

        @Autowired
        private ApplicationContext context;

        @Autowired(required = false)
        private DiscoveryClientOptionalArgs optionalArgs;

        @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);
        }

        @Bean
        @ConditionalOnMissingBean(value = ApplicationInfoManager.class, search = SearchStrategy.CURRENT)
        @org.springframework.cloud.context.config.annotation.RefreshScope
        @Lazy
        public ApplicationInfoManager eurekaApplicationInfoManager(
                EurekaInstanceConfig config) {
            InstanceInfo instanceInfo = new InstanceInfoFactory().create(config);
            return new ApplicationInfoManager(config, instanceInfo);
        }

    }

    @Bean
    public DiscoveryClient discoveryClient(EurekaInstanceConfig config,
            EurekaClient client) {
        return new EurekaDiscoveryClient(config, client);
    }

   ...
}

CloudEurekaClient
spring cloud使用CloudEurekaClient对eureka的DiscoveryClient初始化

EurekaAutoServiceRegistration类实现了SmartLifecycle接口的start方法，会在所有spring bean都初始化完成后调用该方法

public class EurekaAutoServiceRegistration implements AutoServiceRegistration, SmartLifecycle, Ordered {
    ...

    @Override
    public void start() {
        // only set the port if the nonSecurePort is 0 and this.port != 0
        if (this.port.get() != 0 && this.registration.getNonSecurePort() == 0) {
            this.registration.setNonSecurePort(this.port.get());
        }

        // only initialize if nonSecurePort is greater than 0 and it isn't already running
        // because of containerPortInitializer below
        if (!this.running.get() && this.registration.getNonSecurePort() > 0) {
            // 设置 eureka 初始化状态 eureka.instance.initial-status
            this.serviceRegistry.register(this.registration);
            // 传递eureka注册事件
            // DiscoveryClientHealthIndicator类监听
            this.context.publishEvent(
                    new InstanceRegisteredEvent<>(this, this.registration.getInstanceConfig()));
            // 设置在spring容器关闭的时候执行stop方法
            this.running.set(true);
        }
    }

    ....
}

public class EurekaServiceRegistry implements ServiceRegistry<EurekaRegistration> {
    public void register(EurekaRegistration reg) {
        maybeInitializeClient(reg);

        if (log.isInfoEnabled()) {
            log.info("Registering application " + reg.getInstanceConfig().getAppname()
                    + " with eureka with status "
                    + reg.getInstanceConfig().getInitialStatus());
        }

        reg.getApplicationInfoManager()
                .setInstanceStatus(reg.getInstanceConfig().getInitialStatus());

        if (reg.getHealthCheckHandler() != null) {
            reg.getEurekaClient().registerHealthCheck(reg.getHealthCheckHandler());
        }
    }
}

@Singleton
public class DiscoveryClient implements EurekaClient {
    @Inject
    DiscoveryClient(ApplicationInfoManager applicationInfoManager, EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args,
                    Provider<BackupRegistry> backupRegistryProvider) {
        if (args != null) {
            this.healthCheckHandlerProvider = args.healthCheckHandlerProvider;
            this.healthCheckCallbackProvider = args.healthCheckCallbackProvider;
            this.eventListeners.addAll(args.getEventListeners());
        } else {
            this.healthCheckCallbackProvider = null;
            this.healthCheckHandlerProvider = null;
        }

        this.applicationInfoManager = applicationInfoManager;
        //获取 instance
        InstanceInfo myInfo = applicationInfoManager.getInfo();
        //客户端配置
        clientConfig = config;
        staticClientConfig = clientConfig;
        //传输配置，心跳时间等
        transportConfig = config.getTransportConfig();
        instanceInfo = myInfo;
        if (myInfo != null) {
            appPathIdentifier = instanceInfo.getAppName() + "/" + instanceInfo.getId();
        } else {
            logger.warn("Setting instanceInfo to a passed in null value");
        }

        this.backupRegistryProvider = backupRegistryProvider;

        this.urlRandomizer = new EndpointUtils.InstanceInfoBasedUrlRandomizer(instanceInfo);
        localRegionApps.set(new Applications());

        fetchRegistryGeneration = new AtomicLong(0);

        remoteRegionsToFetch = new AtomicReference<String>(clientConfig.fetchRegistryForRemoteRegions());
        remoteRegionsRef = new AtomicReference<>(remoteRegionsToFetch.get() == null ? null : remoteRegionsToFetch.get().split(","));

        //是否需要信息检索 eureka.client.fetchRegistry=true
        //
        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;
        }

        //是否注册到eureka eureka.client.registerWithEureka=true
        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;
        }

        logger.info("Initializing Eureka in region {}", clientConfig.getRegion());

        //如果不开启注册到eureka和从eureka检索服务
        //把定时任务、心跳设置为null
        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());

            // This is a bit of hack to allow for existing code using DiscoveryManager.getInstance()
            // to work with DI'd DiscoveryClient
            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;  // no need to setup up an network tasks and we are done
        }

        // 配置作业
        try {
            scheduler = Executors.newScheduledThreadPool(3,
                    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()
            );  // use direct handoff

            cacheRefreshExecutor = new ThreadPoolExecutor(
                    1, clientConfig.getCacheRefreshExecutorThreadPoolSize(), 0, TimeUnit.SECONDS,
                    new SynchronousQueue<Runnable>(),
                    new ThreadFactoryBuilder()
                            .setNameFormat("DiscoveryClient-CacheRefreshExecutor-%d")
                            .setDaemon(true)
                            .build()
            );  // use direct handoff

            eurekaTransport = new EurekaTransport();
            scheduleServerEndpointTask(eurekaTransport, args);

            AzToRegionMapper azToRegionMapper;
            // eureka.client.use-dns-for-fetching-service-urls
            if (clientConfig.shouldUseDnsForFetchingServiceUrls()) {
                azToRegionMapper = new DNSBasedAzToRegionMapper(clientConfig);
            } else {
                azToRegionMapper = new PropertyBasedAzToRegionMapper(clientConfig);
            }
            if (null != remoteRegionsToFetch.get()) {
                azToRegionMapper.setRegionsToFetch(remoteRegionsToFetch.get().split(","));
            }
            instanceRegionChecker = new InstanceRegionChecker(azToRegionMapper, clientConfig.getRegion());
        } catch (Throwable e) {
            throw new RuntimeException("Failed to initialize DiscoveryClient!", e);
        }
        //刷新服务注册地址
        if (clientConfig.shouldFetchRegistry() && !fetchRegistry(false)) {
            fetchRegistryFromBackup();
        }

        //初始化作业，心跳，状态、缓存
        initScheduledTasks();
        try {
            Monitors.registerObject(this);
        } catch (Throwable e) {
            logger.warn("Cannot register timers", e);
        }

        // This is a bit of hack to allow for existing code using DiscoveryManager.getInstance()
        // to work with DI'd DiscoveryClient
        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());
    }

    /**
     * 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构造函数中：

  • 创建了scheduler定时任务的线程池，heartbeatExecutor心跳检查线程池(服务续约)，cacheRefreshExecutor(服务获取)
  • 然后initScheduledTasks()开启上面三个线程池，往上面3个线程池分别添加相应任务。然后创建了一个instanceInfoReplicator(Runnable任务)，然后调用InstanceInfoReplicator.start方法，把这个任务放进上面scheduler定时任务线程池(服务注册并更新)。
public class ApplicationInfoManager {
    public synchronized void setInstanceStatus(InstanceStatus status) {
        InstanceStatus next = instanceStatusMapper.map(status);
        if (next == null) {
            return;
        }

        InstanceStatus prev = instanceInfo.setStatus(next);
        if (prev != null) {
            for (StatusChangeListener listener : listeners.values()) {
                try {
                    //状态改变
                    listener.notify(new StatusChangeEvent(prev, next));
                } catch (Exception e) {
                    logger.warn("failed to notify listener: {}", listener.getId(), e);
                }
            }
        }
    }
}

private void initScheduledTasks() {
    if (clientConfig.shouldFetchRegistry()) {
        // registry cache refresh timer
        int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
        int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
        scheduler.schedule(
                new TimedSupervisorTask(
                        "cacheRefresh",
                        scheduler,
                        cacheRefreshExecutor,
                        registryFetchIntervalSeconds,
                        TimeUnit.SECONDS,
                        expBackOffBound,
                        new CacheRefreshThread()
                ),
                registryFetchIntervalSeconds, TimeUnit.SECONDS);
    }

    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();
            }
        };

        //eureka.client.on-demand-update-status-change
        //默认为true，一般不设置成false
        if (clientConfig.shouldOnDemandUpdateStatusChange()) {
            //状态改变监听
            applicationInfoManager.registerStatusChangeListener(statusChangeListener);
        }
        //开启
        //初始化实例信息到Eureka服务端的间隔时间 eureka.client.initialInstanceInfoReplicationIntervalSeconds 默认40s
        instanceInfoReplicator.start(clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
    } else {
        logger.info("Not registering with Eureka server per configuration");
    }
}
天涯泪小武
关注
专栏目录
Eureka 源码解析 —— Eureka-Client 初始化（三）之 EurekaClient
FireFlyBus的博客
07-03 887
EurekaClient com.netflix.discovery.EurekaClient，Eureka-Client 接口，声明如下方法： 提供多种方法获取应用集合(com.netflix.discovery.shared.Applications) 和 应用实例信息集合( com.netflix.appinfo.InstanceInfo )。 提供方法获取本地客户端信息，例如，应用管...
1-3 Eureka Client 客户端源码解析
brusion的博客
04-07 473
一、客户端工作流程 1.1、初始化阶段 1、读取与server交互的信息，封装成EurekaClientConfig 2、读取自身服务信息，封装成EurekaInstanceConfig 3、拉取Server注册信息缓存到本地 4、服务注册 5、发送心跳，刷新缓存，注册定时任务 1.2、启动阶段 1、发送心跳维持租约 2、定时获取注册表信息更新本地缓存 3、监控自身信息，如果有变化重新注册服...
Eureka Client 源码解析
寒山道杳
11-16 1069
一、Client 端基本信息 在老版本的 Spring Cloud 的使用中，当构建客户端的时候，会在启动类上标注 @EnableDiscoveryClient 注解，但是在新版本的时候，便不需再标注了，这是因为 Spring Boot 中的自动配置机制不同的原因，这里暂不做论述。那客户端是如何做自动装配的呢？Spring Boot 自身的注解 @SpringBootApplication 本身就是一个组合注解，其中之一的 @EnableAutoConfiguration。 注：本系列文章 spri
【Eureka】Eureka介绍与使用详解，超全！！！
最新发布
weixin_43298211的博客
07-30 3065
以下内容来自百度百科Eureka是Netflix开发的服务发现框架，本身是一个基于REST的服务，主要用于定位运行在AWS域中的中间层服务，以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中，以实现SpringCloud的服务发现功能。Eureka包含两个组件：Eureka Server和Eureka Client。Eureka Server提供服务注册。
Eureka Client 源码详细解读
mrcool2012的博客
12-24 313
client端功能： 1.注册服务 2.拉取server列表到本地 3.发送心跳，续约；定时拉取注册表 4.发送下线 ①spring boot项目引入eureka-client依赖，并注入spring 容器。 在spring-boot项目中pom文件里面添加的依赖中的bean。是如何注册到spring-boot项目的spring容器中的呢？ spring.factories文件是帮助spring-boot项目包以外的bean（即在pom文件中添加依赖中的bean）注册到...
Spring Cloud微服务系列-Eureka Client源码解析(二)
初学者
10-22 2354
导语   上一篇博客中介绍了关于Eureka Client源码的基础部分，如果对于基础部分不是很了解的读者可以点击下面的连接进入到源码分析一中，从头开始学习 Spring Cloud微服务系列 DiscoveryClient构造函数 第一步 构造函数 public DiscoveryClient(ApplicationInfoManager applicationInfoManager, fi...
@EnableEurekaClient源码分析
RodJohnson_523391的专栏
07-14 157
[url]http://www.cnblogs.com/zhangjianbin/p/6616866.html[/url]
深入理解Eureka之源码解析
02-24
本文来自于csdn，本文主要介绍了Eureka的一些概念，高可用架构以及Eureka之源码解析，希望对您的学习有所帮助。Register：服务注册当Eureka客户端向EurekaServer注册时，它提供自身的元数据，比如IP地址、端口，运行...
源码分析之Eureka服务端源码解析
evasnowind的专栏
09-29 559
文章目录说明eureka server基本功能启动eureka-server注册相关bean开启eureka server开启注册注册表管理核心类 InstanceRegistrycom.netflix.eureka.registry.InstanceRegistry是euraka server中注册表管理的核心接口。职责是在内存中管理注册到Eureka Server中的服务实例信息。实现类有PeerAwareInstanceRegistryImpl。服务注册接收服务心跳请求服务剔除剔除的限制剔除服务的定时
Eureka源码解析
qq_43623447的博客
07-06 225
文章目录 本篇文章以源码的角度来深入理解Eureka. Eureka的一些概念 - Register：服务注册 当Eureka客户端向Eureka Server注册时，它提供自身的元数据，比如IP地址、端口，运行状况指示符URL，主页等。 Renew：服务续约 Eureka客户会每隔30秒发送一次心跳来续约。 通过续约来告知Eureka Server该Eureka客户仍然存在，没有出现问题。 正常情况下，如果Eureka Server在90秒没有收到Eureka客户的续约，它会将实例从其注册表中删除。
beaninfo详解源码解析 java_Java后端精选技术：深入理解Eureka之源码解析
weixin_32464651的博客
12-30 90
Eureka的一些概念Register：服务注册 当Eureka客户端向Eureka Server注册时，它提供自身的元数据，比如IP地址、端口，运行状况指示符URL，主页等。Renew：服务续约 Eureka客户会每隔30秒发送一次心跳来续约。 通过续约来告知Eureka Server该Eureka客户仍然存在，没有出现问题。 正常情况下，如果Eureka Server在90秒没有收到Eurek...
Eureka 源码分析
01-28
Eureka源码分析ppt，
Eureka-client服务注册及更新源码详解
夏末安的博客
06-22 931
wiki：https://github.com/Netflix/eureka/wiki/Eureka-REST-operations
Eureka（7）-- EurekaHttpClient类
huiyanshizhen21的博客
10-25 722
1.EurekaHttpClient是一个接口类，实现类有AbstractJerseyEurekaHttpClient、EurekaHttpClientDecorator 用于完成Eureka Client和Eureka Server的交互 2.EurekaHttpClientDecorator的实现类有RedirectingEurekaHttpClient、RetryableEurekaHttp...
Eureka 学习笔记3：EurekaHttpClient
走马观花
07-30 1760
（A low level client factory interface），用于创建 JerseyApplicationClient（Eureka 原生实现）、Jersey2ApplicationClient（Eureka 原生实现）、RestTemplateEurekaHttpClient（SpringCloud 实现）等具体协议相关的实现。，超过会话时间则调用 EurekaHttpClientFactory 的 newClient 方法创建一个新的 EurekaHttpClient 执行请求。
eureka 巧妙的EurekaHttpClient工厂设计与请求发送过程
欢谷悠扬
05-21 655
1.背景 在研究从eureka server拉取服务注册信息列表时，源码阅读到拉取全量列表时，需要调用EurekaHttpClient进行。 方法：com.netflix.discovery.DiscoveryClient#getAndStoreFullRegistry 疑惑代码：eurekaTransport.queryClient.getApplications(remoteRegionsRef.get()) 这里的queryClient返回的竟然不是JerseyApplicationClient而是
SpringCloud源码解析之eureka-client客户端
酸菜鱼_sky的博客
09-02 791
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
【微服务】Eureka+Ribbon实现注册中心与负载均衡
陈宝子的博客
07-22 1393
在搞定了SpringSecurity之后，现在狗子已经正式向微服务发起进攻了（啊，又是一段掉头发的征程）。这里的教学资源来源于黑马程序员的《SpringCloud微服务技术栈课程》，而笔记则是加上了部分自己的理解进行了修改，让其更适合了自己的学习，毕竟知识要进脑子。...
Eureka(四) Eureka 源码分析之EurekaClient源码分析
ForestCat的专栏
10-11 796
一.EurekaClient EurekaClient 为了简化开发人员的工作量，将很多与EurekaServer交互的工作隐藏起来，自主完成。具体完成的工作分为三个阶段， 应用启动阶段,执行阶段, 销毁阶段. 各阶段的工作如下: 应用启动阶段 读取与 Eureka Server交互的配置信息,封装成 EurekaClientConfig 读取自身服务实例配置信息,封装成EurekalnstanceConfig 从Eureka server拉取注册表信息并缓存到本地 服务注册 ...
SpringCloud Eureka客户端源码详解与注册流程
本文档深入解析了Spring Cloud Eureka客户端的源码实现，主要关注以下几个关键部分： 1. **`org.springframework.cloud.netflix.eureka.EurekaClientAutoConfiguration`**: 这个类是Eureka客户端自动配置的核心，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值