DOM 对Jbpm jdpl.xml文件的解析

package com.huike.leave.service.util; 

import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.IOException; 
import java.io.InputStream; 
import java.util.ArrayList; 
import java.util.Date; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
import java.util.Set; 

import javax.xml.parsers.DocumentBuilder; 
import javax.xml.parsers.DocumentBuilderFactory; 
import javax.xml.parsers.ParserConfigurationException; 

import org.jbpm.api.Configuration; 
import org.jbpm.api.ExecutionService; 
import org.jbpm.api.ProcessEngine; 
import org.jbpm.api.ProcessInstance; 
import org.jbpm.api.RepositoryService; 
import org.jbpm.api.TaskService; 
import org.jbpm.api.task.Task; 
import org.jbpm.pvm.internal.model.Activity; 
import org.jbpm.pvm.internal.model.ExecutionImpl; 
import org.jbpm.pvm.internal.model.ProcessDefinitionImpl; 
import org.w3c.dom.Document; 
import org.w3c.dom.Element; 
import org.w3c.dom.Node; 
import org.w3c.dom.NodeList; 
import org.xml.sax.SAXException; 

public class ParseXmlFile { 

DocumentBuilderFactory documentBuilderFactory = null; 
DocumentBuilder documentBuilder = null; 
Document doc = null; 
InputStream inputStream = null; 
Element rootElement = null; 
NodeList childNodes = null; 
Node childNodes_item = null; 
List<Node> first_layer_child_node_AsList = new ArrayList<Node>(); 

StringBuffer all_untreated_nodeNames_As_StringBuffer = new StringBuffer(); 
String[] nodeTypeNameAsArray = null; 

List<String> first_layer_child_node_name_property_AsList = new ArrayList<String>(); 
List<String> first_layer_child_node_g_property_AsList = new ArrayList<String>(); 
List<String> first_layer_child_node_to_property_AsList = new ArrayList<String>(); 

List<String> transition_to_AsLsit = new ArrayList<String>(); 
List<String> transition_name_AsLsit = new ArrayList<String>(); 
Map<String,List<String>> transition_containt_to_name = new HashMap<String,List<String>>(); 

List<String> task_assignee_AsList = new ArrayList<String>(); 
List<String> decision_expr_AsList = new ArrayList<String>(); 
List<String> end_state_AsList = new ArrayList<String>(); 

String key = null; 


/** 
* 设计存放jpdl.xml文件中各节点信息及其对应关系的集合 
* @throws ParserConfigurationException 
* @throws SAXException 
*/ 

List<Map<String,String>> process = new ArrayList<Map<String,String>>(); 

Map<String,Map<String,String>> process_task = new HashMap<String,Map<String,String>>(); 
Map<String,String> task = new HashMap<String,String>(); 
Map<String,String> decision = new HashMap<String,String>(); 

Map<String,String> transition = new HashMap<String,String>(); 
Map<String,String> transition_to = new HashMap<String,String>(); 


public ParseXmlFile(){ 
// this.ParseXmlFile(); 
} 
/** 
* 创建DocumentBuilderFactory（文档构建工厂）实例, 用于创建设DocumentBuilder(文档构建对象) 
*/ 
public  ParseXmlFile(String filePath) throws ParserConfigurationException, SAXException { 
documentBuilderFactory = DocumentBuilderFactory.newInstance(); 
try { 
documentBuilder = documentBuilderFactory.newDocumentBuilder(); 
} catch (ParserConfigurationException e1) { 
e1.printStackTrace(); 
} 
/** 
* 获取要解析的jpdl.xml文件的输入流对象 
*/ 
try { 
inputStream = new FileInputStream(filePath); 
} catch (FileNotFoundException e) { 
new Exception("jpdl.xml file not found!"); 
e.printStackTrace(); 
} 

/** 
* 利用DocumentBuilder(文档构建对象)从jpdl.xml文件中解析出Document(文档对象) 
*/ 
try { 
doc = documentBuilder.parse(inputStream); 
} catch (IOException e) { 
new Exception("parse xml error!"); 
e.printStackTrace(); 
} 
} 

/** 
* 获取根节点 
* @return 
* @throws SAXException 
*/ 
public Element getRootElement() throws SAXException { 
rootElement = doc.getDocumentElement(); 
if (rootElement.getAttribute("name") != null) { 
key = rootElement.getAttribute("name"); 
System.out.println("<process name=\" " 
+ rootElement.getAttribute("name") 
+ "\" xmlns=\"http://jbpm.org/4.0/jpdl\">"); // 输出流程定义的key值 
} 
return rootElement; 
} 

/** 
* 生成一个存放process节点下的第一层所有子节点的节点名的字符串数组 遍历所有节点 
* ,并把各个节点的类型保存到一个数组中，方法其它方法调用（仅作测试用） 
* 
* @return String[] strArray 各个节点的类型,不包括根节点(process)，一般是从start 
*         开始,也可能从on开始 
*/ 

/** 
* 获取根元素下的子节点 
*/ 
public String[] getChildNodesNameAsStringArray(Element rootElement) { 

childNodes = rootElement.getChildNodes(); 

if (childNodes != null) { 
for (int i = 0; i < childNodes.getLength(); i++) { 
childNodes_item = childNodes.item(i); 

first_layer_child_node_AsList.add(childNodes_item); 

all_untreated_nodeNames_As_StringBuffer.append(childNodes_item 
.getNodeName()); // 每遍历出一个节点类型名则附加到一起,因为此时遍历出的类型名包含了#text..... 

// 进入第一层节点的处理,如start task decision end 
if (childNodes_item.getNodeType() == Node.ELEMENT_NODE) { 

} 
} 
nodeTypeNameAsArray = all_untreated_nodeNames_As_StringBuffer 
.toString().split("#text");// 分离出含#text的类型名,并存入一个字符串数组 
} 
return nodeTypeNameAsArray; 
} 

/** 
* 获取指定节点的属性值 
* 
* @return nodePropertyMap 
* @param String 
*            nodeName 
* @param Element 
*            rootElement 
*/ 
public Map<String, String> getNodePropertyAsMap(String nodeName, 
Element rootElement) { 
Map<String, String> map = new HashMap<String, String>(); 

childNodes = rootElement.getChildNodes(); 
for (int i = 0; i < childNodes.getLength(); i++) { 
childNodes_item = childNodes.item(i); 
String currentNodeName = null; 
if(i%2 != 0) 
{ 
currentNodeName = childNodes_item.getNodeName(); 
System.out.println(childNodes_item.getNodeName()); 
} 
// currentNodeName = childNodes_item.getNodeName().split("#text")[0]; 
// System.out.println("currentNodeName" + i + currentNodeName); 

if (childNodes_item.getNodeType() == Node.ELEMENT_NODE) { 
if (currentNodeName.equals(nodeName)) { 

// 获取start task decision 和节点name属性值 
if (childNodes_item.getAttributes().getNamedItem("name") != null) { 
first_layer_child_node_name_property_AsList 
.add(childNodes_item.getAttributes() 
.getNamedItem("name").getNodeValue()); 
System.out.println(" childNodes_item name = " 
+ childNodes_item.getAttributes() 
.getNamedItem("name").getNodeValue()); 
map.put("name", childNodes_item.getAttributes() 
.getNamedItem("name").getNodeValue()); 
} 

// 获取start task decision 和节点to属性值 
if (childNodes_item.getAttributes().getNamedItem("to") != null) { 
first_layer_child_node_to_property_AsList 
.add(childNodes_item.getAttributes() 
.getNamedItem("to").getNodeValue()); 
System.out.println(" childNodes_item to = " 
+ childNodes_item.getAttributes() 
.getNamedItem("to").getNodeValue()); 
map.put("to", childNodes_item.getAttributes() 
.getNamedItem("to").getNodeValue()); 
} 

// 获取task节点assignee属性值 
if (childNodes_item.getAttributes() 
.getNamedItem("assignee") != null) { 
task_assignee_AsList.add(childNodes_item 
.getAttributes().getNamedItem("assignee") 
.getNodeValue()); 
System.out.println(" task_assignee_AsList assignee = " 
+ childNodes_item.getAttributes() 
.getNamedItem("assignee") 
.getNodeValue()); 
map.put("assignee", childNodes_item.getAttributes() 
.getNamedItem("assignee").getNodeValue()); 
} 

// 获取decision节点expr属性值 
if (childNodes_item.getAttributes().getNamedItem("expr") != null) { 
decision_expr_AsList.add(childNodes_item 
.getAttributes() 
.getNamedItem("expr") 
.getNodeValue() 
.substring( 
2, 
childNodes_item.getAttributes() 
.getNamedItem("expr") 
.getNodeValue().length() - 1)); 
System.out.println(" decision_expr_AsList expr= " 
+ childNodes_item 
.getAttributes() 
.getNamedItem("expr") 
.getNodeValue() 
.substring( 
2, 
childNodes_item.getAttributes() 
.getNamedItem("expr") 
.getNodeValue() 
.length() - 1)); 
map.put("expr", childNodes_item.getAttributes() 
.getNamedItem("expr").getNodeValue()); 

} 
// 获取end节点state属性值 
if (childNodes_item.getAttributes().getNamedItem("state") != null) { 
end_state_AsList.add(childNodes_item 
.getAttributes() 
.getNamedItem("state") 
.getNodeValue() 
.substring( 
2, 
childNodes_item.getAttributes() 
.getNamedItem("state") 
.getNodeValue().length() - 1)); 
System.out.println(" end_state_AsList state= " 
+ childNodes_item 
.getAttributes() 
.getNamedItem("state") 
.getNodeValue() 
.substring( 
2, 
childNodes_item.getAttributes() 
.getNamedItem("state") 
.getNodeValue() 
.length() - 1)); 
} 

// 获取 transition 
// 节点的属性,从childNodes_item节点的第一个子节点开始,遍历其兄弟节点（Sibling），并取其to属性和name属性的值 
for (Node node = childNodes_item.getFirstChild(); node != null; node = node 
.getNextSibling()) { 
if (node.getNodeType() == Node.ELEMENT_NODE) { 
if (node.getNodeName().equals("transition")) { 
// 获取 transition 节点的to属性的值 
String transition_to = node.getAttributes() 
.getNamedItem("to").getNodeValue(); 
transition_to_AsLsit.add(transition_to); 

// 获取 transition 节点的name属性的值 
String transition_name = node.getAttributes() 
.getNamedItem("name").getNodeValue(); 
transition_name_AsLsit.add(transition_name); 
} 
} 
transition_containt_to_name.put("to", 
transition_to_AsLsit); 
transition_containt_to_name.put("name", 
transition_name_AsLsit); 
} 
} 
} 
} 
return map; 
} 

public static void main(String args[]) throws ParserConfigurationException, SAXException{ 
// new ParseXmlFile("build/classes/com/huike/leave/service/Order.jpdl.xml"); 
ParseXmlFile pxf = new ParseXmlFile("build/classes/com/huike/leave/service/Order.jpdl.xml"); 
// pxf.getNodePropertyAsMap("start", pxf.getRootElement()); 
// pxf.getNodePropertyAsMap("task", pxf.getRootElement()); 

} 


// public void parseXmlFile() throws ParserConfigurationException, SAXException { 
// ProcessEngine processEngine = new Configuration().buildProcessEngine(); 
// RepositoryService repositoryService = processEngine 
// .getRepositoryService(); 
// ExecutionService executionService = processEngine.getExecutionService(); 
// TaskService taskService = processEngine.getTaskService(); 
// 
// /** 
// * 发布流程定义：获得流程定义deploymentId 
// */ 
// String deploymentId = repositoryService 
// .createDeployment() 
// .addResourceFromClasspath( 
// "com/huike/leave/service/Order.jpdl.xml").deploy(); 
// 
// /** 
// * 获得流程定义的ID 
// */ 
// String id = repositoryService.createProcessDefinitionQuery() 
// .deploymentId(deploymentId).uniqueResult().getId(); 
// 
// /** 
// * 获取jpdl.xml文件中process节点的name属性的值,即得到该流程的key,通过该key即可启动新流程 
// * 注：但此方法对于开始之后执行任务的中要求动态分配所有者时，在启动时无法确定分配人的key， 
// * 即不能确定要传的Map对象，如不传则无法启动成功 if(task_assignee_AsList.size()!=0) 
// * System.out.println(task_assignee_AsList.get(0).substring(2, 
// * task_assignee_AsList.get(0).length()-1)); 
// * 
// * String owner = task_assignee_AsList.get(0).substring(2, 
// * task_assignee_AsList.get(0).length()-1); 
// * 
// * Map<String,Object> map = new HashMap<String,Object>(); map.put(owner, 
// * "testOwner"); ProcessInstance processInstance = 
// * executionService.startProcessInstanceByKey(key,map); 
// */ 
// 
// /** 
// * 启动流程实例(注：在jpdl.xml文件中,如果任务要求动态绑定所有者，则不能根据id直接启动流程实例 
// */ 
// if (task_assignee_AsList.size() != 0) 
// System.out.println(task_assignee_AsList.get(0).substring(2, 
// task_assignee_AsList.get(0).length() - 1)); 
// 
// String assignee = task_assignee_AsList.get(0).substring(2, 
// task_assignee_AsList.get(0).length() - 1); 
// 
// /** 
// * 获取 
// */ 
// String decider = "manager"; 
// String decision_transition_name = "是"; 
// String true_or_no = decision_transition_name; 
// 
// Map<String, Object> map = new HashMap<String, Object>(); 
// map.put(assignee, "testOwner"); 
// map.put("time", new Date()); 
// map.put("leaveDay", 5); 
// map.put("content", "test"); 
// map.put("position", "经理"); 
// 
// map.put(decider, true_or_no); 
// // map.put("manager", "是"); 
// // map.put("position", "普通员工"); 
// // map.put("manager", "否"); 
// 
// ProcessInstance processInstance = executionService 
// .startProcessInstanceByKey(key, map); 
// List<Task> taskList = taskService.findPersonalTasks((String) map 
// .get(assignee)); 
// 
// if (taskList.size() > 0) { 
// Task task = taskList.get(0); 
// taskService.setVariables(task.getId(), map); 
// taskService.completeTask(task.getId()); 
// System.out.println("申请任务完成，流程根据判断转到经理审核或老板审批"); 
// } else 
// new Exception("apply error!"); 
// 
// /** 
// * 获取jbpm中各节点的类型 
// */ 
// ExecutionImpl executionImpl = (ExecutionImpl) processInstance; 
// ProcessDefinitionImpl processDefinitionImpl = executionImpl 
// .getProcessDefinition(); 
// Map<String, Activity> activitiesMap = processDefinitionImpl 
// .getActivitiesMap(); 
// Set<String> activitiesKeySet = activitiesMap.keySet(); 
// 
// for (String str : activitiesKeySet) { 
// System.out.println(activitiesMap.get(str).getType() 
// + activitiesMap.get(str).getParent() 
// + activitiesMap.get(str).getName()); 
// } 
// } 
}