definitionparser.java

一个java工作流引擎

package org.jbpm.par;

import java.io.*;
import java.util.*;
import org.apache.commons.logging.*;
import org.dom4j.*;
import org.dom4j.Element;
import org.dom4j.io.*;
import org.jbpm.*;
import org.jbpm.util.lang.*;
import org.jbpm.model.definition.*;
import org.jbpm.model.definition.impl.*;
import org.xml.sax.*;

public class DefinitionParser {

  private List errors = null;
  private InputStream inputStream = null;
  private DefinitionImpl definition = null;
  private Collection unresolvedReferences = null;
  private Map names = null;

  public static DefinitionImpl parse(InputStream inputStream) throws JpdlException {
    return parse(inputStream, true);
  }

  public static DefinitionImpl parse(InputStream inputStream, boolean validateDefinition) throws JpdlException {
    DefinitionImpl definition = new DefinitionParser(inputStream).parse();
    if (validateDefinition) {
      List errors = DefinitionValidator.validate(definition);
      if (errors.size() > 0) {
        throw new JpdlException(errors);
      }
    }
    return definition;
  }

  private DefinitionParser(InputStream inputStream) throws JpdlException {
    this.errors = new ArrayList();
    this.names = new HashMap();
    this.unresolvedReferences = new ArrayList();
    this.inputStream = inputStream;
  }

  private DefinitionImpl parse() throws JpdlException {
    DefinitionImpl definition = null;
    try {

      SAXReader saxReader = new SAXReader();

      saxReader.setEntityResolver(new EntityResolver() {
        public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
          InputSource inputSource = null;
          if (DocType.getPublicDocTypeId().equals(publicId)) {
            InputStream is = DefinitionParser.class.getClassLoader().getResourceAsStream("processdefinition-2.0-beta1.dtd");
            inputSource = new InputSource(is);
          }
          return inputSource;
        }
      });

      saxReader.setErrorHandler(new ErrorHandler() {
        public void error(SAXParseException e) throws SAXException {
          errors.add("XML-validation-error: " + e.getMessage() + " (processdefinition.xml:" + e.getLineNumber() + ")");
        }
        public void fatalError(SAXParseException e) throws SAXException {
          errors.add("XML-validation-fatal-error: " + e.getMessage() + " (processdefinition.xml:" + e.getLineNumber() + ")");
        }
        public void warning(SAXParseException e) throws SAXException {
          errors.add("XML-validation-warning: " + e.getMessage() + " (processdefinition.xml:" + e.getLineNumber() + ")");
        }
      });

      saxReader.setValidation(true);
      Document document = saxReader.read(inputStream);

      definition = parseDefinition(document.getRootElement());

    } catch (DocumentException e) {
      errors.add(e);
    }

    if (errors.size() > 0) {
      throw new JpdlException(errors);
    }

    return definition;
  }

  private DefinitionImpl parseDefinition(Element definitionXml) {

    // definition
    definition = new DefinitionImpl();
    definition.setName(getAttribute(definitionXml, "name"));
    definition.setDescription(getElementText(definitionXml, "description", null));

    // swimlane
    Iterator iter = definitionXml.elementIterator("swimlane");
    while (iter.hasNext()) {
      definition.add(parseSwimlane((Element) iter.next()));
    }

    // variables
    iter = definitionXml.elementIterator("type");
    while (iter.hasNext()) {
      definition.add(parseType((Element) iter.next()));
    }

    // start-state
    definition.setStartState(parseStartState(definitionXml.element("start-state")));

    // end-state
    definition.setEndState(parseEndState(definitionXml.element("end-state")));

    // state
    iter = definitionXml.elementIterator("state");
    while (iter.hasNext()) {
      definition.add(parseState((Element) iter.next()));
    }

    // process-state
    iter = definitionXml.elementIterator("process-state");
    while (iter.hasNext()) {
      definition.add(parseProcessState((Element) iter.next()));
    }

    // decision
    iter = definitionXml.elementIterator("decision");
    while (iter.hasNext()) {
      definition.add(parseDecision((Element) iter.next()));
    }

    // fork
    iter = definitionXml.elementIterator("fork");
    while (iter.hasNext()) {
      definition.add(parseFork((Element) iter.next()));
    }

    // join
    iter = definitionXml.elementIterator("join");
    while (iter.hasNext()) {
      definition.add(parseJoin((Element) iter.next()));
    }

    // actions
    parseActions(definition, definitionXml);

    // resolve the referenced transition destinations
    resolveReferences();

    return definition;
  }
  private SwimlaneImpl parseSwimlane(Element swimlaneXml) {
    SwimlaneImpl swimlane = new SwimlaneImpl(getAttribute(swimlaneXml, "name"));
    addName(NameType.SWIMLANE, swimlane.getName());
    swimlane.setDescription(getElementText(swimlaneXml, "description", null));
    swimlane.setAssignmentDelegation(parseDelegation(swimlaneXml));
    return swimlane;
  }

  private DelegationImpl getActorDelegation(Element actorXml, String attributeName, String className, boolean setAttributeValueInConfiguration) {
    DelegationImpl delegation = null;
    String attributeValue = getAttribute(actorXml, attributeName, null);
    if (attributeValue != null) {
      delegation = new DelegationImpl(definition, className);
      if (setAttributeValueInConfiguration)
        delegation.setConfiguration(attributeValue);
    }
    return delegation;
  }

  private TypeImpl parseType(Element typeXml) {
    TypeImpl type = new TypeImpl(getAttribute(typeXml, "java-type", null));
    addName(NameType.JAVATYPE, type.getJavaType());
    type.setDescription(getElementText(typeXml, "description", null));

    if (typeXml.element("transient") == null) {
      type.setSerializerDelegation(parseDelegation(typeXml));
    }

    Iterator iter = typeXml.elementIterator("variable");
    while (iter.hasNext()) {
      Element variableXml = (Element) iter.next();
      VariableImpl variable = definition.add(new VariableImpl(type, getAttribute(variableXml, "name")));
      addName(NameType.VARIABLE, variable.getName());
    }
    return type;
  }

  private StartStateImpl parseStartState(Element startStateXml) {
    StartStateImpl startState = new StartStateImpl(getAttribute(startStateXml, "name"));
    addName(NameType.NODE, startState.getName());
    startState.setDescription(getElementText(startStateXml, "description", null));
    resolveSwimlane(startState, startStateXml);
    parseTransitions(startState, startStateXml);
    parseActions(startState, startStateXml);
    return startState;
  }

  private EndStateImpl parseEndState(Element endStateXml) {
    EndStateImpl endState = new EndStateImpl(getAttribute(endStateXml, "name"));
    addName(NameType.NODE, endState.getName());
    endState.setDescription(getElementText(endStateXml, "description", null));
    return endState;
  }

  private NodeImpl parseJoin(Element joinXml) {
    JoinImpl join = new JoinImpl(getAttribute(joinXml, "name"));
    addName(NameType.NODE, join.getName());
    join.setDescription(getElementText(joinXml, "description", null));
    DelegationImpl joinDelegation = parseDelegation(joinXml);
    if (joinDelegation != null) {
      join.setJoinDelegation(joinDelegation);
    } else {
      // set the corresponding fork for validation purposes
      unresolvedReferences.add(new UnresolvedJoin(join, getAttribute(joinXml, "corresponding-fork", null)));
    }
    parseTransitions(join, joinXml);
    parseActions(join, joinXml);
    return join;
  }

  private NodeImpl parseFork(Element forkXml) {
    ForkImpl fork = new ForkImpl(getAttribute(forkXml, "name"));