@BeforeClass
public static void setUp() throws Exception {
    // 注入一些Eureka配置数据（这是为了测试而mock的配置）
    injectEurekaConfiguration();
    // 启动服务
    startServer();
    createEurekaServerConfig();

    httpClientFactory = JerseyEurekaHttpClientFactory.newBuilder()
            .withClientName("testEurekaClient")
            .withConnectionTimeout(1000)
            .withReadTimeout(1000)
            .withMaxConnectionsPerHost(1)
            .withMaxTotalConnections(1)
            .withConnectionIdleTimeout(1000)
            .build();

    jerseyEurekaClient = httpClientFactory.newClient(new DefaultEndpoint(eurekaServiceUrl));

    ServerCodecs serverCodecs = new DefaultServerCodecs(eurekaServerConfig);
    jerseyReplicationClient = JerseyReplicationClient.createReplicationClient(
            eurekaServerConfig,
            serverCodecs,
            eurekaServiceUrl
    );
}

private static void startServer() throws Exception {
    // 找到本地打好的Eureka server的war包
    File warFile = findWar();
  // 启动一个jetty server用于测试
    server = new Server(8080);
  // 设置jetty的一些配置，比如webapp上下文之类的东西
    WebAppContext webapp = new WebAppContext();
    webapp.setContextPath("/");
    webapp.setWar(warFile.getAbsolutePath());
    server.setHandler(webapp);

    // 启动jetty
    server.start();

    eurekaServiceUrl = "http://localhost:8080/v2";
}

public class EurekaBootStrap implements ServletContextListener {
  @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);
        }
    }
    
        @Override
    public void contextDestroyed(ServletContextEvent event) {
        try {
            logger.info("{} Shutting down Eureka Server..", new Date());
            ServletContext sc = event.getServletContext();
            sc.removeAttribute(EurekaServerContext.class.getName());

            destroyEurekaServerContext();
            destroyEurekaEnvironment();

        } catch (Throwable e) {
            logger.error("Error shutting down eureka", e);
        }
        logger.info("{} Eureka Service is now shutdown...", new Date());
    }
}

protected void initEurekaEnvironment() throws Exception {
    String dataCenter = ConfigurationManager.getConfigInstance().getString(EUREKA_DATACENTER);
    if (dataCenter == null) {
        ConfigurationManager.getConfigInstance().setProperty(ARCHAIUS_DEPLOYMENT_DATACENTER, DEFAULT);
    } else {
        ConfigurationManager.getConfigInstance().setProperty(ARCHAIUS_DEPLOYMENT_DATACENTER, dataCenter);
    }
    
    String environment = ConfigurationManager.getConfigInstance().getString(EUREKA_ENVIRONMENT);
    if (environment == null) {
        ConfigurationManager.getConfigInstance().setProperty(ARCHAIUS_DEPLOYMENT_ENVIRONMENT, TEST);
    }
}

static volatile AbstractConfiguration instance = null;

public static AbstractConfiguration getConfigInstance() {
    if (instance == null) {
        synchronized (ConfigurationManager.class) {
            if (instance == null) {
                instance = getConfigInstance(Boolean.getBoolean(DynamicPropertyFactory.DISABLE_DEFAULT_CONFIG));
            }
        }
    }
    return instance;
}

protected void initEurekaServerContext() throws Exception {
    EurekaServerConfig eurekaServerConfig = new DefaultEurekaServerConfig();
    ....
}

class DefaultEurekaServerConfig {
    private static final DynamicStringProperty EUREKA_PROPS_FILE = DynamicPropertyFactory
        .getInstance().getStringProperty("eureka.server.props",
                                         "eureka-server");    

  private void init() {
        String eurekaPropsFile = EUREKA_PROPS_FILE.get();
        ConfigurationManager.loadCascadedPropertiesFromResources(eurekaPropsFile);
    }
}

ApplicationInfoManager applicationInfoManager = null;

