微服务笔记之Euraka(2)

Eureka Server启动过程

入口：SpringCloud充分利用了SpringBoot的自动装配的特点

Eureka-server的jar包，发现在MERA-INF下面有配置文件spring.factories

SpringBoot应用启动时会加载EurekaServerAutoConfiguration自动配置

EurekaServerAutoConfiguration类

先看头部信息

@Configuration

@Import(EurekaServerInitializerConfiguration.class)   //导入初始化类

@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)  //加载Bean对象----> Marker

@EnableConfigurationProperties({ EurekaDashboardProperties.class,

        InstanceRegistryProperties.class })

@PropertySource("classpath:/eureka/server.properties")  // 配置类和配置信息

public class EurekaServerAutoConfiguration extends WebMvcConfigurerAdapter {

         //...

}

主要分析EurekaServerInitializerConfiguration、Marker、EurekaServerAutoConfiguration这三个类

1、先看Marker这个类，它是什么时候注入的？

其实是由@EnableEurekaServer注解决定的，如下：

@SpringBootApplication

@EnableEurekaServer  //在我们启动类添加该注解，声明是一个EurekaServer

public class EurekaApplication {

    public static void main(String[] args) {

        SpringApplication.run(EurekaApplication.class, args);

    }

}

进入EnableEurekaServer注解，会发现他导入了一个EurekaServerMarkerConfiguration类

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Import(EurekaServerMarkerConfiguration.class)  // 导入该类，和我们的Marker类很相像

public @interface EnableEurekaServer {

}

再进入EurekaServerMarkerConfiguration类，在该类中将Marker注入到容器中

@Configuration

public class EurekaServerMarkerConfiguration {

    @Bean   // 此处将Marker注入到容器中

    public Marker eurekaServerMarkerBean() {

        return new Marker();

    }

    class Marker {

    }

}

但是Marker这个类什么都没写，不知道导入它有什么用？？？

2、再看EurekaServerAutoConfiguration这个类

主要分析以下几个重要的方法

eurekaController这个方法：它注入一个对外的接口(通过这个接口我们可以访问后台界面)，这个后台界面我们可以通过配置来修改它是否让它显示，在配置文件中加入eureka.dashboard.enabled = false即可

@Bean

@ConditionalOnProperty(prefix = "eureka.dashboard", name = "enabled", matchIfMissing = true)

public EurekaController eurekaController() {

    return new EurekaController(this.applicationInfoManager);

}

后台界面就是下图

peerAwareInstanceRegistry这个方法：它是对等节点感知实例注册器，在集群模式下，注册服务使用到的注册器

@Bean

public PeerAwareInstanceRegistry peerAwareInstanceRegistry(

    ServerCodecs serverCodecs) {

    this.eurekaClient.getApplications(); // force initialization

    return new InstanceRegistry(this.eurekaServerConfig, this.eurekaClientConfig,serverCodecs, this.eurekaClient,                this.instanceRegistryProperties.getExpectedNumberOfClientsSendingRenews(),

                this.instanceRegistryProperties.getDefaultOpenForTrafficCount());

}

peerEurekaNodes这个方法：它的作用是注入对等的实例节点信息，辅助封装对等节点相关的信息和操作。在EurekaServer集群中，更新集群中对等的节点，因为EurekaServer集群节点可能发生变化，更新节点在PeerEurekaNodes类中的start方法中实现

@Bean

@ConditionalOnMissingBean

public PeerEurekaNodes peerEurekaNodes(PeerAwareInstanceRegistry registry,

    ServerCodecs serverCodecs) {

        return new RefreshablePeerEurekaNodes(registry, this.eurekaServerConfig,this.eurekaClientConfig,serverCodecs, this.applicationInfoManager);

}

PeerEurekaNodes类中的start方法

public void start() {

        this.taskExecutor = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {

            public Thread newThread(Runnable r) {

                Thread thread = new Thread(r, "Eureka-PeerNodesUpdater");

                thread.setDaemon(true);

                return thread;

            }

        });

        try {

            this.updatePeerEurekaNodes(this.resolvePeerUrls());

            Runnable peersUpdateTask = new Runnable() {

                public void run() {

                    try {
                        // 该方法进行更新节点

                        PeerEurekaNodes.this.updatePeerEurekaNodes(PeerEurekaNodes.this.resolvePeerUrls());

                    } catch (Throwable var2) {

                        PeerEurekaNodes.logger.error("Cannot update the replica Nodes", var2);

                    }

                }

            };

            this.taskExecutor.scheduleWithFixedDelay(peersUpdateTask, (long)this.serverConfig.getPeerEurekaNodesUpdateIntervalMs(), (long)this.serverConfig.getPeerEurekaNodesUpdateIntervalMs(), TimeUnit.MILLISECONDS);

        } catch (Exception var3) {

            throw new IllegalStateException(var3);

        }

        Iterator var4 = this.peerEurekaNodes.iterator();

        while(var4.hasNext()) {

            PeerEurekaNode node = (PeerEurekaNode)var4.next();

            logger.info("Replica node URL:  {}", node.getServiceUrl());

        }

}

