package com.landtool.lanbase.common.utils;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
|
import javax.xml.xpath.XPath;
|
import javax.xml.xpath.XPathConstants;
|
|
import org.apache.log4j.Logger;
|
import org.w3c.dom.Document;
|
import org.w3c.dom.Node;
|
import org.w3c.dom.NodeList;
|
|
import com.landtool.lanbase.modules.api.utils.DOMUtil;
|
import com.landtool.lanbase.modules.res.entity.WebService.ParameterInfo;
|
import com.landtool.lanbase.modules.res.entity.WebService.SchemaDefaultType;
|
|
/**
|
* 第二步，使用DOM解析XML Schema，获取元素名称和类型
|
*
|
* @author wangleai
|
*/
|
public class WADOMUtil {
|
|
private static Logger log = Logger.getLogger(WADOMUtil.class);
|
|
/**
|
* 查找某个操作含有的参数
|
*
|
* @param inputParamList
|
* @param document
|
* @param typeName 类型名称
|
* @param xPath 到element上个结点的xpath
|
* @param parentParam
|
* @param isSelfDefinition 是否自己定义
|
* @throws Exception
|
*/
|
public static void getInputParams(List<ParameterInfo> inputParamList, Document document, String typeName,
|
String xPath, ParameterInfo parentParam, boolean isSelfDefinition) throws
|
Exception {
|
// 是否添加结点
|
boolean canAddParam = true;
|
|
// 参数
|
ParameterInfo param = new ParameterInfo();
|
param.setName(typeName);
|
|
// 寻找element节点
|
String elementXPath = getElementXPath(xPath, typeName);
|
Node elementNode = WADOMUtil.findNode(document, elementXPath);
|
|
// 判断element是否为空，为空说明该类型名称可能是直接定义在simpleType或complexType中
|
// 判断是否是自己定义，防止同名导致的堆栈溢出问题
|
if (elementNode != null && isSelfDefinition) {
|
// 是否含type属性
|
if (DOMUtil.assertNodeAttributeExist(elementNode, "type")) {
|
String type = DOMUtil.getNodeType(elementNode);
|
|
// 是否是数组，XML Schema中map会定义成List<Object>的形式
|
if (DOMUtil.isArray(elementNode)) {
|
param.setType(SchemaDefaultType.type_array.getType());
|
param.setChildType(type);
|
|
// 复杂类型数组
|
if (!DOMUtil.isDefaultType(elementNode)) {
|
getInputParams(inputParamList, document, type, xPath, param, false);
|
} else {
|
param.setValue(WAIXPathConstant.VALUEDEF);
|
}
|
} else {
|
param.setType(type);
|
|
// 复杂类型
|
if (!DOMUtil.isDefaultType(elementNode)) {
|
getInputParams(inputParamList, document, type, WAIXPathConstant.SCHEMAXPATH, param, false);
|
} else {
|
param.setValue(WAIXPathConstant.VALUEDEF);
|
}
|
}
|
} else {
|
// 是否是数组，XML Schema中map会定义成List<Object>的形式
|
if (DOMUtil.isArray(elementNode)) {
|
param.setType(SchemaDefaultType.type_array.getType());
|
}
|
|
// 如果type属性不存在，说明该结点的类型在其子结点中定义
|
// 判断是simpleType还是complexType
|
Node simpleTypeNode = getSimpleTypeNode(document, typeName, elementXPath, true);
|
if (simpleTypeNode != null) {
|
String type = DOMUtil.getNodeBase(simpleTypeNode);
|
if (DOMUtil.isArray(elementNode)) {
|
param.setChildType(type);
|
} else {
|
param.setType(type);
|
}
|
param.setValue(WAIXPathConstant.VALUEDEF);
|
// TODO: 2018/2/24
|
// 忽略限定条件
|
} else {
|
// 寻找complexType
|
List<Node> nodeList = getComplexTypeSequenceElement(document, typeName, elementXPath, true);
|
if (nodeList.size() != 0) {
|
for (Node tempNode : nodeList) {
|
// 遍历element
|
String elementName = DOMUtil.getNodeName(tempNode);
|
String sequenceXPath = getSequenceXPathByName(document, typeName, elementXPath, true,
|
elementName);
|
getInputParams(inputParamList, document, elementName, sequenceXPath, param, true);
|
}
|
} else {
|
log.warn("unknown type " + typeName + ",please check your document");
|
}
|
}
|
}
|
} else {
|
// 非自己定义的Type添加到父结点
|
canAddParam = false;
|
|
// 判断是simpleType还是complexType
|
Node simpleTypeNode = getSimpleTypeNode(document, typeName, xPath, false);
|
if (simpleTypeNode != null) {
|
String type = DOMUtil.getNodeBase(simpleTypeNode);
|
parentParam.setType(type);
|
parentParam.setValue(WAIXPathConstant.VALUEDEF);
|
// TODO: 2018/2/24
|
// 忽略限定条件
|
} else {
|
// 寻找complexType
|
List<Node> nodeList = getComplexTypeSequenceElement(document, typeName, elementXPath, false);
|
if (nodeList.size() != 0) {
|
for (Node tempNode : nodeList) {
|
// 遍历element
|
String elementName = DOMUtil.getNodeName(tempNode);
|
String sequenceXPath = getSequenceXPathByName(document, typeName, elementXPath, false,
|
elementName);
|
getInputParams(inputParamList, document, elementName, sequenceXPath, parentParam, true);
|
}
|
} else {
|
log.warn("unknown type " + typeName + ",please check your document");
|
}
|
}
|
}
|
if (canAddParam) {
|
if (parentParam == null) {
|
inputParamList.add(param);
|
} else {
|
parentParam.addChild(param);
|
}
|
}
|
}
|
|
/**
|
* 获取element的xpath
|
*
|
* @param xPath 父结点xpath
|
* @param typeName 名称
|
* @return
|
*/
|
private static String getElementXPath(String xPath, String typeName) {
|
String elementXPath = xPath + "/*[local-name()='element' and @name='" + typeName + "']";
|
return elementXPath;
|
}
|
|
/**
|
* 获取simpleType结点
|
*
|
* @param document
|
* @param simpleTypeName simpleType名称，当为自己定义时可以为空
|
* @param elementXPath XPath路径，当非自己定义时可以为空
|
* @param isSelfDefinition 是否为自己定义
|
* @return
|
* @throws Exception
|
*/
|
private static Node getSimpleTypeNode(Document document, String simpleTypeName, String elementXPath,
|
boolean isSelfDefinition) throws Exception {
|
String simpleTypeXPath = isSelfDefinition
|
? elementXPath + "/*[local-name()='simpleType']/*[local-name()='restriction']"
|
: WAIXPathConstant.SCHEMAXPATH + "/*[local-name()='simpleType' and @name='" + simpleTypeName
|
+ "']/*[local-name()='restriction']";
|
Node node = WADOMUtil.findNode(document, simpleTypeXPath);
|
return node;
|
}
|
|
/**
|
* 获取complexType中element
|
*
|
* @param document
|
* @param complexTypeName complexType名称，当为自己定义时可以为空
|
* @param elementXPath XPath路径，当非自己定义时可以为空
|
* @param isSelfDefinition 是否为自己定义
|
* @return
|
* @throws Exception
|
*/
|
private static List<Node> getComplexTypeSequenceElement(Document document, String complexTypeName,
|
String elementXPath, boolean isSelfDefinition) throws
|
Exception {
|
List<Node> nodeList = new ArrayList<Node>();
|
// 判断是否有继承
|
String extensionXpath = isSelfDefinition
|
? elementXPath + "/*[local-name()='complexType']/*[local-name()='complexContent']/*[local-name()"
|
+ "='extension']"
|
: WAIXPathConstant.SCHEMAXPATH + "/*[local-name()='complexType' and @name='" + complexTypeName
|
+ "']/*[local-name()='complexContent']/*[local-name()='extension']";
|
Node extension = WADOMUtil.findNode(document, extensionXpath);
|
if (extension != null) {
|
// 存在继承
|
// 添加父类
|
String parentTypeName = DOMUtil.getAttributeValue(extension, "base").split(":")[1];
|
List<Node> parentElements = getComplexTypeSequenceElement(document, parentTypeName, elementXPath, false);
|
if (parentElements != null && parentElements.size() > 0) {
|
nodeList.addAll(parentElements);
|
}
|
// 查找自己
|
String selfXpath = extensionXpath + "/*[local-name()='sequence']/*[local-name()" + "='element']";
|
NodeList selfList = WADOMUtil.findNodeList(document, selfXpath);
|
if (selfList != null && selfList.getLength() > 0) {
|
nodeList.addAll(DOMUtil.covertNodeListToList(selfList));
|
}
|
} else {
|
// 查找自己的属性
|
String elementsOfSequenceXpath = isSelfDefinition
|
? elementXPath + "/*[local-name()='complexType']/*[local-name()='sequence']/*[local-name()"
|
+ "='element']"
|
: WAIXPathConstant.SCHEMAXPATH + "/*[local-name()='complexType' and @name='" + complexTypeName
|
+ "']/*[local-name()='sequence']/*[local-name()='element']";
|
NodeList elementsOfSequence = WADOMUtil.findNodeList(document, elementsOfSequenceXpath);
|
nodeList = DOMUtil.covertNodeListToList(elementsOfSequence);
|
}
|
return nodeList;
|
}
|
|
/**
|
* 获取complexType中element上一级sequence的xpath
|
*
|
* @param document
|
* @param complexTypeName complexType名称，当为自己定义时可以为空
|
* @param elementXPath XPath路径，当非自己定义时可以为空
|
* @param isSelfDefinition 是否为自己定义
|
* @param elementName 结点名称
|
* @return
|
* @throws Exception
|
*/
|
private static String getSequenceXPathByName(Document document, String complexTypeName, String elementXPath,
|
boolean isSelfDefinition, String elementName) throws Exception {
|
String result = "";
|
// 判断是否有继承
|
String extensionXpath = isSelfDefinition
|
? elementXPath + "/*[local-name()='complexType']/*[local-name()='complexContent']/*[local-name()"
|
+ "='extension']"
|
: WAIXPathConstant.SCHEMAXPATH + "/*[local-name()='complexType' and @name='" + complexTypeName
|
+ "']/*[local-name()='complexContent']/*[local-name()='extension']";
|
Node extension = WADOMUtil.findNode(document, extensionXpath);
|
if (extension != null) {
|
// 存在继承
|
// 在父类查找
|
String parentTypeName = DOMUtil.getAttributeValue(extension, "base").split(":")[1];
|
result = getSequenceXPathByName(document, parentTypeName, elementXPath, false, elementName);
|
|
// 在自己查找
|
String sequenceXPath = extensionXpath + "/*[local-name()='sequence']";
|
String eleXPath = sequenceXPath + "/*[local-name()='element' and @name='" + elementName + "']";
|
Node selfNode = WADOMUtil.findNode(document, eleXPath);
|
if (selfNode != null) {
|
result = sequenceXPath;
|
}
|
} else {
|
// 在自己查找
|
String sequenceXPath = isSelfDefinition
|
? elementXPath + "/*[local-name()='complexType']/*[local-name()='sequence']"
|
: WAIXPathConstant.SCHEMAXPATH + "/*[local-name()='complexType' and @name='" + complexTypeName
|
+ "']/*[local-name()='sequence']";
|
String eleXpath = sequenceXPath + "/*[local-name()='element' and @name='" + elementName + "']";
|
Node selfNode = WADOMUtil.findNode(document, eleXpath);
|
if (selfNode != null) {
|
result = sequenceXPath;
|
}
|
}
|
return result;
|
}
|
|
/**
|
* 在document中查找结点，如果查找不到，则进入import结点中递归查找
|
*
|
* @param document
|
* @param xpathStr
|
* @return
|
* @throws Exception
|
*/
|
public static Node findNode(Document document, String xpathStr) throws Exception {
|
XPath xpath = WAWsdlUtil.getXPath();
|
Node node = (Node) xpath.evaluate(xpathStr, document, XPathConstants.NODE);
|
if (node == null) {
|
List<Document> importDocumentList = WAWsdlUtil.getImportDocumentList(document, xpath);
|
for (Document importDoucment : importDocumentList) {
|
node = findNode(importDoucment, xpathStr);
|
if (node != null) {
|
return node;
|
}
|
}
|
}
|
return node;
|
}
|
|
/**
|
* 在document中查找结点，如果查找不到，则进入import结点中递归查找
|
*
|
* @param document
|
* @param xpathStr
|
* @return
|
* @throws Exception
|
*/
|
public static NodeList findNodeList(Document document, String xpathStr) throws Exception {
|
XPath xpath = WAWsdlUtil.getXPath();
|
NodeList nodeList = (NodeList) xpath.evaluate(xpathStr, document, XPathConstants.NODESET);
|
if (nodeList.getLength() == 0) {
|
List<Document> importDocumentList = WAWsdlUtil.getImportDocumentList(document, xpath);
|
for (Document importDoucment : importDocumentList) {
|
nodeList = findNodeList(importDoucment, xpathStr);
|
if (nodeList.getLength() > 0) {
|
return nodeList;
|
}
|
}
|
}
|
return nodeList;
|
}
|
}
|
