Spring Cloud Eureka源码解析之Eureka Server启动流程（一）

╰半夏微凉° 2022-09-16 04:52 142阅读 0赞

通过在启动类上添加@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 { 
    	}
    }

看到就只建了一个空类，暂时不清楚干嘛用的，注解只能分析到这，接着看自动装配类  
![在这里插入图片描述][b2e99d8046f9e107f70e0501685f821f.png_pic_center]  
只有一个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”)**  
![在这里插入图片描述][92534bb2615b713b913df4fe934244e5.png_pic_center]  
只是一个配置

现在看看类中创建的几个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

[b2e99d8046f9e107f70e0501685f821f.png_pic_center]: /images/20220828/65ed0453dc7644e2bc661d633fe881b2.png
[92534bb2615b713b913df4fe934244e5.png_pic_center]: /images/20220828/e1bc8a4556764cf5817b91d305fcf62f.png