JBPM深入解析之变量设计

JBPM深入解析之变量设计

      在流程的流转的过程中，很多时候我们需要根据不同的实际情况传入一些初始化数据，以便完成我们个性化的业务需求；同时很多时候我们需要在不同的节点之间共享一些业务数据，特别是一些节点要以前一节点的输出作为输入等；变量对于流程引擎来说很重要，可以说没有变量，那么我们就不能运行时动态的设置和传入一些数据，这将极大的限制流程的灵活性！
      变量类型
       全局变量，所有的节点都可以获取并设置该变量的值
       局部变量，只在该节点及其子节点可以获取并设置该变量的值
      变量的传入
       在流程定义中进行变量的定义

      

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

<process name="EndMultiple" xmlns="http://jbpm.org/4.4/jpdl">

  <start g="16,96,48,48">
    <transition to="get return code" name=""/>
  </start>

  <state g="96,94,111,52" name="get return code">
    <transition g="151,60:-36,11" name="200" to="ok"/>
    <transition g=":-16,-27" name="400" to="bad request"/>
    <transition g="151,183:-33,-32" name="500" to="internal server error"/>
  </state>

  <end g="238,37,48,48" name="ok"/>
  <end g="238,98,48,48" name="bad request"/>
  <end g="240,160,48,48" name="internal server error"/>
  
  <variable    name="msg" init-expr="jbpm" type="string">      
  </variable>
  
      <null></null>
</variable>

</process>

       在启动流程流程实例的时候传入全局变量

    Map<String, Object> variables = new HashMap<String, Object>();
    variables.put("category", "big");
    variables.put("dollars", 100000);
    Execution execution = executionService.startProcessInstanceByKey("TaskVariables", variables);

       在唤醒那些可外部唤醒类型的节点时候传入局部变量

       

    variables = new HashMap<String, Object>();
    variables.put("category", "small");
    variables.put("lires", 923874893);
    taskService.completeTask(taskId, variables)

       在任务存在的情况下，可以在任务等待外部唤醒时进行局部变量的设置

    variables = new HashMap<String, Object>();
    variables.put("category", "small");
    variables.put("lires", 923874893);    
    taskService.setVariables(taskId, variables);

       在任何时候都可以通过执行服务传入设置全局变量

      

    variables = new HashMap<String, Object>();
    variables.put("category", "small");
    variables.put("lires", 923874893);    
    executionService.setVariable(execution.getId(),variables)

    variables = new HashMap<String, Object>();
    variables.put("category", "small");
    variables.put("lires", 923874893);    
    executionService.signalExecutionById(execution.getId(),variables);

      变量架构设计  

      
      TypeSet、DefaultTypeSet
      TypeSet定义了流程引擎中通过变量类型和matcher两种方式查找变量类型的接口；DefaultTypeSet对TypeSet的接口进行了实现，并定义了一个List<TypeMapping>来装载所有的变量类型的映射变量实例。
      TypeSet

     

package org.jbpm.pvm.internal.type;


/**
 * @author Tom Baeyens
 */
public interface TypeSet {

  Type findTypeByMatch(String key, Object value);
  Type findTypeByName(String typeName);

}

      DefaultTypeSet

     

package org.jbpm.pvm.internal.type;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;


/**
 * @author Tom Baeyens
 */
public class DefaultTypeSet implements TypeSet, Serializable {

  private static final long serialVersionUID = 1L;

  protected List<TypeMapping> typeMappings;

  public Type findTypeByMatch(String key, Object value) {
    if (typeMappings!=null) {
      for (TypeMapping typeMapping: typeMappings) {
        if (typeMapping.matches(key, value)) {
          return typeMapping.getType();
        }
      }
    }
    
    return null;
  }

  public Type findTypeByName(String typeName) {
    if ( (typeMappings!=null)
           && (typeName!=null)
       ) {
      for (TypeMapping typeMapping: typeMappings) {
        Type type = typeMapping.getType();
        if (typeName.equals(type.getName())) {
          return type;
        }
      }
    }
    return null;
  }

  public void addTypeMapping(TypeMapping typeMapping) {
    if (typeMappings==null) {
      typeMappings = new ArrayList<TypeMapping>();
    }
    typeMappings.add(typeMapping);
  }
}

       TypeSet的初始化     在配置文件中配置流程引擎中需要使用的变量的类型

       Jbpm.defaut.cfg.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>

       Jbpm.variable.types.xml定义了变量的类型、使用的转换器等信息

      

