JBPM流程部署之部署环境初始化

JBPM流程部署之部署环境初始化

 

      流程的部署是流程引擎需要完成的几个重要的任务之一，流程定义是现实中复杂业务需求在流程流转实现的体现；流程部署需要完成xml格式流程定义的校验、流程定义的持久化、流程定义到流程定义实体的转化、流程版本升级和流程实例的迁移等众多的功能；
      今天我们来简单的学习一下流程部署的环境初始化；流程部署环境初始化需要完成部署服务、流程部署缓存、流程部署持久化相关对象、流程引擎支持的节点类型等相关binding对象及相关的部署解析器的实例化；

      流程引擎支持的节点类型初始化

                 流程引擎支持众多的节点类型，比如任务节点、状态节点、子流程等等；此过程初始化JBPM默认支持的系统节点类型；JBPM将xml格式的流程定义解析成运行

            时流程引擎流转所使用的流程定义(ProcessDefinitionImpl)、Activity等对象；而流程引擎对xml的解析也是依赖自己实现的IOC来实现的，所以归根结底流程引

            擎支持的节点类型的初始化，就是将流程引擎支持的节点类型相应的binding进行实例化！此过程中相关的对象和UML类图如下   

                流程引擎支持的节点类型初始化相关对象  
                                   

                流程引擎支持的节点类型初始化相关对象UML图

               

                下面我们通过图中的对象的实现代码，看一下他们的作用

                 jbpm.jpdl.bindings.xml 定义JBPM支持的节点类型和节点事件监听器，我们可以根据业务的需要注释到不使用的节点类型对应的元素，那么运行时就不会解

            析流程定义xml中相应的元素，从而不会生成对应节点的对象；同时我们也可以在这里配置加载我们自定义或者扩展现有的节点类型。

                

<bindings>
  //流程引擎支持的各种节点的binding
  <activity binding="org.jbpm.jpdl.internal.activity.StartBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.StateBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.DecisionBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.EndBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.EndCancelBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.EndErrorBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.ForEachBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.ForkBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.JoinBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.HqlBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.SqlBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.JavaBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.ScriptBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.TaskBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.SubProcessBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.MailBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.GroupBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.CustomBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.AssignBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.PassthroughBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.RulesBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.RulesDecisionBinding" />
  <activity binding="org.jbpm.jpdl.internal.activity.JmsBinding" />

  //流程引擎节点的事件监听器
  <eventlistener binding="org.jbpm.jpdl.internal.activity.EventListenerBinding" />
  <eventlistener binding="org.jbpm.jpdl.internal.activity.JavaBinding" />
  <eventlistener binding="org.jbpm.jpdl.internal.activity.HqlBinding" />
  <eventlistener binding="org.jbpm.jpdl.internal.activity.SqlBinding" />
  <eventlistener binding="org.jbpm.jpdl.internal.activity.ScriptBinding" />
  <eventlistener binding="org.jbpm.jpdl.internal.activity.MailBinding" />
  <eventlistener binding="org.jbpm.jpdl.internal.activity.AssignBinding" />
  <eventlistener binding="org.jbpm.jpdl.internal.activity.JmsBinding" />

</bindings>

             JpdlDeployer 主要负责根据既有的规则生成流程定义的Id，key和版本，同时在首次解析时，通过静态字段JpdlParser来完成相关节点的binding类的实例化

            

public class JpdlDeployer extends ProcessDeployer {
  
  private static Log log = Log.getLog(JpdlDeployer.class.getName());
  private static Parser parser = new Parser();
  
  //静态字段自动初始化
  static JpdlParser jpdlParser = new JpdlParser();
  static final String jpdlExtension = ".jpdl.xml";

             JpdlDeployer的父类ProcessDeployer中的部分代码，完成对流程定义Id、version、key等的设置并持久化等

 

