Spring Cloud Eureka源码解析之Eureka Server启动流程（一）-蒲公英云

通过在启动类上添加@EnableEurekaServer注解启用EurekaServer

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

该注解引入了一个配置类EurekaServerMarkerConfiguration

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

看到就只建了一个空类，暂时不清楚干嘛用的，注解只能分析到这，接着看自动装配类
在这里插入图片描述
只有一个EurekaServerAutoConfiguration类

@Configuration
@Import(EurekaServerInitializerConfiguration.class)
@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)
@EnableConfigurationProperties({  EurekaDashboardProperties.class,
        InstanceRegistryProperties.class })
@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;
    @Autowired
    private EurekaServerConfig eurekaServerConfig;
    @Autowired
    private EurekaClientConfig eurekaClientConfig;
    @Autowired
    private EurekaClient eurekaClient;
    @Autowired
    private InstanceRegistryProperties instanceRegistryProperties;
    public static final CloudJacksonJson JACKSON_JSON = new CloudJacksonJson();
}

先看类上的注解
引入EurekaServerInitializerConfiguration类

@Configuration
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() { 
        new Thread(new Runnable() { 
            @Override
            public void run() { 
                try { 
                    // 初始化
                    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();
    }
    @Override
    public void stop() { 
        this.running = false;
        eurekaServerBootstrap.contextDestroyed(this.servletContext);
    }
    // 省略。。。
}

该类实现了SmartLifecycle接口，说明在spring容器启动时会调用实现类的start方法
看下初始化方法

public void contextInitialized(ServletContext context) { 
    try { 
        // 初始化eureka环境
        initEurekaEnvironment();
        // 初始化eureka server上下文
        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);
    }
}

初始化eureka server上下文

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");
    // 同步Eureka集群数据，从相邻的eureka节点复制注册表，registryCount是复制过来的实例数
    int registryCount = this.registry.syncUp();
    // 定期剔除租约过期实例的定时任务就是在这里开启的
    this.registry.openForTraffic(this.applicationInfoManager, registryCount);
    // Register all monitoring statistics.
    EurekaMonitors.registerAllStats();
}

@ConditionalOnBean({Marker.class})
这里就看到前面@EnableEurekaServer注解的作用了，只有标注了该注解，该配置类才会执行，EurekaServer才会启动
@EnableConfigurationProperties({ EurekaDashboardProperties.class, InstanceRegistryProperties.class })
这个是引入两个类

@ConfigurationProperties("eureka.dashboard")
public class EurekaDashboardProperties { 
    /** * 控制台默认路径 */
    private String path = "/";
    /** * 是否开启控制台，默认是开启 */
    private boolean enabled = true;
    // setter getter...
}

EurekaDashboardProperties就是两个关于控制台的配置

@ConfigurationProperties(PREFIX)
public class InstanceRegistryProperties { 
    public static final String PREFIX = "eureka.instance.registry";
    /* 期望的每分钟续约次数，默认是1 */
    @Value("${eureka.server.expectedNumberOfRenewsPerMin:1}") // for backwards compatibility
    private int expectedNumberOfRenewsPerMin = 1;
    /** 默认打开的通信数量，默认1 */
    @Value("${eureka.server.defaultOpenForTrafficCount:1}") // for backwards compatibility
    private int defaultOpenForTrafficCount = 1;
    // setter/getter...
}

InstanceRegistryProperties就是关于服务注册的配置
@PropertySource(“classpath:/eureka/server.properties”)
在这里插入图片描述
只是一个配置

现在看看类中创建的几个bean
创建EurekaServer配置bean，包含了EurekaServer的默认属性配置

@Configuration
protected static class EurekaServerConfigBeanConfiguration { 
    @Bean
    @ConditionalOnMissingBean
    public EurekaServerConfig eurekaServerConfig(EurekaClientConfig clientConfig) { 
        EurekaServerConfigBean server = new EurekaServerConfigBean();
        // 是否注册到集群中的其它server上
        if (clientConfig.shouldRegisterWithEureka()) { 
            // Set a sensible default if we are supposed to replicate
            server.setRegistrySyncRetries(5);
        }
        return server;
    }
}

控制台的Controller

@Bean
@ConditionalOnProperty(prefix = "eureka.dashboard", name = "enabled", matchIfMissing = true)
public EurekaController eurekaController() { 
    return new EurekaController(this.applicationInfoManager);
}

设置Eureka的序列化工具

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

创建EurekaServerBootstrap，上面初始化时用到该类

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

创建jersey相关类，注册一个过滤器，跟接收客户端请求有关

@Bean
public FilterRegistrationBean jerseyFilterRegistration(
    javax.ws.rs.core.Application eurekaJerseyApp) { 
    FilterRegistrationBean bean = new FilterRegistrationBean();
    // 设置过滤器
    bean.setFilter(new ServletContainer(eurekaJerseyApp));
    bean.setOrder(Ordered.LOWEST_PRECEDENCE);
    // 设置拦截路径，这里是/eureka/*
    bean.setUrlPatterns(
        Collections.singletonList(EurekaConstants.DEFAULT_PREFIX + "/*"));
    return bean;
}
@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;
}

jerseyApplication 方法，在容器中存放了一个jerseyApplication对象，jerseyApplication()方法里的东西和Spring源码里扫描@Component逻辑类似，扫描@Path和@Provider标签，然后封装成beandefinition，封装到Application的set容器里。通过filter过滤器来过滤url进行映射到对象的Controller