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

12.1 启动方法简介

在说启动方法之前先把视野拉回第一章《1-从一个服务提供者的Demo说起》我们的Demo代码,下面只贴一下核心代码:

  1. public class Application {
  2.     public static void main(String[] args) throws Exception {
  3.             startWithBootstrap();
  4.     }
  5.     private static void startWithBootstrap() {
  6.         //前面的文章都在说这个服务配置对象的创建,中间又说了分层域模型,扩展加载机制
  7.         ServiceConfig<DemoServiceImpl> service = new ServiceConfig<>();
  8.         //为服务配置下服务接口和服务实现,下面两行用来初始化对象就不详细说了
  9.         service.setInterface(DemoService.class);
  10.         service.setRef(new DemoServiceImpl());
  11.         //这一个篇章主要说这里:
  12.         DubboBootstrap bootstrap = DubboBootstrap.getInstance();
  13.         //初始化应用配置
  14.         bootstrap.application(new ApplicationConfig("dubbo-demo-api-provider"))
  15.         //初始化注册中心配置
  16.             .registry(new RegistryConfig("zookeeper://127.0.0.1:2181"))
  17.             //初始化协议配置
  18.             .protocol(new ProtocolConfig(CommonConstants.DUBBO, -1))
  19.             //初始化服务配置
  20.             .service(service)
  21.             //启动
  22.             .start()
  23.             .await();
  24.     }
  25. }

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

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

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

  1. public 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.     }

12.3 应用程序发布器DefaultApplicationDeployer的启动方法

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

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

  1. @Override
  2.     public Future start() {
  3.         //启动锁，防止重复启动
  4.         synchronized (startLock) {
  5.             //发布器,状态已经设置为停止或者失败了就直接抛出异常
  6.             if (isStopping() || isStopped() || isFailed()) {
  7.                 throw new IllegalStateException(getIdentifier() + " is stopping or stopped, can not start again");
  8.             }
  10.             try {
  11.                 // maybe call start again after add new module, check if any new module
  12.                 //可能在添加新模块后再次调用start，检查是否有任何新模块
  13.                 //这里遍历当前应用程序下的所有模块如果某个模块是PENDING状态则这里hasPendingModule的值为true
  14.                 boolean hasPendingModule = hasPendingModule();
  15.                 //发布器状态正在启动中
  16.                 if (isStarting()) {
  17.                     // currently, is starting, maybe both start by module and application
  18.                     // if it has new modules, start them
  19.                     //存在挂器的模块
  20.                     if (hasPendingModule) {
  21.                          //启动模块
  22.                         startModules();
  23.                     }
  24.                     // if it is starting, reuse previous startFuture
  25.                     //模块异步启动中
  26.                     return startFuture;
  27.                 }
  29.                 // if is started and no new module, just return
  30.                 //如果已启动且没有新模块，直接返回
  31.                 if (isStarted() && !hasPendingModule) {
  32.                     return CompletableFuture.completedFuture(false);
  33.                 }
  35.                 // pending -> starting : first start app
  36.                 // started -> starting : re-start app
  37.                 //启动状态切换，将启动状态切换到STARTING（pending和started状态无需切换）
  38.                 onStarting();
  39.                 //核心初始化逻辑，这里主要做一些应用级别启动比如配置中心，元数据中心
  40.                 initialize();
  41.                 //启动模块（我们的服务提供和服务引用是在这个模块级别的）
  42.                 doStart();
  43.             } catch (Throwable e) {
  44.                 onFailed(getIdentifier() + " start failure", e);
  45.                 throw e;
  46.             }
  48.             return startFuture;
  49.         }
  50.     }

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

  • 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.             // @since 2.7.8
  28.             //启动元数据中心
  29.             startMetadataCenter();
  31.             //初始化完成
  32.             initialized = true;
  34.             if (logger.isInfoEnabled()) {
  35.                 logger.info(getIdentifier() + " has been initialized!");
  36.             }
  37.         }
  38.     }

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

12.5 应用下模块的启动（服务的发布与引用）

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

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

DefaultApplicationDeployer的 startModules()方法

  1. private void startModules() {
  2.         // ensure init and start internal module first
  3.         //确保初始化并首先启动内部模块,Dubbo3中将模块分为内部和外部，内部是核心代码已经提供的一些服务比如元数据服务，外部是我们自己写的服务
  4.         prepareInternalModule();
  6.         // filter and start pending modules, ignore new module during starting, throw exception of module start
  7.         //启动所有的模块 （启动所有的服务）
  8.         for (ModuleModel moduleModel : new ArrayList<>(applicationModel.getModuleModels())) {
  9.             //这个状态默认就是PENDING的
  10.             if (moduleModel.getDeployer().isPending()) {
  11.                 //模块启动器，发布服务
  12.                 moduleModel.getDeployer().start();
  13.             }
  14.         }
  15.     }

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

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

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

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(() -> {
  43.                     try {
  44.                         // wait for export finish
  45.                         waitExportFinish();
  46.                         // wait for refer finish
  47.                         waitReferFinish();
  48.                     } catch (Throwable e) {
  49.                         logger.warn("wait for export/refer services occurred an exception", e);
  50.                     } finally {
  51.                         //异步回调完成 所有服务都启动了，再切换状态
  52.                         onModuleStarted();
  53.                     }
  54.                 });
  55.             }
  56.         } catch (Throwable e) {
  57.             onModuleFailed(getIdentifier() + " start failed: " + e, e);
  58.             throw e;
  59.         }
  60.         return startFuture;
  61.     }

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

12.7 发布器简介

前面主要说了应用和模块的发布器的启动和初始化，下面简单了解下它们的关系，如下所示
在这里插入图片描述
可以发布器主要包含

  • 应用的发布器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.      */
  35.     FAILED
  36. }

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

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