<types>

  <!-- types stored in a native column -->
  <type name="string" class="java.lang.String" variable-class="org.jbpm.pvm.internal.type.variable.StringVariable" />
  <type name="long"   class="java.lang.Long" variable-class="org.jbpm.pvm.internal.type.variable.LongVariable" />
  <type name="double" class="java.lang.Double" variable-class="org.jbpm.pvm.internal.type.variable.DoubleVariable" />

  <!-- types converted to a string -->
  <type name="date"    class="java.util.Date" converter="org.jbpm.pvm.internal.type.converter.DateToStringConverter" variable-class="org.jbpm.pvm.internal.type.variable.StringVariable" />
  <type name="boolean" class="java.lang.Boolean" converter="org.jbpm.pvm.internal.type.converter.BooleanToStringConverter" variable-class="org.jbpm.pvm.internal.type.variable.StringVariable" />
  <type name="char"    class="java.lang.Character" converter="org.jbpm.pvm.internal.type.converter.CharacterToStringConverter" variable-class="org.jbpm.pvm.internal.type.variable.StringVariable" />

  <!-- types converted to a long -->
  <type name="byte"    class="java.lang.Byte" converter="org.jbpm.pvm.internal.type.converter.ByteToLongConverter" variable-class="org.jbpm.pvm.internal.type.variable.LongVariable" />
  <type name="short"   class="java.lang.Short" converter="org.jbpm.pvm.internal.type.converter.ShortToLongConverter" variable-class="org.jbpm.pvm.internal.type.variable.LongVariable" />
  <type name="integer" class="java.lang.Integer" converter="org.jbpm.pvm.internal.type.converter.IntegerToLongConverter" variable-class="org.jbpm.pvm.internal.type.variable.LongVariable" />

  <!-- types converted to a double -->
  <type name="float" class="java.lang.Float" converter="org.jbpm.pvm.internal.type.converter.FloatToDoubleConverter" variable-class="org.jbpm.pvm.internal.type.variable.DoubleVariable" />

  <!-- byte[] and char[] -->
  <type name="byte[]" class="[B" variable-class="org.jbpm.pvm.internal.type.variable.BlobVariable" />
  <type name="char[]" class="[C" variable-class="org.jbpm.pvm.internal.type.variable.TextVariable" />

  <type name="hibernate-long-id"   class="hibernatable" id-type="long" variable-class="org.jbpm.pvm.internal.type.variable.HibernateLongVariable" />
  <type name="hibernate-string-id" class="hibernatable" id-type="string" variable-class="org.jbpm.pvm.internal.type.variable.HibernateStringVariable" />

  <type name="serializable" class="serializable" converter="org.jbpm.pvm.internal.type.converter.SerializableToBytesConverter" variable-class="org.jbpm.pvm.internal.type.variable.BlobVariable" />

  <!-- TODO: add ejb3 entity bean support -->
  <!-- TODO: add JCR activity support -->
  <!-- TODO: add collection support -->
  
</types>

         TypesBinding解析jbpm.variable.types.xml中的变量类型定义        

       

public class TypesBinding extends WireDescriptorBinding {

  public TypesBinding() {
    super("types");
  }

  public Object parse(Element element, Parse parse, Parser parser) {
    StreamInput streamSource = null;
    //查找type文件    
    if (element.hasAttribute("file")) {
      String fileName = element.getAttribute("file");
      File file = new File(fileName);
      if (file.exists() && file.isFile()) {
        streamSource = new FileStreamInput(file);
        parser.importStream(streamSource, element, parse);
      } else {
        parse.addProblem("file "+fileName+" isn't a file", element);
      }
    }

    if (element.hasAttribute("resource")) {
      String resource = element.getAttribute("resource");
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
      streamSource = new ResourceStreamInput(resource, classLoader);
      parser.importStream(streamSource, element, parse);
    }

    if (element.hasAttribute("url")) {
      String urlText = element.getAttribute("url");
      try {
        URL url = new URL(urlText);
        streamSource = new UrlStreamInput(url);
        parser.importStream(streamSource, element, parse);
      } catch (Exception e) {
        parse.addProblem("couldn't open url "+urlText, e);
      }
    }

    TypesDescriptor typesDescriptor = new TypesDescriptor();

    List<Element> typeElements = XmlUtil.elements(element, "type");
    for (Element typeElement: typeElements) {
      TypeMapping typeMapping = parseTypeMapping(typeElement, parse, parser);
      typesDescriptor.addTypeMapping(typeMapping);
    }
    return typesDescriptor;
  }