  public void deploy(DeploymentImpl deployment) {
    
    for (String resourceName: deployment.getResourceNames()) {
      
      if (resourceName.endsWith(extension)) {
        //加载xml格式的流程定义资源
        byte[] bytes = deployment.getBytes(resourceName);
        InputStream inputStream = new ByteArrayInputStream(bytes);
        Parse parse = parser.createParse();
        parse.contextMapPut(Parse.CONTEXT_KEY_DEPLOYMENT, deployment);
        parse.setProblems(deployment.getProblems());
        parse.setInputStream(inputStream);
        //解析xml格式的流程定义生成ProcessDefinitionImpl
        parse.execute();
        List<ProcessDefinitionImpl> processDefinitions = (List<ProcessDefinitionImpl>) parse.getDocumentObject();
        if (processDefinitions!=null) {
          for (ProcessDefinitionImpl processDefinition : processDefinitions) {
            if ((processDefinition != null) && (processDefinition.getName() != null)) {
              processDefinition.setSuspended(deployment.isSuspended());

              String imageResourceName = resourceName.substring(0, resourceName.lastIndexOf(extension)) + ".png";
              if (deployment.getResourceNames().contains(imageResourceName)) {
                processDefinition.setImageResourceName(imageResourceName);
              }

              processDefinition.setDeploymentDbid(deployment.getDbid());

              String processDefinitionName = processDefinition.getName();
              //获取已经发布完得流程执行（比如启动流程时获取流程定义对象）
              if (deployment.hasObjectProperties(processDefinitionName)) {
                String key = deployment.getProcessDefinitionKey(processDefinitionName);
                String id = deployment.getProcessDefinitionId(processDefinitionName);
                Long version = deployment.getProcessDefinitionVersion(processDefinitionName);
                processDefinition.setId(id);
                processDefinition.setKey(key);
                processDefinition.setVersion(version.intValue());
            
              } else {
                //流程部署校验并设置流程定义的id、key、version
                checkKey(processDefinition, deployment);
                checkVersion(processDefinition, deployment);
                checkId(processDefinition, deployment);
                //持久化对流程定义id、key、version的设置
                deployment.setProcessDefinitionId(processDefinitionName, processDefinition.getId());
                deployment.setProcessDefinitionKey(processDefinitionName, processDefinition.getKey());
                deployment.setProcessDefinitionVersion(processDefinitionName, new Long(processDefinition.getVersion()));
                
                //execute migration
                //流程实例迁移
                Map<ProcessDefinition, MigrationDescriptor> migrations = (Map<ProcessDefinition, MigrationDescriptor>)parse.contextMapGet(Parse.CONTEXT_KEY_MIGRATIONS);
                if (migrations != null) {
                  MigrationDescriptor migrationDescriptor = migrations.get(processDefinition);
                  if (migrationDescriptor != null) {
                    InstanceMigrator.migrateAll(processDefinition, migrationDescriptor);
                  }
                }
                
              }

              deployment.addObject(processDefinitionName, processDefinition);
            }
          }
        }
      }
    }
  }

 

             ProcessDefinitionImpl，流程定义的运行时对象，作为流程实例运行的流转依据，其定义了流程的启动节点，同时父类CompositeElementImpl定义了流程中

       的所有的节点

            

public class ProcessDefinitionImpl extends CompositeElementImpl implements OpenProcessDefinition, ClientProcessDefinition {

  private static final long serialVersionUID = 1L;
  private static final Log log = Log.getLog(ProcessDefinitionImpl.class.getName());
  
  public static final int UNASSIGNED_VERSION = -1;

  /** user provided short reference for the process definition that 
   * has the same scope as the name.  Multiple versions of the same 
   * process can have the same key. The key is used to build the 
   * globally unique execution ids. */
  protected String key;
  
  /** the unique id (e.g. combination of name and versionnumber) for this 
   * process definition. */
  protected String id;

  /** the version number of the process definitions with the same name.*/
  protected int version = UNASSIGNED_VERSION;
  
  /** optional package name similar to the Java package name. */
  protected String packageName;
  
  /** time this process was deployed */
  protected Date deploymentTime;
  
  /** ref to the deployment */
  protected long deploymentDbid;
  
  /** propagated from deployment to process definition during deploy */
  protected boolean isSuspended = false;
  
  /** the activity which is executed when the process starts */

  //流程的起始节点
  protected ActivityImpl initial;
  

 

              ProcessDefinitionImpl的父类CompositeElementImpl中定义了其所有的直接子节点

public abstract class CompositeElementImpl extends ScopeElementImpl implements CompositeElement {

  private static final long serialVersionUID = 1L;
  //流程定义的所有直接子节点，节点本身是可以嵌套的
  protected List<ActivityImpl> activities;
 

 

