较真儿学源码系列-PowerJob启动流程源码分析

        PowerJob版本：4.3.2-main。

---

1 简介

        PowerJob是全新一代的分布式任务调度与计算框架，官网地址：http://www.powerjob.tech/。其中介绍了PowerJob的功能特点，以及与其他调度框架的对比，这里就不再赘述了。

        以上是PowerJob的架构图，取自官网。可以看出，PowerJob是典型的客户端/服务端交互的架构（但是在PowerJob中却没有一般分布式中间件会有的注册中心）。本文就从启动流程出发，来一起探究下PowerJob在启动阶段中都做了些什么动作。

---

2 服务端

        既然要看启动流程源码，那么首先就来看下启动类。PowerJob依赖于Spring Boot，启动类为PowerJobServerApplication：

/**
 * powerjob-server entry
 *
 * @author tjq
 * @since 2020/3/29
 */
@Slf4j
@EnableScheduling
@SpringBootApplication
public class PowerJobServerApplication {

    private static final String TIPS = "\n\n" +
            "******************* PowerJob Tips *******************\n" +
            "如果应用无法启动，我们建议您仔细阅读以下文档来解决:\n" +
            "if server can't startup, we recommend that you read the documentation to find a solution:\n" +
            "https://www.yuque.com/powerjob/guidence/problem\n" +
            "******************* PowerJob Tips *******************\n\n";

    public static void main(String[] args) {

        pre();

        // Start SpringBoot application.
        try {
            SpringApplication.run(PowerJobServerApplication.class, args);
        } catch (Throwable t) {
            log.error(TIPS);
            throw t;
        }
    }

    private static void pre() {
        log.info(TIPS);
        PropertyUtils.init();
    }

}

/**
 * 加载配置文件
 *
 * @author tjq
 * @since 2020/5/18
 */
@Slf4j
public class PropertyUtils {

    private static final Properties PROPERTIES = new Properties();

    public static Properties getProperties() {
        return PROPERTIES;
    }

    public static void init() {
        URL propertiesURL = PropertyUtils.class.getClassLoader().getResource("application.properties");
        Objects.requireNonNull(propertiesURL);
        try (InputStream is = propertiesURL.openStream()) {
            PROPERTIES.load(is);
        } catch (Exception e) {
            ExceptionUtils.rethrow(e);
        }
    }
}

        其中pre方法只是将配置文件内容加载进Properties缓存中。

        既然启动类看不出什么逻辑，那么接下来就来看下服务端启动时有没有什么初始化的逻辑：

2.1 PowerTransportService

        PowerTransportService类是用作数据传输服务的，也就是客户端和服务端之间的通信。其实现了InitializingBean接口，所以查看下其afterPropertiesSet方法的实现：

/**
 * PowerTransportService:
 */
@Override
public void afterPropertiesSet() throws Exception {

    log.info("[PowerTransportService] start to initialize whole PowerTransportService!");
    log.info("[PowerTransportService] activeProtocols: {}", activeProtocols);

    if (StringUtils.isEmpty(activeProtocols)) {
        throw new IllegalArgumentException("activeProtocols can't be empty!");
    }

    for (String protocol : activeProtocols.split(OmsConstant.COMMA)) {
        try {
            final int port = parseProtocolPort(protocol);
            //初始化网络通讯
            initRemoteFrameWork(protocol, port);
        } catch (Throwable t) {
            log.error("[PowerTransportService] initialize protocol[{}] failed. If you don't need to use this protocol, you can turn it off by 'oms.transporter.active.protocols'", protocol);
            ExceptionUtils.rethrow(t);
        }
    }

    //选择默认的通信协议，默认为HTTP
    choseDefault();

    log.info("[PowerTransportService] initialize successfully!");
    log.info("[PowerTransportService] ALL_PROTOCOLS: {}", protocolName2Info);
}

/**
 * 第18行代码处：
 */