if (eurekaClient == null) {
    EurekaInstanceConfig instanceConfig = isCloud(ConfigurationManager.getDeploymentContext())
            ? new CloudInstanceConfig()
            : new MyDataCenterInstanceConfig(); // 默认就是走这个

public PropertiesInstanceConfig(String namespace, DataCenterInfo info) {
    super(info);
    // 这步其实就是去加载 eureka-client.properties配置文件，这个配置文件名可用eureka.client.props配置指定
    this.configInstance = Archaius1Utils.initConfig(CommonConstants.CONFIG_FILE_NAME);
}

class EurekaConfigBasedInstanceInfoProvider
public synchronized InstanceInfo get() {
    // 主要就是从eureka实例配置中读取数据，构建服务实例信息对象（InstanceInfo），一个服务实例里面包含一个租约信息对象（LeaseInfo，也就是心跳信息）
    if (instanceInfo == null) {
        // 续约 心跳信息
        LeaseInfo.Builder leaseInfoBuilder = LeaseInfo.Builder.newBuilder()
                .setRenewalIntervalInSecs(config.getLeaseRenewalIntervalInSeconds())
                .setDurationInSecs(config.getLeaseExpirationDurationInSeconds());

        // 服务实例信息
        InstanceInfo.Builder builder = InstanceInfo.Builder.newBuilder(vipAddressResolver);

        builder.setNamespace(config.getNamespace())
                .setInstanceId(instanceId)
                .setAppName(config.getAppname())
                .setAppGroupName(config.getAppGroupName())
                .setDataCenterInfo(config.getDataCenterInfo())
                .setIPAddr(config.getIpAddress())
                .setHostName(defaultAddress)
                .setPort(config.getNonSecurePort())
                .enablePort(PortType.UNSECURE, config.isNonSecurePortEnabled())
                .setSecurePort(config.getSecurePort())
                .enablePort(PortType.SECURE, config.getSecurePortEnabled())
                .setVIPAddress(config.getVirtualHostName())
                .setSecureVIPAddress(config.getSecureVirtualHostName())
                .setHomePageUrl(config.getHomePageUrlPath(), config.getHomePageUrl())
                .setStatusPageUrl(config.getStatusPageUrlPath(), config.getStatusPageUrl())
                .setASGName(config.getASGName())
                .setHealthCheckUrls(config.getHealthCheckUrlPath(),
                        config.getHealthCheckUrl(), config.getSecureHealthCheckUrl());

        instanceInfo = builder.build();
        instanceInfo.setLeaseInfo(leaseInfoBuilder.build());
    }
    return instanceInfo;
}

protected void initEurekaServerContext() throws Exception {
    // // 1、读取eureka client配置：这步其实就是去加载 eureka-client.properties配置文件，这个配置文件名可用eureka.client.props配置指定
    EurekaClientConfig eurekaClientConfig = new DefaultEurekaClientConfig();
    // eureka server把自己也当做是一个eureka-client，也是一个服务实例，向其他的eureka-server注册
    eurekaClient = new DiscoveryClient(applicationInfoManager, eurekaClientConfig);
}

DiscoveryClient(ApplicationInfoManager applicationInfoManager, EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args,
                    Provider<BackupRegistry> backupRegistryProvider, EndpointRandomizer endpointRandomizer) {
    // 1. 保存EurekaClientConfig和TransportConfig
    clientConfig = config;
    staticClientConfig = clientConfig;
    transportConfig = config.getTransportConfig();

    // 2. 处理是否要拉取注册表和是否要将自己作为Eureka Client注册到eureka
    if (config.shouldFetchRegistry()) {
        this.registryStalenessMonitor = new ThresholdLevelsMetric(this, METRIC_REGISTRY_PREFIX + "lastUpdateSec_", new long[]{15L, 30L, 60L, 120L, 240L, 480L});
    } else {
        this.registryStalenessMonitor = ThresholdLevelsMetric.NO_OP_METRIC;
    }

    if (config.shouldRegisterWithEureka()) {
        this.heartbeatStalenessMonitor = new ThresholdLevelsMetric(this, METRIC_REGISTRATION_PREFIX + "lastHeartbeatSec_", new long[]{15L, 30L, 60L, 120L, 240L, 480L});
    } else {
        this.heartbeatStalenessMonitor = ThresholdLevelsMetric.NO_OP_METRIC;
    }
    // 3. 支持调度的线程池
    // default size of 2 - 1 each for heartbeat and cacheRefresh
    scheduler = Executors.newScheduledThreadPool(2,
                                                 new ThreadFactoryBuilder()
                                                 .setNameFormat("DiscoveryClient-%d")
                                                 .setDaemon(true)
                                                 .build());    
    // 4. 支持心跳的线程池
    heartbeatExecutor = new ThreadPoolExecutor(
        1, clientConfig.getHeartbeatExecutorThreadPoolSize(), 0, TimeUnit.SECONDS,
        new SynchronousQueue<Runnable>(),
        new ThreadFactoryBuilder()
        .setNameFormat("DiscoveryClient-HeartbeatExecutor-%d")
        .setDaemon(true)
        .build()
    );  // use direct handoff

    // 5. 支持缓存刷新的线程池
    cacheRefreshExecutor = new ThreadPoolExecutor(
        1, clientConfig.getCacheRefreshExecutorThreadPoolSize(), 0, TimeUnit.SECONDS,
        new SynchronousQueue<Runnable>(),
        new ThreadFactoryBuilder()
        .setNameFormat("DiscoveryClient-CacheRefreshExecutor-%d")
        .setDaemon(true)
        .build()
    );  // use direct handoff

    // 6. 实例化一个EurekaTransport，支持eureka client和eureka server底层网络通信的组件
    eurekaTransport = new EurekaTransport();
    // 初始化eurekaTransport内的组件
    scheduleServerEndpointTask(eurekaTransport, args);

    // 7. 如果需要抓取注册表，这里就会尝试抓取增量注册表，如果抓取失败则从备份里获取注册表
    if (clientConfig.shouldFetchRegistry() && !fetchRegistry(false)) {
        fetchRegistryFromBackup();
    }
    
    // 初始化调度任务
    // 1. 抓取服务注册表 默认间隔是 30秒 搞了一个CachedRefreshThread
    // 2. 向eureka server注册 心跳定时任务 默认间隔30秒; 服务实例复制器 默认40秒后开始执行 每次间隔30秒
    // 3. 服务状态变更监听器 如果开启，每次服务状态发生变更，就会通知远程的eureka server
    // finally, init the schedule tasks (e.g. cluster resolvers, heartbeat, instanceInfo replicator, fetch
    initScheduledTasks();
}