Spring Clound Eureka 的设计与实现

最新推荐文章于 2022-06-28 09:01:41 发布
置顶 最新推荐文章于 2022-06-28 09:01:41 发布
阅读量307 收藏
点赞数 1
分类专栏： spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangjimmy1994/article/details/116785698
版权
本文详细解读了SpringCloud Eureka Server的工作原理，包括服务注册、续约、同步、服务调用和剔除机制。通过源码剖析，揭示了Eureka如何集成SpringBoot，以及关键配置和功能实现细节。
摘要由CSDN通过智能技术生成

一、 背景

我们知道SpringCloud Eureka是Spring Cloud集合中一个组件，它是对Euraka的集成，用于服务注册和发现。Eureka是Netflix中的一个开源框架。它和 zookeeper、Consul一样，都是用于服务注册管理的。Eureka由多个instance(服务实例)组成，这些服务实例可以分为两种：Eureka Server和Eureka Client。为了便于理解，我们将Eureka client再分为Service Provider和Service Consumer。

  • Eureka Server 提供服务注册和发现
  • Service Provider 服务提供方，将自身服务注册到Eureka，从而使服务消费方能够找到
  • Service Consumer服务消费方，从Eureka获取注册服务列表，从而能够消费服务

相对于Zookeeper这样的注册中心来说，Eureka实现的是AP也就是保证了CAP理论中的分区容错性和可用性，那么Eureka是怎么实现的AP，AP又有什么样的好处呢，这就要从Eureka的源码中来寻找答案了，本文就先从Eureka Server部分来解析源码。

二、Eureka架构图：

grsvqA.png

三、Eureka核心功能点

  1. 服务注册 Eureka Client会通过发送REST请求的方式向Eureka Server注册自己的服务，提供自身的元数据，比如ip地址、端口、运行状况指标的url、主页地址等信息。Eureka Server接收到注册请求后，就会把这些元数据信息存储在一个双层的Map中。
  2. 服务续约 在服务注册后，Eureka Client会维护一个心跳来持续通知Eureka Server，说明服务一直处于可用状态，防止被剔除。Eureka Client在默认的情况下会每隔30秒发送一次心跳来进行服务续约
  3. 服务同步 Eureka Server之间会互相进行注册，构建Eureka Server集群，不同Eureka Server之间会进行服务同步，用来保证服务信息的一致性。
  4. 服务调用 服务消费者在获取到服务清单后，就可以根据清单中的服务列表信息，查找到其他服务的地址，从而进行远程调用。Eurek有Region和Zone的概念，一个Region可以包含多个Zone，在进行服务调用时，优先访问处于同一个Zone中的服务提供者。
  5. 获取服务 服务消费者（Eureka Client）在启动的时候，会发送一个REST请求给Eureka Server，获取上面注册的服务清单，并且缓存在Eureka Client本地，默认缓存30秒 。同时，为了性能考虑，Eureka Server也会维护一份只读的服务清单缓存，该缓存每隔30秒更新一次。
  6. 服务剔除 有时候，服务实例可能会因为网络故障等原因导致不能提供服务，而此时该实例也没有发送请求给Eureka Server来进行服务下线，所以，还需要有服务剔除的机制。Eureka Server在启动的时候会创建一个定时任务，每隔一段时间（默认60秒），从当前服务清单中把超时没有续约（默认90秒）的服务剔除。
  7. 自我保护 当短时间内，统计续约失败的比例，如果达到一定阈值，则会触发自我保护的机制，在该机制下，Eureka Server不会剔除任何的微服务，等到正常后，再退出自我保护机制。
  8. 服务下线 当Eureka Client需要关闭或重启时，就不希望在这个时间段内再有请求进来，所以，就需要提前先发送REST请求给Eureka Server，告诉Eureka Server自己要下线了，Eureka Server在收到请求后，就会把该服务状态置为下线（DOWN），并把该下线事件传播出去。

四、Eureka Server端代码解析