private void initRemoteFrameWork(String protocol, int port) {

    // 从构造器注入改为从 applicationContext 获取来避免循环依赖
    //获取所有注解了@Actor的bean
    final Map beansWithAnnotation = applicationContext.getBeansWithAnnotation(Actor.class);
    log.info("[PowerTransportService] find Actor num={},names={}", beansWithAnnotation.size(), beansWithAnnotation.keySet());

    Address address = new Address()
            .setHost(NetUtils.getLocalHost())
            .setPort(port);
    EngineConfig engineConfig = new EngineConfig()
            .setServerType(ServerType.SERVER)
            .setType(protocol.toUpperCase())
            .setBindAddress(address)
            .setActorList(Lists.newArrayList(beansWithAnnotation.values()));
    log.info("[PowerTransportService] start to initialize RemoteEngine[type={},address={}]", protocol, address);
    RemoteEngine re = new PowerJobRemoteEngine();
    //初始化网络层
    final EngineOutput engineOutput = re.start(engineConfig);
    log.info("[PowerTransportService] start RemoteEngine[type={},address={}] successfully", protocol, address);

    //放入相关缓存中
    this.engines.add(re);
    this.protocolName2Info.put(protocol, new ProtocolInfo(protocol, address.toFullAddress(), engineOutput.getTransporter()));
}

        其中需要说明的一点是：PowerJob网络层使用的协议是Akka或Vert.x：

• Akka是一个在JVM上构建高并发、分布式和弹性消息驱动的应用程序。其是用Scala写的，使用到了Actor模型；
• 而Vert.x是一个在JVM上构建响应式应用程序的工具包，其底层基于Netty（之前我对Netty的源码也进行过分析，感兴趣的话可以查看《较真儿学源码系列-Netty核心流程源码分析》）。

        PowerJob屏蔽了底层的实现，用两个自定义的注解@Actor和@Handler进行了统一的封装。客户端传过来的请求会自动跳转到@Actor注解的类、@Handler注解的方法上。拿客户端发送心跳给服务端的逻辑为例，流程如下所示：

        下面就来继续看下，在上面的第53行代码处。PowerJob是如何完成这个绑定的：

/**
 * PowerJobRemoteEngine:
 */
@Override
public EngineOutput start(EngineConfig engineConfig) {

    final String engineType = engineConfig.getType();
    EngineOutput engineOutput = new EngineOutput();
    log.info("[PowerJobRemoteEngine] [{}] start remote engine with config: {}", engineType, engineConfig);
    //获取所有@Actor的类，和其中注解了@Handler的方法
    List actorInfos = ActorFactory.load(engineConfig.getActorList());
    //遍历获取指定协议的CSInitializer
    csInitializer = CSInitializerFactory.build(engineType);

    String type = csInitializer.type();

    Stopwatch sw = Stopwatch.createStarted();
    log.info("[PowerJobRemoteEngine] [{}] try to startup CSInitializer[type={}]", engineType, type);

    //CsInitializer初始化，这里以Vert.x为例，查看下其实现
    csInitializer.init(new CSInitializerConfig()
            .setBindAddress(engineConfig.getBindAddress())
            .setServerType(engineConfig.getServerType())
    );

    // 构建通讯器
    Transporter transporter = csInitializer.buildTransporter();
    engineOutput.setTransporter(transporter);

    log.info("[PowerJobRemoteEngine] [{}] start to bind Handler", engineType);
    actorInfos.forEach(actor -> actor.getHandlerInfos().forEach(handlerInfo -> log.info("[PowerJobRemoteEngine] [{}] PATH={}, handler={}", engineType, handlerInfo.getLocation().toPath(), handlerInfo.getMethod())));

    // 绑定 handler
    csInitializer.bindHandlers(actorInfos);

    log.info("[PowerJobRemoteEngine] [{}] startup successfully, cost: {}", engineType, sw);

    return engineOutput;
}

/**
 * ActorFactory:
 * 第11行代码处：
 */
static List load(List