Spring Eureka server启动过程

1spring boot 注解：@Configuration @Bean @Import @ConditionalOnBean

1.1 @Configuration @Bean

configuration 注解相当于xml配置中的标签，其内部可以声明多个Bean标签，每个Bean标签对应一个注册到spring 容器的实例。
Configuration注解的类本身也是一个bean，可以进行Autowired进行注入。
Bean可以定义声明周期，把bean的方法和生命周期绑定。

1.2 import

import注解可以用于class，也可以作用于注解class。主要作用就是将类导入spring的容器。
有三种方式可以选择：直接导入类（@Import），导入类的定义（@Import(ImportBeanDefinitionRegistrar的实现 .class)）,选择性导入类的实现类（@Import（ImportSelector的实现.class））
直接导入类，直接实例化import声明的类，并放入spring容器中。
导入类的定义，需要用户自己实现ImportBeanDefinitionRegistrar接口。实现类中给出需要加载的类的定义，并将定义注册到spring容器。
选择性导入类的实现类，需要用户实现ImportSelector。实现类中自己判断需要加载哪些类，并返回这些类的全名（class.getName()）。

1.3 ConditionalOnBean

选择性加载被注释的类。注解中给出一个class，如果这个class在容器中有定义，那么就满足条件；如果没有，就不满足条件，被ConditionalOnBean注释的类就不会加载。

2 @SpringBootApplication启动

springbootapplication的定义：

@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 {
}

其中包含了包扫描的定义，所以工程里面的所有class都会被扫描到，这也是之后配置起作用的一个点。

3 Eureka启动@EnableEurekaServer

我们在启动的main函数中，需要如此配置：

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

@EnableEurekaServer包含了所有的Eureka Server启动配置。
但是在EnableEurekaServer的注解声明中，没有看到任何初始化bean定义：

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

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

但是在EurekaServerMarkerConfiguration的配置中，定义了一个空的类并进行了实例化。按照这个类的探索，发现其实以上都是一个开关，真正的配置都在EurekaServerAutoConfiguration中实现。

@Configuration
@Import(EurekaServerInitializerConfiguration.class)
@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)
@EnableConfigurationProperties({ EurekaDashboardProperties.class,
             InstanceRegistryProperties.class })
@PropertySource("classpath:/eureka/server.properties")
public class EurekaServerAutoConfiguration extends WebMvcConfigurerAdapter {
}


@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"})
public class EurekaClientAutoConfiguration {
}

总结来说，过程是：配置@EnableEurekaServer-@Import-》EurekaServerMarkerConfiguration-创建Marker实例-》扫描到EurekaServerAutoConfiguration时，@ConditionalOnBean满足加载条件，进行加载。

4 Spring cloud Eureka启动

4.1 Eureka 启动

在不集成Spring Cloud时，Eureka的启动接口为com.netflix.eureka.EurekaBootStrap。EurekaBootStrap实现了javax.servlet.ServletContextListener，并在contextInitialized函数中初始化Eureka的参数和服务启动。
Eureka 需要启动server以及一个client。client用于同步cluster的信息。

 /**
     * Initializes Eureka, including syncing up with other Eureka peers and  publishing the registry.
     *
     * @see
     *  javax.servlet.ServletContextListener#contextInitialized(javax.servlet.ServletContextEvent)
     */
    @Override
    public void contextInitialized(ServletContextEvent event) {
        try {
            initEurekaEnvironment();//配置信息
            initEurekaServerContext();//服务启动
            ServletContext sc = event.getServletContext();
            sc.setAttribute(EurekaServerContext.class.getName(), serverContext);
        } catch (Throwable e) {
            logger.error("Cannot bootstrap eureka server :", e);
            throw new RuntimeException("Cannot bootstrap eureka server :", e);
        }
    }

4.2 Spring Cloud集成

Spring Cloud 启动Eureka的过程：
EurekaServerInitializerConfiguration 实现了SmartLifecycle.start方法，在spring 初始化的时候，会调用。

@Override
       public void start() {
             new Thread(new Runnable() {
                    @Override
                    public void run() {
                           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();
       }

eurekaServerBootstrap是spring cloud定义的类，其代码完全拷贝了Eureka启动类的实现。
这里看到，在Eureka启动后，会向外发送EurekaRegistryAvailableEvent和EurekaServerStartedEvent。但是在源码里没有发现这两个事件的处理类。臆测，应该是留给开发者的接口。