  protected TypeMapping parseTypeMapping(Element element, Parse parse, Parser parser) {
    TypeMapping typeMapping = new TypeMapping();
    Type type = new Type();
    typeMapping.setType(type);

    // type name
    //类型名称
    if (element.hasAttribute("name")) {
      type.setName(element.getAttribute("name"));
    }

    String hibernateSessionFactoryName = XmlUtil.attribute(element, "hibernate-session-factory");

    // first we get the matcher
    Matcher matcher = null;
    if (element.hasAttribute("class")) {
      String className = element.getAttribute("class");

      // if type="serializable"
      if ("serializable".equals(className)) {
        matcher = new SerializableMatcher();

      // if type="hibernatable"
      } else if ("hibernatable".equals(className)) {
        if (element.hasAttribute("id-type")) {
          String idType = element.getAttribute("id-type");
          if ("long".equalsIgnoreCase(idType)) {
            matcher = new HibernateLongIdMatcher(hibernateSessionFactoryName);
          } else if ("string".equalsIgnoreCase(idType)) {
            matcher = new HibernateStringIdMatcher(hibernateSessionFactoryName);
          } else {
            parse.addProblem("id-type was not 'long' or 'string': "+idType, element);
          }
        } else {
          parse.addProblem("id-type is required in a persistable type", element);
        }

      // otherwise, we expect type="some.java.ClassName"
      } else {
        matcher = new ClassNameMatcher(className);
      }

    } else {
      // look for the matcher element
      Element matcherElement = XmlUtil.element(element, "matcher");
      Element matcherObjectElement = XmlUtil.element(matcherElement);
      if (matcherObjectElement!=null) {
        try {
          Descriptor descriptor = (Descriptor) parser.parseElement(matcherObjectElement, parse);
          matcher = (Matcher) WireContext.create(descriptor);
        } catch (ClassCastException e) {
          parse.addProblem("matcher is not a "+Matcher.class.getName()+": "+(matcher!=null ? matcher.getClass().getName() : "null"), element);
        }
      } else {
        parse.addProblem("no matcher specified in "+XmlUtil.toString(element), element);
      }
    }

    typeMapping.setMatcher(matcher);

    // parsing the converter
    Converter converter = null;
    if (element.hasAttribute("converter")) {
      String converterClassName = element.getAttribute("converter");
      try {
        Class<?> converterClass = ReflectUtil.classForName(converterClassName);
        converter = (Converter) converterClass.newInstance();
      } catch (Exception e) {
        parse.addProblem("couldn't instantiate converter "+converterClassName, element);
      }
    } else {
      // look for the matcher element
      Element converterElement = XmlUtil.element(element, "converter");
      Element converterObjectElement = XmlUtil.element(converterElement);
      if (converterObjectElement!=null) {
        try {
          converter = (Converter) parser.parseElement(converterObjectElement, parse);
        } catch (ClassCastException e) {
          parse.addProblem("converter is not a "+Converter.class.getName()+": "+(converter!=null ? converter.getClass().getName() : "null"), element);
        }
      }
    }

    type.setConverter(converter);

    // parsing the variable class

    Class<?> variableClass = null;
    if (element.hasAttribute("variable-class")) {
      String variableClassName = element.getAttribute("variable-class");
      try {
        variableClass = ReflectUtil.classForName(variableClassName);
      } catch (Exception e) {
        parse.addProblem("couldn't instantiate variable-class "+variableClassName, e);
      }
    } else {
      parse.addProblem("variable-class is required on a type: "+XmlUtil.toString(element), element);
    }

    type.setVariableClass(variableClass);

    return typeMapping;
  }
}

        TypeDescriptor用于运行时生成DefaultTypeSet
        

public class TypesDescriptor extends AbstractDescriptor {

  private static final long serialVersionUID = 1L;
  
  DefaultTypeSet defaultTypeSet = new DefaultTypeSet();
  
  public Object construct(WireContext wireContext) {
    return defaultTypeSet;
  }
  
  public Class< ? > getType(WireDefinition wireDefinition) {
    return DefaultTypeSet.class;
  }

  public void addTypeMapping(TypeMapping typeMapping) {
    defaultTypeSet.addTypeMapping(typeMapping);
  }
  
  public DefaultTypeSet getDefaultTypeSet() {
    return defaultTypeSet;
  }
}

 
        TypeMapping作为映射器，负责承载变量的类型和matcher
      

public class TypeMapping implements Serializable {

  Matcher matcher;
  Type type;

  private static final long serialVersionUID = 1L;
  
  public boolean matches(String name, Object value) {
    return matcher.matches(name, value);
  }
  
