Flowable源码注释（四十三）BPMN解析器

Flowable源码地址：https://github.com/flowable/flowable-engine

Flowable-6.7.2 源码注释地址：https://github.com/solojin/flowable-6.7.2-annotated

BPMN解析器，包路径：org.flowable.engine.impl.bpmn.parser

BpmnParser BPMN解析器

package org.flowable.engine.impl.bpmn.parser;

import org.flowable.engine.impl.bpmn.parser.factory.ActivityBehaviorFactory;
import org.flowable.engine.impl.bpmn.parser.factory.ListenerFactory;
import org.flowable.engine.impl.cfg.BpmnParseFactory;

/**
 * BPMN 2.0流程模型的解析器。
 * 
 * 流程引擎中只有一个该解析器的实例。这个{@link BpmnParser}创建了{@link BpmnParse}实例，可用于实际解析BPMN 2.0 XML流程定义。
 * 
 * @author Tom Baeyens
 * @author Joram Barrez
 */
public class BpmnParser {

    /**
     * BPMN 2.0图交换元素的名称空间。
     */
    public static final String BPMN_DI_NS = "http://www.omg.org/spec/BPMN/20100524/DI";

    /**
     * BPMN 2.0图表公共元素的名称空间。
     */
    public static final String BPMN_DC_NS = "http://www.omg.org/spec/DD/20100524/DC";

    /**
     * 通用OMG DI元素的名称空间（不要问我为什么不使用BPMN_DI_NS…）
     */
    public static final String OMG_DI_NS = "http://www.omg.org/spec/DD/20100524/DI";

    protected ActivityBehaviorFactory activityBehaviorFactory;
    protected ListenerFactory listenerFactory;
    protected BpmnParseFactory bpmnParseFactory;
    protected BpmnParseHandlers bpmnParserHandlers;

    /**
     * 创建一个新的{@link BpmnParse}实例，该实例只能用于解析一个BPMN 2.0进程定义。
     */
    public BpmnParse createParse() {
        return bpmnParseFactory.createBpmnParse(this);
    }

    public ActivityBehaviorFactory getActivityBehaviorFactory() {
        return activityBehaviorFactory;
    }

    public void setActivityBehaviorFactory(ActivityBehaviorFactory activityBehaviorFactory) {
        this.activityBehaviorFactory = activityBehaviorFactory;
    }

    public ListenerFactory getListenerFactory() {
        return listenerFactory;
    }

    public void setListenerFactory(ListenerFactory listenerFactory) {
        this.listenerFactory = listenerFactory;
    }

    public BpmnParseFactory getBpmnParseFactory() {
        return bpmnParseFactory;
    }

    public void setBpmnParseFactory(BpmnParseFactory bpmnParseFactory) {
        this.bpmnParseFactory = bpmnParseFactory;
    }

    public BpmnParseHandlers getBpmnParserHandlers() {
        return bpmnParserHandlers;
    }

    public void setBpmnParserHandlers(BpmnParseHandlers bpmnParserHandlers) {
        this.bpmnParserHandlers = bpmnParserHandlers;
    }
}

BpmnParseHandlers BPMN解析处理器

package org.flowable.engine.impl.bpmn.parser;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.flowable.bpmn.model.BaseElement;
import org.flowable.bpmn.model.DataObject;
import org.flowable.bpmn.model.FlowElement;
import org.flowable.engine.parse.BpmnParseHandler;
import org.slf4j.Logger;

/**
 * BPMN解析处理器
 *
 * @author Joram Barrez
 */
public class BpmnParseHandlers {

    private static final Logger LOGGER = org.slf4j.LoggerFactory.getLogger(BpmnParseHandlers.class);

    protected Map<Class<? extends BaseElement>, List<BpmnParseHandler>> parseHandlers;

    public BpmnParseHandlers() {
        this.parseHandlers = new HashMap<>();
    }

    public List<BpmnParseHandler> getHandlersFor(Class<? extends BaseElement> clazz) {
        return parseHandlers.get(clazz);
    }

    // 批量添加BPMN处理器
    public void addHandlers(List<BpmnParseHandler> bpmnParseHandlers) {
        for (BpmnParseHandler bpmnParseHandler : bpmnParseHandlers) {
            addHandler(bpmnParseHandler);
        }
    }

    // 添加BPMN处理器
    public void addHandler(BpmnParseHandler bpmnParseHandler) {
        for (Class<? extends BaseElement> type : bpmnParseHandler.getHandledTypes()) {
            List<BpmnParseHandler> handlers = parseHandlers.get(type);
            if (handlers == null) {
                handlers = new ArrayList<>();
                parseHandlers.put(type, handlers);
            }
            handlers.add(bpmnParseHandler);
        }
    }

    // 解析元素
    public void parseElement(BpmnParse bpmnParse, BaseElement element) {

        if (element instanceof DataObject) {
            // 忽略DataObject元素，因为它们是在进程上处理的
            // 和子流程级别
            return;
        }

        // 如果是流元素，设置为BPMN解析器当前正处理的流元素
        if (element instanceof FlowElement) {
            bpmnParse.setCurrentFlowElement((FlowElement) element);
        }

        // 执行解析处理程序
        List<BpmnParseHandler> handlers = parseHandlers.get(element.getClass());

        if (handlers == null) {
            // 找不到与{elementId}匹配的分析处理程序。这可能是一个BUG。
            LOGGER.warn("Could not find matching parse handler for + {} this is likely a bug.", element.getId());
        } else {
            for (BpmnParseHandler handler : handlers) {
                handler.parse(bpmnParse, element);
            }
        }
    }

}