JbpmUtil.java

package com.huike.leave.service.util; 

import java.io.File; 
import java.util.ArrayList; 
import java.util.Iterator; 
import java.util.List; 

import org.dom4j.Attribute; 
import org.dom4j.Document; 
import org.dom4j.DocumentException; 
import org.dom4j.Element; 
import org.dom4j.Node; 
import org.dom4j.io.SAXReader; 

public class JbpmUtil { 

private SAXReader reader = new SAXReader();   
private Document document = null; 
private Element rootElement = null; 
private Element childElement = null; 
private Attribute attribute = null; 
private String attribute_value = null; 

private String node_name_property = null; 

public JbpmUtil(String filepath){ 
this.parseXML(filepath); 
this.getRootElement(); 
} 

public void parseXML(String filepath) { 
try { 
document = reader.read(new File(filepath)); 
if(filepath == null) 
p("SAXReader解析时出现异常，可能指定路径下的文件不存在"); 
} catch (DocumentException e) { 
p("SAXReader解析时出现异常，可能指定路径下的文件不存在"); 
e.printStackTrace(); 
}   
} 

public Element getRootElement(){ 
rootElement = document.getRootElement(); 
return rootElement; 
} 

public String getRootElementKey(){ 
return rootElement.attributeValue("name"); 
} 
// public  String getRootElementKey(String attributeName) { 
// return  rootElement.attributeValue(attributeName); 
// } 

// public Element getProcessChildElement(String nodeName){ 
// childElement = rootElement.element(nodeName); 
// return childElement; 
// } 
// @SuppressWarnings({ "rawtypes" }) 
// public List Element getChildElementAsList(Element parentElement){ 
// List Element elementAsList = new ArrayList Element  
// for(Iterator it=parentElement.elementIterator();it.hasNext();) 
// {   
// childElement = (Element) it.next(); 
// elementAsList.add(childElement); 
// } 
// return elementAsList;   
// } 

/** 
* 获取根节点下第一层子节点指定的的属性名的对应值 
* @param nodeName 
* @param attributeName 
* @return 
* @throws Exception 
*/ 
public String getProperty(String nodeName,String attributeName)throws Exception{ 
Element currentElement = rootElement.element(nodeName); 
if(currentElement == null) 
{ 
new Exception("文件中不存在指定的节点名"); 
System.out.println("文件中不存在指定的节点名"); 
} 
else{ 
attribute = currentElement.attribute(attributeName); 
} 

    if(attribute == null) 
    { 
    System.out.println("指定的属性在此节点中不存在，请检查传入的属性名与节点名是否匹配"); 
    new Exception("指定的属性在此节点中不存在，请检查传入的节点名与属性名是否匹配"); 
    } 
    else{ 
    attribute_value = attribute.getValue(); 
    return attribute_value; 
    } 
    return attribute_value; 
} 

// /** 
// * 处理第二层子节点下只有一个元素 
// */ 
// public String getProperty(String firstLevelNodeName,String firstLevelChildNodeName,String attributeName){ 
// Element start = rootElement.element(firstLevelNodeName); 
// Element transition = start.element(firstLevelChildNodeName); 
// Attribute a = transition.attribute(attributeName); 
// return a.getValue(); 
// } 
// /** 
// * 处理第二层子节点下有多个元素 
// */ 
// @SuppressWarnings({ "unchecked", "rawtypes" }) 
// public List getProperties (String firstLevelChildNodeName,String secondLevelChildNodeName,String attributeName){ 
// Element task = rootElement.element(firstLevelChildNodeName); 
// List task_transitionAsList = task.elements(secondLevelChildNodeName); 
// Element transition = null; 
// Attribute attribute = null; 
// String s = null; 
// List list = new ArrayList(); 
// for(int i=0; i task_transitionAsList.size();i++) 
// { 
// transition = (Element) task_transitionAsList.get(i); 
// attribute = transition.attribute(attributeName); 
// s = attribute.getText(); 
// list.add(s); 
// } 
// return list; 
// } 

// public String getNameProperty(String nodeName){ 
// Element currentElement = rootElement.element(nodeName); 
//     attribute = currentElement.attribute("name"); 
//     attribute_value = attribute.getValue(); 
// return node_name_property; 
// } 

// @SuppressWarnings("rawtypes") 
// public List getCurrentNodeInformation(String nodeName){ 
// return  rootElement.element(nodeName).attributes(); 
// } 
/** 
* 根据元素的name属性值获取对应的元素 
* @param name 
* @return 
*/ 
@SuppressWarnings("rawtypes") 
public Element getElementByNameAttributeValue(String name){ 
Iterator it = rootElement.elementIterator(); 
Element e = null; 
Attribute a = null; 
List Element el = new ArrayList Element  
while(it.hasNext()) 
{ 
e = (Element)it.next(); 
a = e.attribute("name"); 
if(a.getText().equals(name)) 
{ 
el.add(e); 
if(el.size() == 1) 
{ 
return el.get(0); 
} 
} 
if(el.size()==0) 
System.out.println("根元素下的子元素中存在具有 name属性值为"+name+"的元素"); 
} 
return el.get(0); 
} 

// @SuppressWarnings("rawtypes") 
// public String getTransitionToProperty(String currentActivityName, String decisionInfo){ 
// Element currentElment = this.getElementByNameAttributeValue(currentActivityName); 
// List transitionAsList = currentElment.elements(); 
// Element e = null; 
// String toValue = null ; 
// for(int i=0; i transitionAsList.size();i++) 
// { 
// e = (Element)transitionAsList.get(i); 
// toValue = e.attribute("name").getText().toString(); 
// p(toValue); 
// p(decisionInfo); 
// if(decisionInfo.equals(toValue)) 
// { 
// toValue = e.attribute("to").getText().toString(); 
// return toValue; 
// } 
// } 
// return toValue; 
// } 
public static void p(Object o){ 
System.out.println(o.toString()); 
} 
} 
一篇文章和你从 Java1 聊到 Java18 002-2022 年的 20 年里 Java 始终保持在前三的水平，其中在 2005 年、2013-2015 年间、2021 年等时间还多次登顶过第一，这么一个已经发布了 27 年的语言在这些年是怎么始终保持在编程语言前三的呢？这么多年 Java 各个版本间又有什么变化？Java 语言在未来还会继续保持成为语言的常青树吗？这篇文章就来和大家回顾一下 Java 的历史。
java me Java 是一门面向对象编程语言，不仅吸收了 C++ 语言的各种优点，还摒弃了 C++ 里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。 Java 语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。 Java EE 是指 Java Enterprise Edition，Java 企业版，多用于企业级开发，包括 web 开发等等。也叫 J2EE。 Java SE 通常是指 Java Standard Edition，Java 标准版，就是一般 Java 程序的开发就可以(如桌面程序)，可以看作
赶快看看Java11，不然你就out了！ 由于直接从Java8跨越到Java11，所以特性介绍就把Java9-Java11的部分特性一起介绍一下。想要了解Java8特性的朋友可以去我的博客找「Java8系列」。
从Java8到Java17 背景Java8的前世今生作为一名程序员，笔者从大学开始接触Java这门编程语言，还记得当时的版本是1.4，不过这个版本的寿命还挺长，目前在一些金融行业的存量系统中依然还有1.4版本的影子。从C/C++到Java，Java给我的第一印象，就是这门语言的语法非常之啰嗦，比如内部类，像下面这段排序的代码，在C语言里面可以很方便地通过函数指针来解决，C++可以通过运算符重载来解决，唯独Java语言的写法最