  public String toString() {
    return "("+matcher+"-->"+type+")";
  }
  
  public void setMatcher(Matcher matcher) {
    this.matcher = matcher;
  }
  public Type getType() {
    return type;
  }
  public void setType(Type type) {
    this.type = type;
  }
  public Matcher getMatcher() {
    return matcher;
  }
}

 

      Matcher，递归查询给定变量的类型以及所有的基类中是否有与该Matcher对应的类的变量类型相同的。
     

public class ClassNameMatcher implements Matcher {

  private static final long serialVersionUID = 1L;
  
  String className = null;
  
  public ClassNameMatcher(String className) {
    this.className = className;
  }
  
  public String toString() {
    return className;
  }

  public boolean matches(String name, Object value) {
    if (value==null) {
      return true;
    }
    
    Class<?> valueClass = value.getClass();
    
    while (valueClass!=null) {
      if (className.equals(value.getClass().getName())) {
        return true;
      } else {
        Class<?>[] interfaces = valueClass.getInterfaces();
        for (int i=0; i<interfaces.length; i++) {
          if (className.equals(interfaces[i].getName())) {
            return true;
          }
        }
        valueClass = valueClass.getSuperclass();
      }
    }
    return false;
  }
}

        Type 定义变量类型的名称、转换器和对应的Variable

        

public class Type implements Serializable {

  private static final long serialVersionUID = 1L;
  
  protected String name;
  protected Converter converter;
  protected Class<?> variableClass;

  public String toString() {
    if (name!=null) {
      return name;
    }
    StringBuilder text = new StringBuilder();
    if (converter!=null) {
      text.append(converter.toString());
      text.append("-->");
    }
    if (variableClass!=null) {
      text.append(variableClass.getSimpleName());
    } else {
      text.append("undefined");
    }
    return text.toString();
  }
  
  public Converter getConverter() {
    return converter;
  }
  public void setConverter(Converter converter) {
    this.converter = converter;
  }
  public Class< ? > getVariableClass() {
    return variableClass;
  }
  public void setVariableClass(Class< ? > variableClass) {
    this.variableClass = variableClass;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
}

       Converter，负责变量运行时的表现形式和持久化形式进行转化
      

public class SerializableToBytesConverter implements Converter {

  private static final long serialVersionUID = 1L;
  
  public boolean supports(Object value, ScopeInstanceImpl scopeInstance, Variable variable) {
    if (value==null) return true;
    return Serializable.class.isAssignableFrom(value.getClass());
  }

  public Object convert(Object o, ScopeInstanceImpl scopeInstance, Variable variable) {
    byte[] bytes = null;
    try {
      ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
      ObjectOutputStream oos = new ObjectOutputStream(baos);
      oos.writeObject(o);
      oos.flush();
      bytes = baos.toByteArray();

      Transaction transaction = EnvironmentImpl.getFromCurrent(Transaction.class, false);
      if (transaction!=null) {
        transaction.registerDeserializedObject(new DeserializedObject(o, scopeInstance, (BlobVariable) variable));
      }
      
    } catch (IOException e) {
      throw new JbpmException("couldn't serialize '"+o+"'", e);
    }
    
    return bytes;
  }

  public Object revert(Object o, ScopeInstanceImpl scopeInstance, Variable variable) {
    byte[] bytes = (byte[]) o;
    try {
      ByteArrayInputStream bais = new ByteArrayInputStream(bytes);

      ObjectInputStream ois = null;
     
      ois = new DeploymentObjectInputStream(bais, scopeInstance.getExecution().getProcessDefinition().getDeploymentId());
      
      Object object = ois.readObject();
      
      Transaction transaction = EnvironmentImpl.getFromCurrent(Transaction.class, false);
      if (transaction!=null) {
        transaction.registerDeserializedObject(new DeserializedObject(object, scopeInstance, (BlobVariable) variable));
      }
      
      return object;

    } catch (Exception e) {
      throw new JbpmException("couldn't deserialize object", e);
    }
  }
}

        Variable，定义具体的变量以及一些持久化需要的属性

       

public class StringVariable extends Variable {
  
  private static final long serialVersionUID = 1L;
  
  protected String string = null;

  public boolean isStorable(Object value) {
    if (value==null) return true;
    return (String.class==value.getClass());
  }

  public Object getObject() {
    return string;
  }

  public void setObject(Object value) {
    this.string = (String) value;
    if (value!=null) {
      this.textValue = string;
    } else {
      this.textValue = null;
    }
  }
}