Java tutorial
/* * JBoss, Home of Professional Open Source * Copyright 2005, JBoss Inc., and individual contributors as indicated * by the @authors tag. See the copyright.txt in the distribution for a * full listing of individual contributors. * * This is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this software; if not, write to the Free * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA * 02110-1301 USA, or see the FSF site: http://www.fsf.org. */ package org.jbpm.graph.def; import java.io.IOException; import java.io.InputStream; import java.io.Reader; import java.io.StringReader; import java.net.URL; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.zip.ZipInputStream; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.xml.sax.InputSource; import org.jbpm.JbpmConfiguration.Configs; import org.jbpm.JbpmContext; import org.jbpm.JbpmException; import org.jbpm.context.def.ContextDefinition; import org.jbpm.file.def.FileDefinition; import org.jbpm.graph.exe.ProcessInstance; import org.jbpm.graph.node.ProcessFactory; import org.jbpm.graph.node.StartState; import org.jbpm.jpdl.JpdlException; import org.jbpm.jpdl.par.ProcessArchive; import org.jbpm.jpdl.xml.JpdlXmlReader; import org.jbpm.module.def.ModuleDefinition; import org.jbpm.taskmgmt.def.TaskMgmtDefinition; import org.jbpm.util.ClassLoaderUtil; public class ProcessDefinition extends GraphElement implements NodeCollection { private static final long serialVersionUID = 1L; protected int version = -1; protected boolean isTerminationImplicit; protected Node startState; protected List nodes; private transient Map nodesMap; protected Map actions; protected Map definitions; private static final Map moduleClassesByResource = new HashMap(); // event types ////////////////////////////////////////////////////////////// private static final String[] EVENT_TYPES = { Event.EVENTTYPE_PROCESS_START, Event.EVENTTYPE_PROCESS_END, Event.EVENTTYPE_NODE_ENTER, Event.EVENTTYPE_NODE_LEAVE, Event.EVENTTYPE_TASK_CREATE, Event.EVENTTYPE_TASK_ASSIGN, Event.EVENTTYPE_TASK_START, Event.EVENTTYPE_TASK_END, Event.EVENTTYPE_TRANSITION, Event.EVENTTYPE_BEFORE_SIGNAL, Event.EVENTTYPE_AFTER_SIGNAL, Event.EVENTTYPE_SUPERSTATE_ENTER, Event.EVENTTYPE_SUPERSTATE_LEAVE, Event.EVENTTYPE_SUBPROCESS_CREATED, Event.EVENTTYPE_SUBPROCESS_END, Event.EVENTTYPE_TIMER }; /** * @deprecated arrays are mutable and thus vulnerable to external manipulation. use * {@link #getSupportedEventTypes()} instead */ public static final String[] supportedEventTypes = (String[]) EVENT_TYPES.clone(); public String[] getSupportedEventTypes() { return (String[]) EVENT_TYPES.clone(); } // constructors ///////////////////////////////////////////////////////////// public ProcessDefinition() { processDefinition = this; } public static ProcessDefinition createNewProcessDefinition() { ProcessDefinition processDefinition = new ProcessDefinition(); // instantiate default modules List moduleClasses = getModuleClasses(); for (Iterator iter = moduleClasses.iterator(); iter.hasNext();) { Class moduleClass = (Class) iter.next(); try { ModuleDefinition moduleDefinition = (ModuleDefinition) moduleClass.newInstance(); processDefinition.addDefinition(moduleDefinition); } catch (InstantiationException e) { throw new JbpmException("failed to instantiate " + moduleClass, e); } catch (IllegalAccessException e) { throw new JbpmException(ProcessDefinition.class + " has no access to " + moduleClass, e); } } return processDefinition; } private static List getModuleClasses() { String resource = Configs.getString("resource.default.modules"); synchronized (moduleClassesByResource) { List moduleClasses = (List) moduleClassesByResource.get(resource); if (moduleClasses == null) { moduleClasses = loadModuleClasses(resource); moduleClassesByResource.put(resource, moduleClasses); } return moduleClasses; } } private static List loadModuleClasses(String resource) { Properties properties = ClassLoaderUtil.getProperties(resource); List moduleClasses = new ArrayList(); Log log = LogFactory.getLog(ProcessDefinition.class); boolean debug = log.isDebugEnabled(); for (Iterator iter = properties.keySet().iterator(); iter.hasNext();) { String moduleClassName = (String) iter.next(); try { Class moduleClass = ClassLoaderUtil.classForName(moduleClassName); moduleClasses.add(moduleClass); if (debug) log.debug("loaded module " + moduleClassName); } catch (ClassNotFoundException e) { if (debug) log.debug("module class not found: " + moduleClassName, e); } } return moduleClasses; } public ProcessDefinition(String name) { this(); this.name = name; } public ProcessDefinition(String[] nodes, String[] transitions) { this(); ProcessFactory.addNodesAndTransitions(this, nodes, transitions); } public ProcessInstance createProcessInstance() { return new ProcessInstance(this); } public ProcessInstance createProcessInstance(Map variables) { return new ProcessInstance(this, variables, null); } public ProcessInstance createProcessInstance(Map variables, String businessKey) { return new ProcessInstance(this, variables, businessKey); } public void setProcessDefinition(ProcessDefinition processDefinition) { if (!equals(processDefinition)) { throw new IllegalArgumentException("process definition cannot reference another process definition"); } } // equals /////////////////////////////////////////////////////////////////// /** * Tells whether this process definition is equal to the given object. This method considers * two process definitions equal if they are equal in name and version, the name is not null * and the version is not negative. */ public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof ProcessDefinition)) return false; ProcessDefinition other = (ProcessDefinition) o; if (id != 0 && id == other.getId()) return true; return name != null && version >= 0 && name.equals(other.getName()) && version == other.getVersion(); } /** * Computes the hash code for this process definition. Process definitions with a null name or * a negative version will return their {@linkplain System#identityHashCode(Object) identity * hash code}. */ public int hashCode() { if (name == null || version < 0) return System.identityHashCode(this); int result = 224001527 + name.hashCode(); result = 1568661329 * result + version; return result; } // parsing ////////////////////////////////////////////////////////////////// /** * parse a process definition from an xml string. * * @throws org.jbpm.jpdl.JpdlException if parsing reported an error. */ public static ProcessDefinition parseXmlString(String xml) { StringReader stringReader = new StringReader(xml); JpdlXmlReader jpdlReader = new JpdlXmlReader(new InputSource(stringReader)); return jpdlReader.readProcessDefinition(); } /** * parse a process definition from an xml resource file. * * @throws org.jbpm.jpdl.JpdlException if parsing reported an error. */ public static ProcessDefinition parseXmlResource(String xmlResource) { URL resourceURL = ClassLoaderUtil.getClassLoader().getResource(xmlResource); if (resourceURL == null) { throw new JpdlException("resource not found: " + xmlResource); } JpdlXmlReader jpdlReader = new JpdlXmlReader(new InputSource(resourceURL.toString())); return jpdlReader.readProcessDefinition(); } /** * parse a process definition from an xml input stream. * * @throws org.jbpm.jpdl.JpdlException if parsing reported an error. */ public static ProcessDefinition parseXmlInputStream(InputStream inputStream) { JpdlXmlReader jpdlReader = new JpdlXmlReader(new InputSource(inputStream)); return jpdlReader.readProcessDefinition(); } /** * parse a process definition from an xml reader. * * @throws org.jbpm.jpdl.JpdlException if parsing reported an error. */ public static ProcessDefinition parseXmlReader(Reader reader) { JpdlXmlReader jpdlReader = new JpdlXmlReader(new InputSource(reader)); return jpdlReader.readProcessDefinition(); } /** * parse a process definition from a process archive zip-stream. * * @throws org.jbpm.jpdl.JpdlException if parsing reported an error. */ public static ProcessDefinition parseParZipInputStream(ZipInputStream zipInputStream) throws IOException { return new ProcessArchive(zipInputStream).parseProcessDefinition(); } /** * parse a process definition from a process archive resource. * * @throws org.jbpm.jpdl.JpdlException if parsing reported an error. */ public static ProcessDefinition parseParResource(String parResource) throws IOException { return parseParZipInputStream(new ZipInputStream(ClassLoaderUtil.getStream(parResource))); } // nodes //////////////////////////////////////////////////////////////////// // javadoc description in NodeCollection public List getNodes() { return nodes; } // javadoc description in NodeCollection public Map getNodesMap() { if (nodesMap == null) { nodesMap = new HashMap(); if (nodes != null) { for (Iterator iter = nodes.iterator(); iter.hasNext();) { Node node = (Node) iter.next(); nodesMap.put(node.getName(), node); } } } return nodesMap; } // javadoc description in NodeCollection public Node getNode(String name) { if (nodes == null) return null; return (Node) getNodesMap().get(name); } // javadoc description in NodeCollection public boolean hasNode(String name) { if (nodes == null) return false; return getNodesMap().containsKey(name); } // javadoc description in NodeCollection public Node addNode(Node node) { if (node == null) { throw new IllegalArgumentException("node is null"); } if (nodes == null) nodes = new ArrayList(); nodes.add(node); node.processDefinition = this; nodesMap = null; if ((node instanceof StartState) && (this.startState == null)) { this.startState = node; } return node; } // javadoc description in NodeCollection public Node removeNode(Node node) { Node removedNode = null; if (node == null) { throw new IllegalArgumentException("node is null"); } if (nodes != null) { if (nodes.remove(node)) { removedNode = node; removedNode.processDefinition = null; nodesMap = null; } } if (startState == removedNode) { startState = null; } return removedNode; } // javadoc description in NodeCollection public void reorderNode(int oldIndex, int newIndex) { if (nodes != null && Math.min(oldIndex, newIndex) >= 0 && Math.max(oldIndex, newIndex) < nodes.size()) { Object node = nodes.remove(oldIndex); nodes.add(newIndex, node); } else { throw new IndexOutOfBoundsException("could not move node from " + oldIndex + " to " + newIndex); } } // javadoc description in NodeCollection public String generateNodeName() { return generateNodeName(nodes); } // javadoc description in NodeCollection public Node findNode(String hierarchicalName) { return findNode(this, hierarchicalName); } public static String generateNodeName(List nodes) { String name; if (nodes == null) { name = "1"; } else { int n = 1; while (containsName(nodes, Integer.toString(n))) n++; name = Integer.toString(n); } return name; } private static boolean containsName(List nodes, String name) { for (Iterator iter = nodes.iterator(); iter.hasNext();) { Node node = (Node) iter.next(); if (name.equals(node.getName())) return true; } return false; } public static Node findNode(NodeCollection nodeCollection, String hierarchicalName) { String[] nameParts = hierarchicalName.split("/"); if (nameParts.length == 1) { String nodeName = nameParts[0]; return nodeName.length() > 0 ? nodeCollection.getNode(nodeName) : null; } GraphElement currentElement = (GraphElement) nodeCollection; int startIndex = 0; if (nameParts[0].length() == 0) { // hierarchical name started with a '/' currentElement = currentElement.getProcessDefinition(); startIndex = 1; } for (int i = startIndex; i < nameParts.length; i++) { String namePart = nameParts[i]; if ("..".equals(namePart)) { // namePart calls for parent, but current element is absent if (currentElement == null) return null; currentElement = currentElement.getParent(); } else { // namePart calls for child, but current element is not a collection if (!(currentElement instanceof NodeCollection)) return null; NodeCollection currentCollection = (NodeCollection) currentElement; currentElement = currentCollection.getNode(namePart); } } // current element could be the process definition or might be absent return currentElement instanceof Node ? (Node) currentElement : null; } public void setStartState(StartState startState) { if (this.startState != startState && this.startState != null) { removeNode(this.startState); } this.startState = startState; if (startState != null) { addNode(startState); } } public GraphElement getParent() { return null; } // actions ////////////////////////////////////////////////////////////////// /** * creates a bidirectional relation between this process definition and the given action. * * @throws IllegalArgumentException if action is null or if action.getName() is null. */ public Action addAction(Action action) { if (action == null) { throw new IllegalArgumentException("action is null"); } if (action.getName() == null) { throw new IllegalArgumentException("action is unnamed"); } if (actions == null) actions = new HashMap(); actions.put(action.getName(), action); action.processDefinition = this; return action; } /** * removes the bidirectional relation between this process definition and the given action. * * @throws IllegalArgumentException if action is null or if the action was not present in the * actions of this process definition. */ public void removeAction(Action action) { if (action == null) { throw new IllegalArgumentException("action is null"); } if (actions != null) { if (!actions.containsValue(action)) { throw new IllegalArgumentException("action is not present in process definition"); } actions.remove(action.getName()); action.processDefinition = null; } } public Action getAction(String name) { return actions != null ? (Action) actions.get(name) : null; } public Map getActions() { return actions; } public boolean hasActions() { return actions != null && !actions.isEmpty(); } // module definitions /////////////////////////////////////////////////////// public Object createInstance() { return new ProcessInstance(this); } public ModuleDefinition addDefinition(ModuleDefinition moduleDefinition) { if (moduleDefinition == null) { throw new IllegalArgumentException("module definition is null"); } if (definitions == null) definitions = new HashMap(); definitions.put(moduleDefinition.getName(), moduleDefinition); moduleDefinition.setProcessDefinition(this); return moduleDefinition; } public ModuleDefinition removeDefinition(ModuleDefinition moduleDefinition) { if (moduleDefinition == null) { throw new IllegalArgumentException("module definition is null"); } ModuleDefinition removedDefinition = null; if (definitions != null) { removedDefinition = (ModuleDefinition) definitions.remove(moduleDefinition.getClass().getName()); if (removedDefinition != null) { moduleDefinition.setProcessDefinition(null); } } return removedDefinition; } public ModuleDefinition getDefinition(Class clazz) { ModuleDefinition moduleDefinition = null; if (definitions != null) { moduleDefinition = (ModuleDefinition) definitions.get(clazz.getName()); } return moduleDefinition; } public ContextDefinition getContextDefinition() { return (ContextDefinition) getDefinition(ContextDefinition.class); } public FileDefinition getFileDefinition() { return (FileDefinition) getDefinition(FileDefinition.class); } public TaskMgmtDefinition getTaskMgmtDefinition() { return (TaskMgmtDefinition) getDefinition(TaskMgmtDefinition.class); } public Map getDefinitions() { return definitions; } public void setDefinitions(Map definitions) { this.definitions = definitions; } // getters and setters ////////////////////////////////////////////////////// public int getVersion() { return version; } /** * Sets the version of this process. Generally the version is assigned automatically upon * {@linkplain JbpmContext#deployProcessDefinition(ProcessDefinition) deployment}. * * @param version the version to assign. Automatic versioning starts from 1. Any negative * value is regarded as an unknown or <code>null</code> version. The meaning of version 0 is * undefined. */ public void setVersion(int version) { this.version = version; } public Node getStartState() { return startState; } public void setStartState(Node startState) { this.startState = startState; } public boolean isTerminationImplicit() { return isTerminationImplicit; } public void setTerminationImplicit(boolean isTerminationImplicit) { this.isTerminationImplicit = isTerminationImplicit; } }