@EnableEurekaServer：熟悉springboot启动流程的都知道，这是要自动注入一些配置进入容器中

@Import(EurekaServerMarkerConfiguration.class)：向IOC容器导入EurekaServerMarkerConfiguration这个配置类

通过springboot的自动注入机制，找到EurekaServer jar包下的spring.factories文件，再根据spring.factories文件找到EurekaServerAutoConfiguration配置类，这个配置类做了两件事，一：@Import(EurekaServerInitializerConfiguration.class)向IOC容器导入EurekaServer初始化配置类，二：把EurekaServer需要的一些类加载到容器中

@Configuration(proxyBeanMethods = false)
@Import(EurekaServerInitializerConfiguration.class)
@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)
@EnableConfigurationProperties({ EurekaDashboardProperties.class,
      InstanceRegistryProperties.class })
@PropertySource("classpath:/eureka/server.properties")
public class EurekaServerAutoConfiguration implements WebMvcConfigurer {

   /**
    * List of packages containing Jersey resources required by the Eureka server.
    */
   private static final String[] EUREKA_PACKAGES = new String[] {
         "com.netflix.discovery", "com.netflix.eureka" };

   @Autowired
   private ApplicationInfoManager applicationInfoManager;

   @Autowired
   private EurekaServerConfig eurekaServerConfig;

   @Autowired
   private EurekaClientConfig eurekaClientConfig;

   @Autowired
   private EurekaClient eurekaClient;

   @Autowired
   private InstanceRegistryProperties instanceRegistryProperties;

   /**
    * A {@link CloudJacksonJson} instance.
    */
   public static final CloudJacksonJson JACKSON_JSON = new CloudJacksonJson();

   @Bean
   public HasFeatures eurekaServerFeature() {
      return HasFeatures.namedFeature("Eureka Server",
            EurekaServerAutoConfiguration.class);
   }
   
   // 加载EurekaController，SpringCloud提供了一些接口来获取EurekaServer的信息
   @Bean
   @ConditionalOnProperty(prefix = "eureka.dashboard", name = "enabled",
         matchIfMissing = true)
   public EurekaController eurekaController() {
      return new EurekaController(this.applicationInfoManager);
   }

   static {
      CodecWrappers.registerWrapper(JACKSON_JSON);
      EurekaJacksonCodec.setInstance(JACKSON_JSON.getCodec());
   }

   @Bean
   public ServerCodecs serverCodecs() {
      return new CloudServerCodecs(this.eurekaServerConfig);
   }

   private static CodecWrapper getFullJson(EurekaServerConfig serverConfig) {
      CodecWrapper codec = CodecWrappers.getCodec(serverConfig.getJsonCodecName());
      return codec == null ? CodecWrappers.getCodec(JACKSON_JSON.codecName()) : codec;
   }

   private static CodecWrapper getFullXml(EurekaServerConfig serverConfig) {
      CodecWrapper codec = CodecWrappers.getCodec(serverConfig.getXmlCodecName());
      return codec == null ? CodecWrappers.getCodec(CodecWrappers.XStreamXml.class)
            : codec;
   }

   @Bean
   @ConditionalOnMissingBean
   public ReplicationClientAdditionalFilters replicationClientAdditionalFilters() {
      return new ReplicationClientAdditionalFilters(Collections.emptySet());
   }

   // 初始化集群注册表
   @Bean
   public PeerAwareInstanceRegistry peerAwareInstanceRegistry(
         ServerCodecs serverCodecs) {
      this.eurekaClient.getApplications(); // force initialization
      return new InstanceRegistry(this.eurekaServerConfig, this.eurekaClientConfig,
            serverCodecs, this.eurekaClient,
            this.instanceRegistryProperties.getExpectedNumberOfClientsSendingRenews(),
            this.instanceRegistryProperties.getDefaultOpenForTrafficCount());
   }