那么什么时候执行start方法呢？且往下看

eurekaServerContext这个方法：注入EurekaServer的上下文对象，返回的是一个DefaultEurekaServerContext对象，

@Bean

public EurekaServerContext eurekaServerContext(ServerCodecs serverCodecs,PeerAwareInstanceRegistry registry, PeerEurekaNodes peerEurekaNodes) {

    return new DefaultEurekaServerContext(this.eurekaServerConfig, serverCodecs,registry, peerEurekaNodes, this.applicationInfoManager);

}

DefaultEurekaServerContext类中有个Initialize方法，他会在DefaultEurekaServerContext初始化完成后执行，在它里面会执行上述的start方法

@PostConstruct

public void initialize() {

   logger.info("Initializing ...");

   this.peerEurekaNodes.start();

   try {

       this.registry.init(this.peerEurekaNodes);

   } catch (Exception var2) {

       throw new RuntimeException(var2);

   }

   logger.info("Initialized");

}

eurekaServerBootstrap这个方法：注入一个EurekaServerBootstrap对象，后续启动会使用该对象

@Bean

public EurekaServerBootstrap eurekaServerBootstrap(PeerAwareInstanceRegistry registry,EurekaServerContext serverContext) {

    return new EurekaServerBootstrap(this.applicationInfoManager, this.eurekaClientConfig, this.eurekaServerConfig, registry,serverContext);

}

jerseyFilterRegistration这个方法：它会注册Jersey过滤器。Jersey它是一个rest框架，帮我们发布resetful服务接口的(类似于springmvc)。EurekaServer端和EurekaClient进行通信，Server端发送的是http服务，该服务就是由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);

    bean.setUrlPatterns(Collections.singletonList(EurekaConstants.DEFAULT_PREFIX + "/*"));

    return bean;

}

jerseyApplication这个方法：它会注入一个Application对象，它的作用就是作为jerseyFilterRegistration方法的参数注册Jersey过滤器

@Bean

public javax.ws.rs.core.Application jerseyApplication(Environment environment,ResourceLoader resourceLoader) {

       //...

}

3、再看EurakaServerInitializerConfiguration这个类

它实现了SmartLifecycle这个接口，该接口的父类是Lifecycle(此接口中有一个start方法)，实现该接口，可以在Spring容器的Bean创建完成之后做一些事情(如执行start方法)

@Configuration

public class EurekaServerInitializerConfiguration implements ServletContextAware, SmartLifecycle, Ordered {

        //...

}

下面我们看一下start方法实现(其中上面我们所讲的EurekaServerBootStrap注册的对象就是在此处使用的)

@Override

public void start() {

    new Thread(new Runnable() {

        @Override

        public void run() {

            try {

                //TODO: is this class even needed now?
                // 初始化EurekaServerContext细节

                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();
}

下面看一下contextInitialized这个方法

public void contextInitialized(ServletContext context) {

   try {

        // 初始化环境信息

        initEurekaEnvironment();

        // 初始化context细节

        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);

    }

}

看一下initEurekaServerContext这个方法

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();

    }
    // 此处是给非IOC容器提供获取EurekaServerContext对象的接口

    EurekaServerContextHolder.initialize(this.serverContext);

    log.info("Initialized server context");

    // 某一个server实例启动的时候，从集群中其他的server拷贝注册信息过来(同步其他节点信息)，每一个server对于其他server来说也是一个客户端
    int registryCount = this.registry.syncUp();
    // 更改实例状态为UP，对外提供服务
    this.registry.openForTraffic(this.applicationInfoManager, registryCount);

    // 注册统计器

    EurekaMonitors.registerAllStats();

 }

先看一下syncUp这个方法

public int syncUp() {

    // Copy entire entry from neighboring DS node

    int count = 0;   // 统计节点个数

    // serverConfig.getRegistrySyncRetries() 可能由于远程server没有连接上，做重试操作

    for (int i = 0; ((i < serverConfig.getRegistrySyncRetries()) && (count == 0)); i++) {

        if (i > 0) {

            try {

                Thread.sleep(serverConfig.getRegistrySyncRetryWaitMs());

            } catch (InterruptedException e) {

                logger.warn("Interrupted during registry transfer..");

                break;

            }

        }

        // 获取其他server的注册表信息

        Applications apps = eurekaClient.getApplications();

        for (Application app : apps.getRegisteredApplications()) {

            for (InstanceInfo instance : app.getInstances()) {

                try {

                   if (isRegisterable(instance)) {

                       // 把从远程获取到的注册表信息注册到自己的注册表中(map)

                       register(instance, instance.getLeaseInfo().getDurationInSecs(), true);

                       count++;

                   }

                } catch (Throwable t) {

                   logger.error("During DS init copy", t);

                }

            }

        }

    }

    return count;

}

看一下register方法

回过头来在看一下openForTraffic方法

以上就是EurekaServer启动过程分析

巴特西

微服务笔记之Euraka(2)

最新文章

热门文章