系列文章目录

一.SpringCloud源码剖析-Eureka核心API

二.SpringCloud源码剖析-Eureka Client 初始化过程

三.SpringCloud源码剖析-Eureka服务注册

四.SpringCloud源码剖析-Eureka服务发现

五.SpringCloud源码剖析-Eureka Client服务续约

六.SpringCloud源码剖析-Eureka Client取消注册

七.SpringCloud源码剖析-Eureka Server的自动配置

八.SpringCloud源码剖析-Eureka Server初始化流程

九.SpringCloud源码剖析-Eureka Server服务注册流程

十.SpringCloud源码剖析-Eureka Server服务续约

十一.SpringCloud源码剖析-Eureka Server服务注册表拉取

十二.SpringCloud源码剖析-Eureka Server服务剔除

十三.SpringCloud源码剖析-Eureka Server服务下线

1.EureakServerAutoConfiguration的注册

这里和EureakClientAutoConfiguration差不多，都是由主启动类上的@SpringBootApplication标签中的@EnableAutoConfiguration启动自动配置，通过AutoConfigurationImportSelector来扫描classpath下的starter包中的自动配置类

@Target({
   
   ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration    //开启自动配置
@ComponentScan(
    excludeFilters = {
   
   @Filter(
    type = FilterType.CUSTOM,
    classes = {
   
   TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {
   
   AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
   
   

@EnableAutoConfiguration标签的源码

@Target({
   
   ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({
   
   AutoConfigurationImportSelector.class})    //自动配置选择器
public @interface EnableAutoConfiguration {
   
   
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {
   
   };

    String[] excludeName() default {
   
   };
}

AutoConfigurationImportSelector导入选择器源码

public class AutoConfigurationImportSelector
        implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware,
        BeanFactoryAware, EnvironmentAware, Ordered {
   
   

    ...省略部分代码...

    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
   
   
        if (!isEnabled(annotationMetadata)) {
   
   
            return NO_IMPORTS;
        }
        AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
                .loadMetadata(this.beanClassLoader);
        AnnotationAttributes attributes = getAttributes(annotationMetadata);
        //1.这里会扫描spring.factories文件中的配置
        List<String> configurations = getCandidateConfigurations(annotationMetadata,
                attributes);
        configurations = removeDuplicates(configurations);
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = filter(configurations, autoConfigurationMetadata);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        //2.加载一堆自动配置，其中就有 EureakServerAutoConfiguration 
        return StringUtils.toStringArray(configurations);
    }
    //获取候选的自动配置
    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
            AnnotationAttributes attributes) {
   
   
            //通过SpringFactoriesLoader加载spring.spring.factories中的配置类
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
                getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
        Assert.notEmpty(configurations,
                //从错误日志就可以看得出在扫描 META-INF/spring.factories
                "No auto configuration classes found in META-INF/spring.factories. If you "
                        + "are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

这里的 selectImports方法会通过getCandidateConfigurations方法使用SpringFactoriesLoader去加载classpath下的jar中的META-INF/spring.factories文件，该文件中有很多的自动配置，其中 EureakServerAutoConfiguration 就在spring-cloud-netflix-eureka-server-2.0.1.RELEASE.jar 中如下

2.EureakServerAutoConfiguration被加载的条件

在EureakServerAutoConfiguration自动配置类上有一个注册条件

/**
 * @author Gunnar Hillert
 * @author Biju Kunjummen
 * @author Fahim Farook
 */
@Configuration
//导入 EurekaServerInitializerConfiguration 对Eureak进行初始化
@Import(EurekaServerInitializerConfiguration.class)
//条件：EurekaServerMarkerConfiguration.Marker是通过@EnableEureakServer激活
@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)
//Eureka仪表盘界面配置，以及实例注册的配置
@EnableConfigurationProperties({
   
    EurekaDashboardProperties.class,
        InstanceRegistryProperties.class })
//加载server.properties 服务端配置文件
@PropertySource("classpath:/eureka/server.properties")
public class EurekaServerAutoConfiguration extends WebMvcConfigurerAdapter {
   
   

@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class) 这个条件是通过@EnableEureakServer开启，

/**
    激活 EurekaServerAutoConfiguration
 * Annotation to activate Eureka Server related configuration {@link EurekaServerAutoConfiguration}
 *
 * @author Dave Syer
 * @author Biju Kunjummen
 *
 */

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(EurekaServerMarkerConfiguration.class)
public @interface EnableEurekaServer {
   
   

}

EnableEurekaServer的注释写的很清楚，该注解用来激活EureakServerAutoConfiguration配置，通过@Import(EurekaServerMarkerConfiguration.class)来激活的

/**
 * Responsible for adding in a marker bean to activate
 * {@link EurekaServerAutoConfiguration}
 *
 * @author Biju Kunjummen
 */
@Configuration
public class EurekaServerMarkerConfiguration {
   
   

    @Bean
    public Marker eurekaServerMarkerBean() {
   
   
        return new Marker();
    }

    class Marker {
   
   
    }
}

看到这里就清楚了，EnableEurekaServer通过@Import(EurekaServerMarkerConfiguration.class)导入EurekaServerMarkerConfiguration.Marker,而在EureakServerAutoConfiguration配置类上正好有一个条件
@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)，满足这个条件，自动配置被加载，他们的加载关系如下：

3.EureakServerAutoConfiguration配置了什么？

EureakServerAutoConfiguration配置了那些东西？我们来看一下源码，哦~~~,特别说明一下，服务端的pom我用的是spring-cloud-starter-netflix-eureka-server，该依赖会把客户端的包spring-cloud-starter-netflix-eureka-client也导入进来(Eureka集群需要互相注册),所以你会看到下面的配置类中也会有eureka client的配置

/**
 * @author Gunnar Hillert
 * @author Biju Kunjummen
 * @author Fahim Farook
 */
@Configuration
//导入 EurekaServerInitializerConfiguration 对Eureak进行初始化
@Import(EurekaServerInitializerConfiguration.class)
//条件：EurekaServerMarkerConfiguration.Marker是通过@EnableEureakServer激活
@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)
//Eureka仪表盘界面配置，以及实例注册的配置
@EnableConfigurationProperties({
   
    EurekaDashboardProperties.class,
        InstanceRegistryProperties.class })
//加载server.properties 服务端配置文件
@PropertySource("classpath:/eureka/server.properties")
public class EurekaServerAutoConfiguration extends WebMvcConfigurerAdapter {
   
   
    /**
     * 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;
    //eureka server服务端配置对象加载 eureka.server 开头的配置项
    //里面记录了了EurekaServer所需要的配置
    @Autowired
    private EurekaServerConfig eurekaServerConfig;
    //eureka client 客户端配置对象 加载eureka.client开头的配置项
    @Autowired
    private EurekaClientConfig eurekaClientConfig;
    //Eureka客户端
    @Autowired
    private EurekaClient eurekaClient;
    //实例注册表属性配置，加载eureka.instance.registry开头的配置
    @Autowired
    private InstanceRegistryProperties instanceRegistryProperties;

    public static final CloudJacksonJson JACKSON_JSON = new CloudJacksonJson();

    @Bean
    public HasFeatures eurekaServerFeature() {
   
   
        return HasFeatures.namedFeature("Eureka Server",
                EurekaServerAutoConfiguration.class);
    }
    //配置EurekaServerConfig ，Eureka服务器配置，加载eureka.server开头配置
    @Configuration
    protected static class EurekaServerConfigBeanConfiguration {
   
   
        @Bean
        @ConditionalOnMissingBean
        public EurekaServerConfig eurekaServerConfig(EurekaClientConfig clientConfig) {
   
   
            EurekaServerConfigBean server = new EurekaServerConfigBean();
            //如果开启了eureka.client.registerWithEureka=true 注册到Eureka
            if (clientConfig.shouldRegisterWithEureka()) {
   
   
                // Set a sensible default if we are supposed to replicate
                //当eureka服务器启动时尝试去获取集群里其他服务器上的注册信息的次数，默认为5
                server.setRegistrySyncRetries(5);
            }
            return server;
        }
    }

    //定义Eureka Server dashboard仪表盘监控界面的端点,注册中心的监控界面就是在这里定义的默认是“/”
    @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;
    }

    class CloudServerCodecs extends DefaultServerCodecs {
   
   

        public CloudServerCodecs(EurekaServerConfig serverConfig) {
   
   
            super(getFullJson(serverConfig),
                    CodecWrappers.getCodec(CodecWrappers.JacksonJsonMini.class),
                    getFullXml(serverConfig),
                    CodecWrappers.getCodec(CodecWrappers.JacksonXmlMini.class));
        }
    }
    // 注册PeerAwareInstanceRegistry,应用对象注册表接口，提供了Eureka群内注册信息的同步功能。
    @Bean
    public PeerAwareInstanceRegistry peerAwareInstanceRegistry(
            ServerCodecs serverCodecs) {
   
   
            //客户端获取注册列表，强制初始化EurekaClient
        this.eurekaClient.getApplications(); // force initialization
        //创建实例注册器InstanceRegistry,继承了PeerAwareInstanceRegistry，PeerAwareInstanceRegistryimpl的实现

        return new InstanceRegistry(this.eurekaServerConfig, this.eurekaClientConfig,
                serverCodecs, this.eurekaClient,
                //期望最大每分钟续租次数
                this.instanceRegistryProperties.getExpectedNumberOfRenewsPerMin(),
                this.instanceRegistryProperties.getDefaultOpenForTrafficCount());
    }
    //PeerEurekaNode的工具类，用来管理PeerEurekaNode的生命周期,PeerEurekaNode表示集群中的一个节点
    @Bean
    @ConditionalOnMissingBean
    public PeerEurekaNodes peerEurekaNodes(PeerAwareInstanceRegistry registry,
            ServerCodecs serverCodecs) {
   
   
        return new RefreshablePeerEurekaNodes(registry, this.eurekaServerConfig,
                this.eurekaClientConfig, serverCodecs, this.applicationInfoManager);
    }

    /**
    //可刷新的集群节点，通过监听EnvironmentChangeEvent环境改变事件，如果特点的配置改变如：
    //eureka.client.region，eureka.client.service-url配置改变就刷新集群中的节点信息
     * {@link PeerEurekaNodes} which updates peers when /refresh is invoked.
     * Peers are updated only if
     * <code>eureka.client.use-dns-for-fetching-service-urls</code> is
     * <code>false</code> and one of following properties have changed.
     * </p>
     * <ul>
     * <li><code>eureka.client.availability-zones</code></li>
     * <li><code>eureka.client.region</code></li>
     * <li><code>eureka.client.service-url.&lt;zone&gt;</code></li>
     * </ul>
     */
    static class RefreshablePeerEurekaNodes extends PeerEurekaNodes
            implements ApplicationListener<EnvironmentChangeEvent> {
   
   

        public RefreshablePeerEurekaNodes(
                final PeerAwareInstanceRegistry registry,
                final EurekaServerConfig serverConfig,
                final EurekaClientConfig clientConfig, 
                final ServerCodecs serverCodecs,
                final ApplicationInfoManager applicationInfoManager) {
   
   
            super(registry, serverConfig, clientConfig, serverCodecs, applicationInfoManager);
        }
        //监听事件
        @Override
        public void onApplicationEvent(final EnvironmentChangeEvent event) {
   
   
            //如果配置发生改变
            if (shouldUpdate(event.getKeys())) {
   
   
                //更新集群中的节点，通过删除旧的不可用的PeerEurekaNode，创建新的副本
                updatePeerEurekaNodes(resolvePeerUrls());
            }
        }

        /*
            检查是否需要更新节点，检查特点的配置是否有改变
         * Check whether specific properties have changed.
         */
        protected boolean shouldUpdate(final Set<String> changedKeys) {
   
   
            assert changedKeys != null;

            // if eureka.client.use-dns-for-fetching-service-urls is true, then
            // service-url will not be fetched from environment.
            if (clientConfig.shouldUseDnsForFetchingServiceUrls()) {
   
   
                return false;
            }

            if (changedKeys.contains("eureka.client.region")) {
   
   
                return true;
            }

            for (final String key : changedKeys) {
   
   
                // property keys are not expected to be null.
                if (key.startsWith("eureka.client.service-url.") ||
                    key.startsWith("eureka.client.availability-zones.")) {
   
   
                    return true;
                }
            }

            return false;
        }
    }
    //EurekaServer的上下文对象
    @Bean
    public EurekaServerContext eurekaServerContext(ServerCodecs serverCodecs,
            PeerAwareInstanceRegistry registry, PeerEurekaNodes peerEurekaNodes) {
   
   
        return new DefaultEurekaServerContext(this.eurekaServerConfig, serverCodecs,
                registry, peerEurekaNodes, this.applicationInfoManager);
    }
    //EurekaServerBootstrap  :EurekaServer的启动引导
    @Bean
    public EurekaServerBootstrap eurekaServerBootstrap(PeerAwareInstanceRegistry registry,
            EurekaServerContext serverContext) {
   
   
        return new EurekaServerBootstrap(this.applicationInfoManager,
                this.eurekaClientConfig, this.eurekaServerConfig, registry,
                serverContext);
    }

    /**
    注册 Jersey filter ,通过ServletContainer处理/eureka/*请求
     * Register the Jersey filter
     */
    @Bean
    public FilterRegistrationBean jerseyFilterRegistration(
            javax.ws.rs.core.Application eurekaJerseyApp) {
   
   
        FilterRegistrationBean bean = new FilterRegistrationBean();
        //使用ServletContainer处理
        bean.setFilter(new ServletContainer(eurekaJerseyApp));
        bean.setOrder(Ordered.LOWEST_PRECEDENCE);
        //filter的拦截url   /eureka/*
        bean.setUrlPatterns(
                Collections.singletonList(EurekaConstants.DEFAULT_PREFIX + "/*"));

        return bean;
    }

    /**
    创建用Eureka服务器所需的所有资源,构建Jersey {@link javax.ws.rs.core.Application}。
     * Construct a Jersey {@link javax.ws.rs.core.Application} with all the resources
     * required by the Eureka server.
     */
    @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;
    }

    @Bean
    public FilterRegistrationBean traceFilterRegistration(
            @Qualifier("httpTraceFilter") Filter filter) {
   
   
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(filter);
        bean.setOrder(Ordered.LOWEST_PRECEDENCE - 10);
        return bean;
    }
}

我们来归纳一下EurekaServerAutoConfiguration 配置了那些东西

• @Import(EurekaServerInitializerConfiguration.class)：导入了EurekaServer初始化配置
• @ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)：这个是配置起效的条件，通过@EnableEurekaServer开启该条件
• EurekaDashboardProperties.class：仪表盘配置
• InstanceRegistryProperties.class ：以 eureka.instance.registry开头的服务注册配置

• @PropertySource("classpath:/eureka/server.properties")：加载server.properties配置文件

• 注册了EurekaServerConfig：Eureka服务端配置对象，eureka服务器运行所需的配置信息，实现由两个一个是EurekaServerConfigBean是netflix的实现，一个是DefaultEurekaServerConfig是Eureka的实现

• 注册了EurekaController：仪表盘端点controller，默认的路径是“/”
• 注册了PeerAwareInstanceRegistry应用对象注册接口，提供了eureka集群间的服务同步功能及相关操作
• 注册了PeerEurekaNodes：集群节点PeerEurekaNode的管理类，
• 注册了EurekaServerContext ：EurekaServer的上下文对象默认实现DefaultEurekaServerContext，提供了initialize初始化和shutdown关闭方法。
• 注册了EurekaServerBootstrap 服务端启动引导，EurekaServer启动的关键
• 注册了jersey Filter：使用ServletContainer实现功能，用来处理/eureka的请求

总结

1. SpringBoot自动配置加载EurekaServerAutoConfiguration自动配置
2. @EnableEurekaServer导入EurekaServerMarkerConfiguration.marker激活EurekaServerAutoConfiguration自动配置
3. EurekaServerAutoConfiguration注册了一系列组件，比较重要的有EurekaServerInitializerConfiguration初始化EurekaServer配置，PeerAwareInstanceRegistry服务注册器，PeerEurekaNodes服务节PeerEurekaNode点生命周期管理工具，EurekaServerContext服务上下文，EurekaServerBootstrap EurekaServer的启动引导等等

在下一章节我们将来研究一下EurekaServer的初始化的详细过程