               JpdlParser定义了部署中需要使用的一些关键信息，并完成xml格式流程定义的解析，并在初次解析xml前完成节点类型binding类的解析初始化

 

public class JpdlParser extends Parser {

  private static final Log log = Log.getLog(JpdlParser.class.getName());

  //xml格式流程定义使用的命名空间
  public static final String NAMESPACE_JPDL_40 = "http://jbpm.org/4.0/jpdl";
  public static final String NAMESPACE_JPDL_42 = "http://jbpm.org/4.2/jpdl";
  public static final String NAMESPACE_JPDL_43 = "http://jbpm.org/4.3/jpdl";
  public static final String NAMESPACE_JPDL_44 = "http://jbpm.org/4.4/jpdl";

  //当前JBPM的版本、流程定义的命名空间、jbpl的版本
  public static final String CURRENT_VERSION_JBPM = "4.4";
  public static final String CURRENT_VERSION_NAMESPACE =
    "http://jbpm.org/" + CURRENT_VERSION_JBPM + "/jpdl";
  public static final String CURRENT_VERSION_PROCESS_LANGUAGE_ID =
    "jpdl-" + CURRENT_VERSION_JBPM;

  //流程定义xml校验使用的xsd
  private static final String[] SCHEMA_RESOURCES =
    { "jpdl-4.0.xsd", "jpdl-4.2.xsd", "jpdl-4.3.xsd", "jpdl-4.4.xsd" };

  //节点类型binding的配置文件
  private static final String[] DEFAULT_BINDING_RESOURCES =
    { "jbpm.jpdl.bindings.xml", "jbpm.user.bindings.xml" };

  //解析配置文件中的binding类
  private static JpdlBindingsParser jpdlBindingsParser = new JpdlBindingsParser();

  //节点的binding类的分类
  public static final String CATEGORY_ACTIVITY = "activity";
  public static final String CATEGORY_EVENT_LISTENER = "eventlistener";

  //初始化时，加载并解析节点的binding类
  public JpdlParser() {
    parseBindings();
    setSchemaResources(SCHEMA_RESOURCES);
  }

  //加载并解析节点的binding类
  protected void parseBindings() {
    this.bindings = new Bindings();

    for (String activityResource : DEFAULT_BINDING_RESOURCES) {
      Enumeration<URL> resourceUrls = getResources(activityResource);
      if (resourceUrls.hasMoreElements()) {
        while (resourceUrls.hasMoreElements()) {
          URL resourceUrl = resourceUrls.nextElement();
          log.trace("loading jpdl bindings from resource: " + resourceUrl);
          jpdlBindingsParser.createParse()
            .setUrl(resourceUrl)
            .contextMapPut(Parse.CONTEXT_KEY_BINDINGS, bindings)
            .execute()
            .checkErrors("jpdl bindings from " + resourceUrl.toString());
        }
      }
      else {
        log.trace("skipping unavailable jpdl activities resource: " + activityResource);
      }
    }
  }

  protected Enumeration<URL> getResources(String resourceName) {
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    Enumeration<URL> resourceUrls;
    try {
      resourceUrls = classLoader.getResources(resourceName);

      if (!resourceUrls.hasMoreElements()) {
        resourceUrls = JpdlParser.class.getClassLoader().getResources(resourceName);
      }
    }
    catch (Exception e) {
      throw new JbpmException("couldn't get resource urls for " + resourceName, e);
    }
    return resourceUrls;
  }