   // 初始化Eureka节点
   @Bean
   @ConditionalOnMissingBean
   public PeerEurekaNodes peerEurekaNodes(PeerAwareInstanceRegistry registry,
         ServerCodecs serverCodecs,
         ReplicationClientAdditionalFilters replicationClientAdditionalFilters) {
      return new RefreshablePeerEurekaNodes(registry, this.eurekaServerConfig,
            this.eurekaClientConfig, serverCodecs, this.applicationInfoManager,
            replicationClientAdditionalFilters);
   }
   
   
   // Eureka 上下文
   @Bean
	@ConditionalOnMissingBean
	public EurekaServerContext eurekaServerContext(ServerCodecs serverCodecs,
			PeerAwareInstanceRegistry registry, PeerEurekaNodes peerEurekaNodes) {
		return new DefaultEurekaServerContext(this.eurekaServerConfig, serverCodecs,
				registry, peerEurekaNodes, this.applicationInfoManager);
	}

    // EurekaServer 启动器
	@Bean
	public EurekaServerBootstrap eurekaServerBootstrap(PeerAwareInstanceRegistry registry,
			EurekaServerContext serverContext) {
		return new EurekaServerBootstrap(this.applicationInfoManager,
				this.eurekaClientConfig, this.eurekaServerConfig, registry,
				serverContext);
	}

	/**
	 * Register the Jersey filter.
	 * @param eurekaJerseyApp an {@link Application} for the filter to be registered
	 * @return a jersey {@link FilterRegistrationBean}
	 */
    //  jersey拦截器，ServletContainer里面实现了jersey框架，通过他来实现eurekaServer对外的restFull接口
	@Bean
	public FilterRegistrationBean<?> jerseyFilterRegistration(
			javax.ws.rs.core.Application eurekaJerseyApp) {
		FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<Filter>();
		bean.setFilter(new ServletContainer(eurekaJerseyApp));
		bean.setOrder(Ordered.LOWEST_PRECEDENCE);
		bean.setUrlPatterns(
				Collections.singletonList(EurekaConstants.DEFAULT_PREFIX + "/*"));

		return bean;
	}

