12 全局视野来看Dubbo3的服务启动生命周期

    前面我们介绍了Dubbo启动器DubboBootstrap类型对象的创建,又介绍了为DubboBootstrap启动器初始化各种配置信息,这一个博客就开始到了分析启动方法的位置了,Dubbo启动器借助Deployer发布器来启动和发布服务,发布器的启动过程包含了启动配置中心,加载配置,启动元数据中心,启动服务等操作都是比较重要又比较复杂的过程,这里我们先来看下启动过程的生命周期来为后面的内容做好铺垫。

    12.2 启动器启动方法的调用逻辑start()

    这里我们就直接来看DubboBootstrap的start()方法:

    2.         //调用重载的方法进行启动参数代表是否等待启动结束
    3.        this.start(true);
    4.        return this;
    5.    }

    我们再来看重载的start方法:

    1. public DubboBootstrap start(boolean wait) {
    2.         //这个发布器是在ApplicationModel对象创建之后初始化的时候进行初始化的具体类型为DefaultApplicationDeployer
    3.         Future future = applicationDeployer.start();
    5.         if (wait) {
    6.             try {
    7.               //等待异步启动的结果
    8.                 future.get();
    9.             } catch (Exception e) {
    10.                 //启动失败则抛出一个异常
    11.                 throw new IllegalStateException("await dubbo application start finish failure", e);
    12.             }
    13.         }
    14.         return this;
    15.     }

    发布器是帮助我们发布服务和引用服务的,在Dubbo3中不论是服务提供者还是服务消费者如果想要启动服务都需要走这个启动方法的逻辑,所以务必重视

    我们直接来看DefaultApplicationDeployer的start()代码:

    这个启动方法逻辑不多 主要三个方法我们重点来看：

    • onStarting() 这个是启动之前的状态切换
    • initialize() 应用的初始化逻辑 比如配置中心，元数据中心的初始化
    • doStart() 启动模块比如启动我们的服务提供和服务引用的）

    12.4 应用程序发布器对应用级别的初始化逻辑

    这个我们先来看DefaultApplicationDeployer的初始化方法initialize()：

    1. @Override
    2.     public void initialize() {
    3.         //状态判断 如果已经初始化过了就直接返回
    4.         if (initialized) {
    5.             return;
    6.         }
    7.         // Ensure that the initialization is completed when concurrent calls
    8.         //启动锁，确保在并发调用时完成初始化
    9.         synchronized (startLock) {
    10.             //双重校验锁 如果已经初始化过了就直接返回
    11.             if (initialized) {
    12.                 return;
    13.             }
    14.             // register shutdown hook
    15.             //注册关闭钩子，这个逻辑基本每个中间件应用都必须要要做的事情了，正常关闭应用回收资源，一般没这个逻辑情况下容易出现一些异常，让我们开发人员很疑惑，而这个逻辑往往并不好处理的干净。
    16.             registerShutdownHook();
    18.             //启动配置中心，感觉Dubbo3耦合了这个玩意
    19.             startConfigCenter();
    21.             //加载配置，一般配置信息当前机器的来源：环境变量，JVM启动参数，配置文字
    22.             loadApplicationConfigs();
    24.             //初始化模块发布器 （发布服务提供和服务引用使用）
    25.             initModuleDeployers();
    27.             //启动元数据中心
    28.             startMetadataCenter();
    30.             //初始化完成
    31.             initialized = true;
    33.             if (logger.isInfoEnabled()) {
    34.                 logger.info(getIdentifier() + " has been initialized!");
    35.             }
    36.         }
    37.     }

    这个是个生命周期整体概览的方法，将具体逻辑拆分到各个子方法中，是代码重构的一种策略，上面注释也很清楚了就不细说了，上面每个方法在后面会有单独的博客来分析。

    我们回过头来详细看DefaultApplicationDeployer的doStart()代码:

    1. private void doStart() {
    2.         // 启动模块
    3.         startModules();

    DefaultApplicationDeployer的 startModules()方法

    这个模块的启动其实就是用来启动服务的 先启动内部服务，再启动外部服务
    内部服务有个元数据服务Dubbo3中每个服务都可以对外提供服务的元数据信息，来简化服务配置，不论是内部服务还是外部服务调用的代码逻辑都是模块发布器ModuleDeployer的start()方法，接下来我们详细看下模块发布器的生命周期函数。

    12.6 模块发布器发布服务的过程

    前面我们说到了所有的服务都是经过模块发布器，ModuleDeployer的start()方法来启动的，那我们接下来就来看看这个模块发布器的启动方法。

    1. @Override
    2.     public synchronized Future start() throws IllegalStateException {
    3.         //模块发布器已经停止或者启动失败则直接抛出异常返回
    4.         if (isStopping() || isStopped() || isFailed()) {
    5.             throw new IllegalStateException(getIdentifier() + " is stopping or stopped, can not start again");
    6.         }
    8.         try {
    9.             //启动重或者已经启动了则直接返回一个Future对象 
    10.             if (isStarting() || isStarted()) {
    11.                 return startFuture;
    12.             }
    13.             //切换模块启动状态为STARTING
    14.             onModuleStarting();
    16.             // initialize
    17.             //如果应用未初始化则初始化（非正常逻辑）
    18.             applicationDeployer.initialize();
    19.             //模块发布器进行初始化
    20.             initialize();
    22.             // export services
    23.             //暴露服务
    24.             exportServices();
    26.             // prepare application instance
    27.             // exclude internal module to avoid wait itself
    28.             if (moduleModel != moduleModel.getApplicationModel().getInternalModule()) {
    29.                 applicationDeployer.prepareInternalModule();
    30.             }
    32.             // refer services
    33.             //引用服务
    34.             referServices();
    36.             // if no async export/refer services, just set started
    37.             //非异步启动则直接切换状态为STARTED
    38.             if (asyncExportingFutures.isEmpty() && asyncReferringFutures.isEmpty()) {
    39.                 onModuleStarted();
    40.             } else {
    41.             //如果是异步的则等待服务发布和服务引用异步回调
    42.                 frameworkExecutorRepository.getSharedExecutor().submit(() -> {
    44.                         waitExportFinish();
    45.                         // wait for refer finish
    46.                         waitReferFinish();
    47.                     } catch (Throwable e) {
    48.                         logger.warn("wait for export/refer services occurred an exception", e);
    49.                     } finally {
    50.                         //异步回调完成 所有服务都启动了，再切换状态
    51.                         onModuleStarted();
    52.                     }
    53.                 });
    54.             }
    55.         } catch (Throwable e) {
    56.             onModuleFailed(getIdentifier() + " start failed: " + e, e);
    57.             throw e;
    58.         }
    59.         return startFuture;
    60.     }

    好了整体的服务启动生命周期就如上代码，后续我们再详细来看每个细节。

    前面主要说了应用和模块的发布器的启动和初始化，下面简单了解下它们的关系，如下所示

    可以发布器主要包含

    • 应用的发布器ApplicationDeployer用于初始化并启动应用程序实例
    • 模块发布器ModuleDeployer 模块（服务）的导出/引用服务

    两种发布器有各自的接口，他们都继承了抽象的发布器AbstractDeployer 封装了一些公共的操作比如状态切换，状态查询的逻辑。

    另外我们再来看下发布过程的状态枚举DeployState如下：

    1. public enum DeployState {
    2.     /**
    3.      * Unknown state
    4.      */
    5.     UNKNOWN,
    7.     /**
    8.      * Pending, wait for start
    9.      */
    10.     PENDING,
    12.     /**
    13.      * Starting
    14.      */
    15.     STARTING,
    17.     /**
    18.      * Started
    19.      */
    20.     STARTED,
    22.     /**
    23.      * Stopping
    24.      */
    25.     STOPPING,
    27.     /**
    28.      * Stopped
    29.      */
    30.     STOPPED,
    32.     /**
    33.      * Failed
    34.      */
    36. }

    Dubbo这一块后续可以优化以下，这里的状态切换全部耦合在一起了，可以考虑使用状态机将状态与行为解耦。

    技术咨询与支持,可以扫描微信公众号进行回复咨询
    在这里插入图片描述