  //解析xml格式的流程定义，并生成processDefinitionImpl
  public Object parseDocumentElement(Element documentElement, Parse parse) {
        JpdlProcessDefinition processDefinition = instantiateNewJpdlProcessDefinition();
        parse.contextStackPush(processDefinition);

             Bindings负责承载解析生成的节点的binding对象，并负责根据流程定义中的节点元素的tagName找到对相应的bingding对象（用于解析该节点元素）

            

public class Bindings {

  /** maps categories to a list of bindings */
  protected Map<String, List<Binding>> bindings = null;
  public Set<String> getTagNames(String category) {
    Set<String> tagNames = new HashSet<String>();

    List<Binding> categoryBindings = (bindings!=null ? bindings.get(category) : null );
    if (categoryBindings!=null) {
      for (Binding binding: categoryBindings) {
        tagNames.add(binding.toString());
      }
    }
    
    return tagNames;
  }
}

             JpdlBindingsParser 负责解析jbpm.jpdl.bindings.xml，并生成其中配置的binding实例

 

public class JpdlBindingsParser extends Parser {

  private static final Log log = Log.getLog(JpdlBindingsParser.class.getName());

  //解析jbpm.jpdl.bindings.xml中的xml
  public Object parseDocumentElement(Element documentElement, Parse parse) {
    Bindings bindings = (Bindings) parse.contextMapGet(Parse.CONTEXT_KEY_BINDINGS);
    parse.setDocumentObject(bindings);

    for (Element bindingElement : XmlUtil.elements(documentElement)) {
      Binding binding = instantiateBinding(bindingElement, parse);
      bindings.addBinding(binding);
    }

    return bindings;
  }

  //实例化jbpm.jpdl.bindings.xml中的元素中定义的binding类
  protected Binding instantiateBinding(Element bindingElement, Parse parse) {
    String bindingClassName = XmlUtil.attribute(bindingElement, "binding", parse);

    log.trace("adding jpdl binding "+bindingClassName);

    if (bindingClassName!=null) {
      try {
        Class<?> bindingClass = ReflectUtil.classForName(bindingClassName);
        TagBinding binding = (TagBinding) bindingClass.newInstance();

        String tagLocalName = bindingElement.getLocalName();
        if ("activity".equals(tagLocalName)) {
          binding.setCategory(JpdlParser.CATEGORY_ACTIVITY);
        } else if ("eventlistener".equals(tagLocalName)) {
          binding.setCategory(JpdlParser.CATEGORY_EVENT_LISTENER);
        } else {
          parse.addProblem("unrecognized binding tag: "+tagLocalName);
        }

        return binding;
      } catch (Exception e) {
        parse.addProblem("couldn't instantiate activity binding "+bindingClassName, e);
      }
    }
    return null;
  }
}

         初始化发布服务相关和初始化流程部署解析器相关

               流程的发布服务对外提供发布服务，我们可以通过调用该服务来完成流程的发布；流程部署解析器则主要负责xml格式流程定义的解析！ 

                流程部署解析器相关对象

              

               流程部署服务相关对象

              

               流程部署解析器和流程部署服务相关对象的UML图，由于两部分的管理比较紧密，所以UML图可能比较复杂

                

                下面我们同样结合UML中的类的代码来探究JBPM的实现

                 jbpm.cfg.xml定义了并导入JBPM中的各种配置文件，方便对配置文件的集中管理

               

<jbpm-configuration>

  <import resource="jbpm.default.cfg.xml" />
  <import resource="jbpm.businesscalendar.cfg.xml" />
  <import resource="jbpm.tx.hibernate.cfg.xml" />
  //流程定义JPDL的配置文件
  <import resource="jbpm.jpdl.cfg.xml" />
  <import resource="jbpm.bpmn.cfg.xml" />
  <import resource="jbpm.identity.cfg.xml" />

  <!-- Job executor is excluded for running the example test cases. -->
  <!-- To enable timers and messages in production use, this should be included. -->
  <!--
  <import resource="jbpm.jobexecutor.cfg.xml" />
  -->

</jbpm-configuration>

            jbpm.wire.bindings.xml定义了流程引擎需要使用的一些相关对象的binding，是JBPM 自身实现的IOC框架的重要组成部分

           

<wire-bindings> 
  
  <!-- hibernate bindings -->  
  <binding class="org.jbpm.pvm.internal.wire.binding.RepositorySessionBinding" />  
 
  <!-- services  -->  
  <binding class="org.jbpm.pvm.internal.wire.binding.RepositoryServiceBinding" />
  <binding class="org.jbpm.pvm.internal.wire.binding.RepositoryCacheBinding" />
  
  <!-- deployers -->
  <binding class="org.jbpm.pvm.internal.wire.binding.DeployerManagerBinding" />

  <!-- jpdl bindings -->
  <binding class="org.jbpm.jpdl.internal.xml.JpdlDeployerBinding" /> 
  

</wire-bindings>

        jbpm.default.cfg.xml 配置流程引擎的相关对象，配置需要立即实例化的对象会在解析配置文件的同时生成对象实例，否则仅根据相应的binding生成对象的descriptor实例，到实际使用时再延迟实例化

       

<?xml version="1.0" encoding="UTF-8"?>

<jbpm-configuration>

  <import resource="jbpm.default.scriptmanager.xml" />
  <import resource="jbpm.mail.templates.xml" />

  <process-engine-context>
    //部署服务
    <repository-service />

    //部署缓存对象
    <repository-cache />
    <execution-service />
    <history-service />
    <management-service />
    <identity-service />
    <task-service />

    <object class="org.jbpm.pvm.internal.id.DatabaseDbidGenerator">
      <field name="commandService"><ref object="newTxRequiredCommandService" /></field>
    </object>

    <object class="org.jbpm.pvm.internal.id.DatabaseIdComposer" init="eager" />
    
    <object class="org.jbpm.pvm.internal.el.JbpmElFactoryImpl" />

    <types resource="jbpm.variable.types.xml" />

    <address-resolver />
 
  </process-engine-context>

  <transaction-context>

    //部署持久化使用的对象
    <repository-session />
    <db-session />
    
    <message-session />
    <timer-session />
    
    <history-sessions>
      <object class="org.jbpm.pvm.internal.history.HistorySessionImpl" />
    </history-sessions>
    
    <mail-session>
      <mail-server>
        <session-properties resource="jbpm.mail.properties" />
      </mail-server>
    </mail-session>

  </transaction-context>

</jbpm-configuration>

         ConfigrationImpl作为流程引擎初始化的入口，几乎完成流程引擎所有所有的配置文件的解析，同时负责根据配置生成流程引擎对象

         

ublic class ConfigurationImpl extends Configuration {
  //流程引擎的默认配置文件
  public static final String DEFAULT_CONFIG_RESOURCENAME = "jbpm.cfg.xml";

  private static Log log = Log.getLog(ConfigurationImpl.class.getName());

  transient protected boolean isConfigured = false;
  transient String jndiName;
  transient boolean checkDb = true;
  transient boolean isSpringEnabled = false;
  // type is Object because we don't want a dependency on spring in this class
  transient Object applicationContext = null;
  //承载流程相关的descriptor
  transient WireContext processEngineWireContext = new WireContext(new WireDefinition(), Context.CONTEXTNAME_PROCESS_ENGINE, true);
  //承载事务相关的descriptor
  transient WireDefinition transactionWireDefinition = new WireDefinition();
  transient ProcessEngine producedProcessEngine;
  
  public ConfigurationImpl() {
    // to prevent a loop in the constructors, we need to delegate to a non-default constructor in Configuration
    super(null);
  }
  
  //构建流程引擎对象
  public ProcessEngine buildProcessEngine() {

          ConfigrationParser主要负责解析JBPM的配置文件并根据不同的标签调用不同的Parser

         

public class ConfigurationParser extends Parser {

  private static final long serialVersionUID = 1L;
  

  //解析配置文件中标签process-engine-context及其子元素
  Parser processEngineContextParser = new WireParser();
  //解析配置文件中标签transaction-context及其子元素
  Parser transactionContextParser = new WireParser();

  protected static ConfigurationParser INSTANCE = new ConfigurationParser();
  
  public static ConfigurationParser getInstance() {
    return INSTANCE;
  }

  //解析配置文件
  public Object parseDocument(Document document, Parse parse) {

          WireParser主要负责流程定义文件的具体解析，同时负责在首次运行之前解析jbpm.wire.bindings.xml

         

public class WireParser extends Parser {
  //默认的bindings配置文件
  public static final String[] DEFAULT_WIRE_BINDING_RESOURCES = new String[]{
    "jbpm.wire.bindings.xml",
    "jbpm.user.wire.bindings.xml"
  }; 

  private static final long serialVersionUID = 1L;
  
  private static final Log log = Log.getLog(WireParser.class.getName());

  //生成的descriptor的分类
  public static final String CATEGORY_DESCRIPTOR = "descriptor";
  public static final String CATEGORY_OPERATION = "operation";
  public static final String CATEGORY_INTERCEPTOR = "interceptor";


  private static WireParser instance;

  //承载jbpm.wire.bindings.xml中的binding实例
  private static Bindings defaultBindings; // initialized at the bottom of this file



 


  //解析配置文件
  public Object parseDocumentElement(Element documentElement, Parse parse) {
    List<Element> elements = XmlUtil.elements(documentElement);

    
    WireDefinition wireDefinition = parse.contextStackFind(WireDefinition.class);
    if (wireDefinition==null) {
      wireDefinition = new WireDefinition();
    }
    
    parse.contextStackPush(wireDefinition);
    try {
      for (Element descriptorElement: elements) {
        Descriptor descriptor = (Descriptor) parseElement(descriptorElement, parse, CATEGORY_DESCRIPTOR);
        
        // add the descriptor
        if ( (wireDefinition!=null)
             && (descriptor!=null)
           ) {
          wireDefinition.addDescriptor(descriptor);
        }
      }
    } finally {
      parse.contextStackPop();
    }

    return wireDefinition;
  }

  //解析jbpm.wire.bindings.xml
  static {
    // default descriptor parsers ///////////////////////////////////////////////
    defaultBindings = new Bindings();
    
    BindingParser bindingParser = new BindingParser();
 
    for (String wireResource: DEFAULT_WIRE_BINDING_RESOURCES) {
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
      Enumeration<URL> resourceUrls;
      try {
        resourceUrls = classLoader.getResources(wireResource);

        if (!resourceUrls.hasMoreElements()) {
          resourceUrls = WireParser.class.getClassLoader().getResources(wireResource);
        }
      } catch (Exception e) {
        throw new JbpmException("couldn't get resource urls for "+wireResource, e);
      }
      if (resourceUrls.hasMoreElements()) {
        while (resourceUrls.hasMoreElements()) {
          URL resourceUrl = resourceUrls.nextElement();
          log.trace("loading wire bindings from resource: "+resourceUrl);
          bindingParser.createParse()
            .setUrl(resourceUrl)
            .contextStackPush(defaultBindings)
            .execute()
            .checkErrors(resourceUrl.toString());
        }
      } else {
        log.trace("skipping unavailable wire bindings resource "+wireResource);
      }
    }
  }

           BindingParser主要负责jbpm.wire.bindings.xml

          

public class BindingParser extends Parser {

  private static final Log log = Log.getLog(BindingParser.class.getName());

  public Object parseDocumentElement(Element documentElement, Parse parse) {
    List<Element> elements = XmlUtil.elements(documentElement, "binding");
    for (Element bindingElement : elements) {
      String bindingClassName = XmlUtil.attribute(bindingElement, "class");

      log.trace("adding wire binding for "+bindingClassName);

      Binding binding = null;
      if (bindingClassName!=null) {
        try {
          Class<?> bindingClass = ReflectUtil.classForName(bindingClassName);
          binding = (Binding) bindingClass.newInstance();
        } catch (Exception e) {
          log.trace("couldn't instantiate binding "+bindingClassName);
        }
      } else {
        parse.addProblem("class is a required attribute in a binding "+XmlUtil.toString(bindingElement), documentElement);
      }

      if (binding!=null) {
        Bindings bindings = parse.contextStackFind(Bindings.class);
        bindings.addBinding(binding);
      }
    }

    return null;
  }
}

         ProcessEnginImpl持有流程解析配置文件形成的相关对象，对外提供相关服务，可以获取相关的对象，为事务提供环境对象实例

        

public class ProcessEngineImpl implements Context, ProcessEngine, EnvironmentFactory, Serializable {

  private static final long serialVersionUID = 1L;
  private static final Log log = Log.getLog(ProcessEngineImpl.class.getName());
  
  public static final String JBPM_LIBRARY_VERSION = "4.4-SNAPSHOT";

  //持有流程引擎解析配置文件形成的对象
  transient protected WireContext processEngineWireContext;
  transient protected WireDefinition transactionWireDefinition;
  
  transient protected ThreadLocal<List<UserProvidedEnvironmentObject>> userProvidedEnvironmentObjectsThreadLocal = new ThreadLocal<List<UserProvidedEnvironmentObject>>();
  transient protected ThreadLocal<String> authenticatedUserIdThreadLocal = new ThreadLocal<String>();
  
  transient protected CommandService userCommandService = null;
  
  public ProcessEngineImpl() {
  }

 


  //对外提供各种服务
  public ExecutionService getExecutionService() {
    return get(ExecutionService.class);
  }
  public HistoryService getHistoryService() {
    return get(HistoryService.class);
  }
  public ManagementService getManagementService() {
    return get(ManagementService.class);
  }
  public TaskService getTaskService() {
    return get(TaskService.class);
  }
  public IdentityService getIdentityService() {
    return get(IdentityService.class);
  }
  public RepositoryService getRepositoryService() {
    return get(RepositoryService.class);
  }

  //提供与事务相关的环境对象
  public EnvironmentImpl openEnvironment() {
    PvmEnvironment environment = new PvmEnvironment(this);

    if (log.isTraceEnabled()) log.trace("opening " + environment);

    installAuthenticatedUserId(environment);
    installProcessEngineContext(environment);
    installTransactionContext(environment);

    return environment;
  }

  
  

 
  //获取流程需要使用的相关对象
  public Object get(String key) {
    return processEngineWireContext.get(key);
  }

  public <T> T get(Class<T> type) {
    return processEngineWireContext.get(type);
  }

  public String getName() {
    return processEngineWireContext.getName();
  }

  public boolean has(String key) {
    return processEngineWireContext.has(key);
  }

  public Set<String> keys() {
    return processEngineWireContext.keys();
  }

  public Object set(String key, Object value) {
    return processEngineWireContext.set(key, value);
  }
  
 

 

  public <T> T execute(Command<T> command) {
    return userCommandService.execute(command);
  }

  
}

        EnvironmentImpl主要为具体的一次事务提供上下文环境，并提供获取相关对象的方法

       

public abstract class EnvironmentImpl implements Serializable, Environment {

  private static final long serialVersionUID = 1L;

 
  public abstract Object get(String name);

 
  public abstract Object get(String name, String[] searchOrder);
  
  public abstract Object get(String name,String[] searchOrder, boolean nullAllowed) throws JbpmException;
  
  public abstract Object get(String name, boolean nullAllowed) throws JbpmException;

  public abstract <T> T get(Class<T> type); 
 
  public abstract <T> T get(Class<T> type, String[] searchOrder);

 
  static ThreadLocal<EnvironmentImpl> currentEnvironment = new ThreadLocal<EnvironmentImpl>();  
  static ThreadLocal<Stack<EnvironmentImpl>> currentEnvironmentStack = new ThreadLocal<Stack<EnvironmentImpl>>();

  public static EnvironmentImpl getCurrent() {
    return currentEnvironment.get();
  }
  
  public static <T> T getFromCurrent(Class<T> type) {
    return getFromCurrent(type, true);
  }

  public static <T> T getFromCurrent(Class<T> type, boolean required) {
    EnvironmentImpl environment = getCurrent();
    if (environment==null) {
      if (required) {
        throw new JbpmException("no environment to get "+type.getName());
      }
      return null;
    }
    T object = environment.get(type);
    if (object==null) {
      if (required) {
        throw new JbpmException("no "+type.getName()+" in current environment");
      }
      return null;
    }
    return object;
  }


  public static Object getFromCurrent(String name, boolean required) {
    EnvironmentImpl environment = getCurrent();
    if (environment==null) {
      if (required) {
        throw new JbpmException("no environment to get '"+name+"'");
      }
      return null;
    }
    Object object = environment.get(name);
    if (object==null) {
      if (required) {
        throw new JbpmException("no '"+name+"' in current environment");
      }
      return null;
    }
    return object;
  }

  static Stack<EnvironmentImpl> getStack() {
    // lazy initialize the current environment stack
    Stack<EnvironmentImpl> stack = currentEnvironmentStack.get();
    if (stack==null) {
      stack = new Stack<EnvironmentImpl>();
      currentEnvironmentStack.set(stack);
    }
    return stack;
  }



}

          jbpm.jpdl.cfg.xml配置流程部署管理者和部署解析器

         

<jbpm-configuration>

  <process-engine-context>
    //部署管理者
    <deployer-manager>
      //部署解析器
      <jpdl-deployer />
      <object class="org.jbpm.pvm.internal.repository.RulesDeployer" />
    </deployer-manager>
    
  </process-engine-context>

</jbpm-configuration>

        DeployManager 负责调用部署解析器解析xml流程定义，并管理生成的流程定义进行缓存

        

public class DeployerManager {
  
  private static Log LOG = Log.getLog(DeployerManager.class.getName());
  
  List<Deployer> deployers;
  
  public void deploy(DeploymentImpl deployment) {
    deployment.setProblems(new ArrayList<Problem>());
    //调用部署解析器
    for (Deployer deployer: deployers) {
      deployer.deploy(deployment);
    }
    
    if (deployment.hasErrors()) {
      JbpmException jbpmException = deployment.getJbpmException();
      LOG.info("errors during deployment of "+deployment+": "+jbpmException.getMessage());
      throw  jbpmException;
    }
    //缓存流程定义
    RepositoryCache repositoryCache = EnvironmentImpl.getFromCurrent(RepositoryCache.class);
    
    if (repositoryCache != null) {
      
      // If there are no objects after deploying, then there is something wrong
      if (deployment.getObjects() == null || deployment.getObjects().isEmpty()) {
        
        if (LOG.isWarnEnabled()) {
          LOG.warn("WARNING: no objects were deployed! Check if you have configured a correct deployer " 
                  +"in your jbpm.cfg.xml file for the type of deployment you want to do.");
        }
        
      } else {
        
        repositoryCache.set(deployment.getId(), deployment.getObjects());
        
      }
    }
  }

  //更新流程定义
  public void updateResource(DeploymentImpl deployment, String resourceName, byte[] bytes) {
    for (Deployer deployer: deployers) {
      deployer.updateResource(deployment, resourceName, bytes);
    }
    
    RepositoryCache repositoryCache = EnvironmentImpl.getFromCurrent(RepositoryCache.class);
    repositoryCache.remove(deployment.getId());
  }
}

          RepositoryService主要对外提供部署服务接口

          

public class RepositoryServiceImpl extends AbstractServiceImpl implements RepositoryService {

  public NewDeployment createDeployment() {
    return new DeploymentImpl(commandService);
  }

  public void suspendDeployment(String deploymentId) {
    commandService.execute(new SuspendDeploymentCmd(deploymentId));
  }

  public void resumeDeployment(String deploymentId) {
    commandService.execute(new ResumeDeploymentCmd(deploymentId));
  }

  public void deleteDeployment(String deploymentId) {
    commandService.execute(new DeleteDeploymentCmd(deploymentId));
  }

         RepositorySessionImpl主要负责流程部署的持久化，持有一些部署相关的对象

        

public class RepositorySessionImpl implements RepositorySession {
  
  private static Log log = Log.getLog(RepositorySessionImpl.class.getName());
  
  protected Session session;
  protected RepositoryCache repositoryCache;
  protected DeployerManager deployerManager;

  public String deploy(NewDeployment deployment) {
    DeploymentImpl deploymentImpl = (DeploymentImpl) deployment;
    
    long dbid = DbidGenerator.getDbidGenerator().getNextId();
    deploymentImpl.setDbid(dbid);
    deploymentImpl.initResourceLobDbids();
    
    session.save(deploymentImpl); // will also save the attached resources
    deployerManager.deploy(deploymentImpl);

    return deploymentImpl.getId();
  }

        RepositoryCacheImpl 封装集合对流程定义进行缓存

       

public class RepositoryCacheImpl implements RepositoryCache {
  
  Map<String, Map<String, Object>> deployments = new HashMap<String, Map<String,Object>>();
  Map<Object, DeploymentClassLoader> deploymentClassLoaders = new HashMap<Object, DeploymentClassLoader>();

  public Object get(String deploymentId, String objectName) {
    Map<String, Object> deploymentObjects = deployments.get(deploymentId);
    if (deploymentObjects==null) {
      return null;
    }
    return deploymentObjects.get(objectName);
  }

  public void set(String deploymentId, String key, Object cachedObject) {
    Map<String, Object> objects = new HashMap<String, Object>();
    objects.put(key, cachedObject);
    set(deploymentId, objects);
  }

         流程引擎的部署环境的初始化涉及流程引擎的各个方面，相对比较复杂，就简单介绍到这里，接下来我们将结合部署环境的初始化进行扩展自定义！