	/**
	 * Construct a Jersey {@link javax.ws.rs.core.Application} with all the resources
	 * required by the Eureka server.
	 * @param environment an {@link Environment} instance to retrieve classpath resources
	 * @param resourceLoader a {@link ResourceLoader} instance to get classloader from
	 * @return created {@link Application} object
	 */
    // 构造Jersey应用实例
	@Bean
	public javax.ws.rs.core.Application jerseyApplication(Environment environment,
			ResourceLoader resourceLoader) {

		ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(
				false, environment);

		// Filter to include only classes that have a particular annotation.
		//
		provider.addIncludeFilter(new AnnotationTypeFilter(Path.class));
		provider.addIncludeFilter(new AnnotationTypeFilter(Provider.class));

		// Find classes in Eureka packages (or subpackages)
		//
		Set<Class<?>> classes = new HashSet<>();
		for (String basePackage : EUREKA_PACKAGES) {
			Set<BeanDefinition> beans = provider.findCandidateComponents(basePackage);
			for (BeanDefinition bd : beans) {
				Class<?> cls = ClassUtils.resolveClassName(bd.getBeanClassName(),
						resourceLoader.getClassLoader());
				classes.add(cls);
			}
		}

		// Construct the Jersey ResourceConfig
		Map<String, Object> propsAndFeatures = new HashMap<>();
		propsAndFeatures.put(
				// Skip static content used by the webapp
				ServletContainer.PROPERTY_WEB_PAGE_CONTENT_REGEX,
				EurekaConstants.DEFAULT_PREFIX + "/(fonts|images|css|js)/.*");

		DefaultResourceConfig rc = new DefaultResourceConfig(classes);
		rc.setPropertiesAndFeatures(propsAndFeatures);

		return rc;
	}

@Configuration(proxyBeanMethods = false)
public class EurekaServerInitializerConfiguration
      implements ServletContextAware, SmartLifecycle, Ordered {

   private static final Log log = LogFactory
         .getLog(EurekaServerInitializerConfiguration.class);

   @Autowired
   private EurekaServerConfig eurekaServerConfig;

   private ServletContext servletContext;

   @Autowired
   private ApplicationContext applicationContext;

   @Autowired
   private EurekaServerBootstrap eurekaServerBootstrap;

   private boolean running;

   private int order = 1;

   @Override
   public void setServletContext(ServletContext servletContext) {
      this.servletContext = servletContext;
   }

   @Override
   public void start() {
      // 启动一个线程，由于这个配置类实现了SmartLifecycle接口，所以之后会回调这个start()方法
      new Thread(() -> {
         try {
            // TODO: is this class even needed now?
            // 上下文初始化
            eurekaServerBootstrap.contextInitialized(
                  EurekaServerInitializerConfiguration.this.servletContext);
            log.info("Started Eureka Server");

            publish(new EurekaRegistryAvailableEvent(getEurekaServerConfig()));
            EurekaServerInitializerConfiguration.this.running = true;
            publish(new EurekaServerStartedEvent(getEurekaServerConfig()));
         }
         catch (Exception ex) {
            // Help!
            log.error("Could not initialize Eureka servlet context", ex);
         }
      }).start();
   }

   private EurekaServerConfig getEurekaServerConfig() {
      return this.eurekaServerConfig;
   }

   private void publish(ApplicationEvent event) {
      this.applicationContext.publishEvent(event);
   }

   @Override
   public void stop() {
      this.running = false;
      eurekaServerBootstrap.contextDestroyed(this.servletContext);
   }

   @Override
   public boolean isRunning() {
      return this.running;
   }

   @Override
   public int getPhase() {
      return 0;
   }

   @Override
   public boolean isAutoStartup() {
      return true;
   }

   @Override
   public void stop(Runnable callback) {
      callback.run();
   }

   @Override
   public int getOrder() {
      return this.order;
   }

}

EurekaServerBootstrap的contextInitialized方法：

public void contextInitialized(ServletContext context) {
   try {
      // 初始化Eureka环境
      initEurekaEnvironment();
      // 初始化EurekaServer上下文
      initEurekaServerContext();

      context.setAttribute(EurekaServerContext.class.getName(), this.serverContext);
   }
   catch (Throwable e) {
      log.error("Cannot bootstrap eureka server :", e);
      throw new RuntimeException("Cannot bootstrap eureka server :", e);
   }
}



protected void initEurekaServerContext() throws Exception {
		// For backward compatibility
		JsonXStream.getInstance().registerConverter(new V1AwareInstanceInfoConverter(),
				XStream.PRIORITY_VERY_HIGH);
		XmlXStream.getInstance().registerConverter(new V1AwareInstanceInfoConverter(),
				XStream.PRIORITY_VERY_HIGH);

		if (isAws(this.applicationInfoManager.getInfo())) {
			this.awsBinder = new AwsBinderDelegate(this.eurekaServerConfig,
					this.eurekaClientConfig, this.registry, this.applicationInfoManager);
			this.awsBinder.start();
		}

		EurekaServerContextHolder.initialize(this.serverContext);

		log.info("Initialized server context");

		// Copy registry from neighboring eureka node
    	// 从相邻节点复制全量的注册表
		int registryCount = this.registry.syncUp();
    	// 默认每30秒发送心跳，1分钟就是2次 
        // 修改eureka状态为up，同时，这里面会开启一个定时任务，用于清理60秒没有心跳的客户端。自动下线
		this.registry.openForTraffic(this.applicationInfoManager, registryCount);

		// Register all monitoring statistics.
		EurekaMonitors.registerAllStats();
	}

registry.syncUp()方法：

Override
public int syncUp() {
    // Copy entire entry from neighboring DS node
    int count = 0;

    for (int i = 0; ((i < serverConfig.getRegistrySyncRetries()) && (count == 0)); i++) {
        if (i > 0) {
            try {
                Thread.sleep(serverConfig.getRegistrySyncRetryWaitMs());
            } catch (InterruptedException e) {
                logger.warn("Interrupted during registry transfer..");
                break;
            }
        }
        Applications apps = eurekaClient.getApplications();
        for (Application app : apps.getRegisteredApplications()) {
            for (InstanceInfo instance : app.getInstances()) {
                try {
                    if (isRegisterable(instance)) {
                        // 将其他节点信息注册到本节点
                        register(instance, instance.getLeaseInfo().getDurationInSecs(), true);
                        count++;
                    }
                } catch (Throwable t) {
                    logger.error("During DS init copy", t);
                }
            }
        }
    }
    return count;
}

register()方法：

public void register(InstanceInfo registrant, int leaseDuration, boolean isReplication) {
    // 读锁
    read.lock();
    try {
        Map<String, Lease<InstanceInfo>> gMap = registry.get(registrant.getAppName());
        REGISTER.increment(isReplication);
        if (gMap == null) {
            final ConcurrentHashMap<String, Lease<InstanceInfo>> gNewMap = new ConcurrentHashMap<String, Lease<InstanceInfo>>();
            gMap = registry.putIfAbsent(registrant.getAppName(), gNewMap);
            if (gMap == null) {
                gMap = gNewMap;
            }
        }
        Lease<InstanceInfo> existingLease = gMap.get(registrant.getId());
        // Retain the last dirty timestamp without overwriting it, if there is already a lease
        if (existingLease != null && (existingLease.getHolder() != null)) {
            Long existingLastDirtyTimestamp = existingLease.getHolder().getLastDirtyTimestamp();
            Long registrationLastDirtyTimestamp = registrant.getLastDirtyTimestamp();
            logger.debug("Existing lease found (existing={}, provided={}", existingLastDirtyTimestamp, registrationLastDirtyTimestamp);

            // this is a > instead of a >= because if the timestamps are equal, we still take the remote transmitted
            // InstanceInfo instead of the server local copy.
            if (existingLastDirtyTimestamp > registrationLastDirtyTimestamp) {
                logger.warn("There is an existing lease and the existing lease's dirty timestamp {} is greater" +
                        " than the one that is being registered {}", existingLastDirtyTimestamp, registrationLastDirtyTimestamp);
                logger.warn("Using the existing instanceInfo instead of the new instanceInfo as the registrant");
                registrant = existingLease.getHolder();
            }
        } else {
            // The lease does not exist and hence it is a new registration
            synchronized (lock) {
                if (this.expectedNumberOfClientsSendingRenews > 0) {
                    // Since the client wants to register it, increase the number of clients sending renews
                    this.expectedNumberOfClientsSendingRenews = this.expectedNumberOfClientsSendingRenews + 1;
                    // 更新续约阈值 计算方法为预期续约的客户端数*（60/预期客户端续约时间间隔）*续约比例的阈值
                    updateRenewsPerMinThreshold();
                }
            }
            logger.debug("No previous lease information found; it is new registration");
        }
        Lease<InstanceInfo> lease = new Lease<InstanceInfo>(registrant, leaseDuration);
        if (existingLease != null) {
            lease.setServiceUpTimestamp(existingLease.getServiceUpTimestamp());
        }
        gMap.put(registrant.getId(), lease);
        recentRegisteredQueue.add(new Pair<Long, String>(
                System.currentTimeMillis(),
                registrant.getAppName() + "(" + registrant.getId() + ")"));
        // This is where the initial state transfer of overridden status happens
        if (!InstanceStatus.UNKNOWN.equals(registrant.getOverriddenStatus())) {
            logger.debug("Found overridden status {} for instance {}. Checking to see if needs to be add to the "
                            + "overrides", registrant.getOverriddenStatus(), registrant.getId());
            if (!overriddenInstanceStatusMap.containsKey(registrant.getId())) {
                logger.info("Not found overridden id {} and hence adding it", registrant.getId());
                overriddenInstanceStatusMap.put(registrant.getId(), registrant.getOverriddenStatus());
            }
        }
        InstanceStatus overriddenStatusFromMap = overriddenInstanceStatusMap.get(registrant.getId());
        if (overriddenStatusFromMap != null) {
            logger.info("Storing overridden status {} from map", overriddenStatusFromMap);
            registrant.setOverriddenStatus(overriddenStatusFromMap);
        }

        // Set the status based on the overridden status rules
        InstanceStatus overriddenInstanceStatus = getOverriddenInstanceStatus(registrant, existingLease, isReplication);
        registrant.setStatusWithoutDirty(overriddenInstanceStatus);

        // If the lease is registered with UP status, set lease service up timestamp
        if (InstanceStatus.UP.equals(registrant.getStatus())) {
            lease.serviceUp();
        }
        registrant.setActionType(ActionType.ADDED);
        recentlyChangedQueue.add(new RecentlyChangedItem(lease));
        registrant.setLastUpdatedTimestamp();
        //将缓存过期
        invalidateCache(registrant.getAppName(), registrant.getVIPAddress(), registrant.getSecureVipAddress());
        logger.info("Registered instance {}/{} with status {} (replication={})",
                registrant.getAppName(), registrant.getId(), registrant.getStatus(), isReplication);
    } finally {
        read.unlock();
    }
}

openForTraffic()方法

@Override
public void openForTraffic(ApplicationInfoManager applicationInfoManager, int count) {
    // Renewals happen every 30 seconds and for a minute it should be a factor of 2.
    // 每30秒更新一次
    this.expectedNumberOfClientsSendingRenews = count;
    // 每分钟最小续约数
    updateRenewsPerMinThreshold();
    logger.info("Got {} instances from neighboring DS node", count);
    logger.info("Renew threshold is: {}", numberOfRenewsPerMinThreshold);
    this.startupTime = System.currentTimeMillis();
    if (count > 0) {
        this.peerInstancesTransferEmptyOnStartup = false;
    }
    DataCenterInfo.Name selfName = applicationInfoManager.getInfo().getDataCenterInfo().getName();
    boolean isAws = Name.Amazon == selfName;
    if (isAws && serverConfig.shouldPrimeAwsReplicaConnections()) {
        logger.info("Priming AWS connections for all replicas..");
        primeAwsReplicas(applicationInfoManager);
    }
    logger.info("Changing status to UP");
    applicationInfoManager.setInstanceStatus(InstanceStatus.UP);
    // 开启定时任务，默认60秒一次
    super.postInit();
}

postInit()方法

protected void postInit() {
    // 服务剔除方法	
    renewsLastMin.start();
    if (evictionTaskRef.get() != null) {
        evictionTaskRef.get().cancel();
    }
    evictionTaskRef.set(new EvictionTask());
    evictionTimer.schedule(evictionTaskRef.get(),
            serverConfig.getEvictionIntervalTimerInMs(),
            serverConfig.getEvictionIntervalTimerInMs());
}

EurekaServerAutoConfiguration中有个eurekaServerContext方法，其中创建了一个DefaultEurekaServerContext对象，这个类中有个initialize()方法是被@PostConstruct注解修饰的，在应用加载时，会调用这个方法。

@PostConstruct
@Override
public void initialize() {
    logger.info("Initializing ...");
    // 启动一个线程的线程池第一次更新其他节点的信息，然后启动一个定时线程池，每60秒更新一次，也就是说后续可以根据配置动态的修改节点配置
    peerEurekaNodes.start();
    try {
        registry.init(peerEurekaNodes);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    logger.info("Initialized");
}

start()方法

public void start() {
    taskExecutor = Executors.newSingleThreadScheduledExecutor(
            new ThreadFactory() {
                @Override
                public Thread newThread(Runnable r) {
                    Thread thread = new Thread(r, "Eureka-PeerNodesUpdater");
                    thread.setDaemon(true);
                    return thread;
                }
            }
    );
    try {
        // 第一次进来，更新集群节点信息
        updatePeerEurekaNodes(resolvePeerUrls());
        Runnable peersUpdateTask = new Runnable() {
            @Override
            public void run() {
                try {
                    updatePeerEurekaNodes(resolvePeerUrls());
                } catch (Throwable e) {
                    logger.error("Cannot update the replica Nodes", e);
                }

            }
        };
        // 启动一个定时线程池，定时更新集群节点信息
        taskExecutor.scheduleWithFixedDelay(
                peersUpdateTask,
                serverConfig.getPeerEurekaNodesUpdateIntervalMs(),
                serverConfig.getPeerEurekaNodesUpdateIntervalMs(),
                TimeUnit.MILLISECONDS
        );
    } catch (Exception e) {
        throw new IllegalStateException(e);
    }
    for (PeerEurekaNode node : peerEurekaNodes) {
        logger.info("Replica node URL:  {}", node.getServiceUrl());
    }
}

// 通过URL创建PeerEurekaNode信息
protected PeerEurekaNode createPeerEurekaNode(String peerEurekaNodeUrl) {
        HttpReplicationClient replicationClient = JerseyReplicationClient.createReplicationClient(serverConfig, serverCodecs, peerEurekaNodeUrl);
        String targetHost = hostFromUrl(peerEurekaNodeUrl);
        if (targetHost == null) {
            targetHost = "host";
        }
        return new PeerEurekaNode(registry, targetHost, peerEurekaNodeUrl, replicationClient, serverConfig);
    }

五、总结

通过对Eureka Server端源码的解析，我们看到了Eureka是怎么整合到Spring中的，我们看到了Eureka Server初始化的过程和一系列的配置，下一回，我将对Eureka Client端源码进行解析，我们来看看Eureka是通过什么样的设计来实现AP和它自身的那些特性的。

wangjimmy1994
关注
专栏目录
springclound+springcloundAlibaba 入门全套源码
01-25
eureka consul zookeeper openfeign hygtrix gateway config-center stream-rabbitmq alibaba nacos sentinel seata 全套工程源码，POM文件，YML配置
spring clound注册中心搭建
12-05
在这个场景下，我们主要关注的是Spring Cloud Eureka，它是Spring Cloud生态中的一个组件，用于实现服务注册与发现。 Eureka是Netflix开源的一个基于REST的服务，它主要用于服务注册和服务发现。在微服务架构中，每...
SpringCloud的Eureka是怎么实现的？
qq_35599414的博客
05-30 217
666666
springcloud（2）-实现eureka
RoyRaoHR的博客
10-19 132
前言 eureka-server的创建相对简单，步骤如下 创建工程 导入eureka依赖 application配置eureka相关配置 启动类上注解开启eureka 实现 建立spring boot项目 pom依赖，主要为eureka服务端依赖 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netfli
SpringCloud的服务发现框架 — Eureka — 单机Eureka构建流程，以及服务注册功能实现
CSNZのBlog
06-28 233
了解 单机Eureka构建流程，以及服务注册功能实现
Spring Cloud Eureka 实现
harryptter的专栏
03-01 1743
之前项目中用到了spring cloud的一些服务，这里准备将spring cloud最常用的一些服务框架进行总结和实现。 框架大致的介绍在之前的文章里面已经有提及：什么是微服务 这里就从springcloud最开始搭建说起，也就是服务发现和注册，原生提供的就是Eureka服务端和客户端，之后由于zookeeper的流行，也提供你spring cloud zookeeper的实现方式，本文主要...
怎样搭建一个Eureka服务
suolun_的博客
06-12 447
首先我们新建一个maven的项目
spring clound netflix eureka与netflix eureka java客户端
06-13
简单来说，Spring Cloud Netflix Eureka是一个服务发现框架，而Netflix Eureka Java客户端是用于将服务注册到Eureka服务器的一个Java库。它们的作用不同，但是它们可以一起使用来构建一个分布式系统。
spring clound netflix eureka客户端与netflix eureka java客户端
最新发布
06-13
Spring Cloud Netflix Eureka客户端与Netflix Eureka Java客户端都是用于将服务注册到Eureka服务器上的库，但是它们的实现方式不同。 Spring Cloud Netflix Eureka客户端是在Spring Cloud框架中实现的，它提供了...
springboot整合springclound文档
11-06
以上内容详细介绍了Spring Boot 整合 Spring Cloud 的核心概念和技术实现细节，包括服务治理、服务发现与消费、Feign 模式的使用、熔断器Hystrix以及路由网关Zuul等多个方面，为开发人员提供了全面的指导。
feign以XML格式传输-技术点eureka-feign-jackson.zip
10-12
知识点：feign以XML格式传输，domain通过Jackson转成XML， 项目总体理解：此文档搭建了eureka注册中心，和生产者，以及feign消费者。feign消费者以XML格式传输数据
Spring Clound Eureka 的设计与实现（二）
wangjimmy1994的博客
05-16 251
一、背景 上一次我们分析了Eureka Server端的源码，这回，我们来分析Eureka Client端的源码，二话不说我们就开始 二、源码分析 首先通过springboot的自动配置原理，找到eureka-client的jar包下的spring.factories文件，找到了EurekaClientAutoConfiguration这个配置类，这个就是eureka-client的主配置类，接下来我们看到，这个配置类里主要就是配置类的Bean，我们看到EurekaClientAutoConfigurati
自己搭建一个简单的Eureka集群
weixin_41626852的博客
03-17 153
1.依赖，创建springboot项目是添加eureka-server即可 2.yaml 文件： server: port: 7070 # 这个在多个注册中心里命名是一样的 spring: application: name: my-eureka-server # 测试不配置的话,现象为在注册中心显示端口+ip,但是配置后，eureka.clientserverUrl.defaultZone即制定注册中心可以直接使用， # hostname设置一样，后缀改一下，不用去记住另一个服务的i
Eureka实现原理
风尘小白沙
07-28 482
Eureka服务集群以及原理 服务注册 提供服务ip地址，端点等各项服务发现基本信息 服务取消 客户端连续一段时间没有向Eureka服务端发送服务续约消息，就会将其从服务列表剔除 Eureka服务存储和缓存 在Eureka,InstanceRegistry接口及其实现类实现这部分职能 private final ConcurrentHashMap<String, Map<String, Lease<InstanceInfo>>> registry = new Conc
SpringCloud实现一个Eureka Server
sz_bdqn的专栏
07-09 243
使用Eureka做服务发现.
spring-cloud-starter-eureka中的jackson-dataformat-xml返回xml
TrayLei的博客
07-14 423
不善言辞，直接上图 导入spring-cloud-starter-eureka包时，里面有个包 导致这样写 返回的数据时时xml格式的 解决方法 在spring-cloud-starter-eureka引用里面添加 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-eureka</ar
SpringCloud之Eureka的报错（版本神坑）
weixin_43920711的博客
09-12 3370
一、报错内容 2021-09-12 14:47:53.594 INFO 20640 --- [freshExecutor-0] com.netflix.discovery.DiscoveryClient : Disable delta property : false 2021-09-12 14:47:53.594 INFO 20640 --- [freshExecutor-0] com.netflix.discovery.DiscoveryClient : Single vip regis
java无效的指针错误_Springboot 注解无效，报空指针错误。
weixin_42509597的博客
02-28 729
有人说是springboot版本问题，我将springboot版本改成2.2.6之后，报错就变成了java.lang.IllegalStateException: Failed to load ApplicationContextat org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.load...
【踩坑日记】jackson依赖导入报错找不到类
热门推荐
qq_43685399的博客
04-12 1万+
jackson相关依赖导入问题
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值