Java dom4j解析RESTFull风格发布的WebService的xml文件

   公司项目要求解析出RESTFull风格发布的WebService接口的所有请求方法，参数，参数类型，已经方法是返回类型，想来想去都不知道该怎么办，思来想去然后又研究RESTFull风格WebService的xml文件，发现其实对于Java简单类型的 方法是能在xml文件中体现的，但是对于复杂类型，比如参数是一个对象，或者返回值是一个对象或者List，Map等。这些返回类型在xml文件中的 response下representation这个节点的属性type会是一个"application/json"。对于这些返回类型或者参数我没法 知道是什么类型，所以我就默认给这些Object类型。对于void类型的方法，会在response的status属性等于204，所以我就笨笨的用HttpClient抓去整个xml文件，然后用dome4j解析这个xml，幸好的是我在项目只需要解析简单类型的方法，所以想想也能达到要求.

package xxx.xxx.common;
 
 import java.util.List;
 
 import org.apache.commons.httpclient.HttpClient;
 import org.apache.commons.httpclient.HttpStatus;
 import org.apache.commons.httpclient.methods.GetMethod;
 import org.dom4j.Document;
 import org.dom4j.DocumentException;
 import org.dom4j.DocumentHelper;
 import org.dom4j.Element;
 
 import com.google.common.collect.Lists;
 import com.qya.vo.transform.TransformParamVO;
 import com.qya.vo.transform.TransformVO;
 
 import com.qya.utils.string.StringUtil;
 
 public class TransformWsUrlUtil {
 
     protected final String DEFAULT_URL = "http://localhost:8080/bpms/services?_wadl";
 
     public static List<TransformVO> transform(String url) {
         String xml = getTransformXml(url);
         Document doc = null;
         try {
             doc = DocumentHelper.parseText(xml);
         } catch (DocumentException e) {
             e.printStackTrace();
         }
         List<TransformVO> lst = Lists.newArrayList();
         String rootPath = "";
         Element resourcesEl = doc.getRootElement().element("resources");
         if (resourcesEl.hasContent()) {
             List<Element> els = resourcesEl.elements();
             for (Element resEl : els) {
                 rootPath = resEl.attribute(0).getText();
                 if (resEl.hasContent()) {
                     lst.addAll(getMethod(rootPath, resEl.elements()));
                 }
             }
         }
         return lst;
     }
 
     // 所有方法列表
     public static List<TransformVO> getMethod(String rootPath, List<Element> els) {
         List<TransformVO> lst = Lists.newArrayList();
         String wsPath = "";
         String returnType = "";
         for (Element el : els) {
             returnType = transform2JavaType(getReturnType(el));
             wsPath = el.attribute("path").getText();
             if(!"java.lang.Object".equals(returnType)){  //此处我做了判断，只需要简单类型和void类型的方法
                 TransformVO vo = new TransformVO();
                 vo.setUrl(transform2JavaType(rootPath + wsPath));
                 vo.setUrlMethodName(transform2JavaType(returnType + "   " + replaceSeparatorLine(wsPath) + getParamters(el)));
                 vo.setMethodName(transform2JavaType(wsPath));
                 vo.setReturnType(returnType);
                 List<TransformParamVO> paramLst = getParamterVO(el);
                 vo.setTransformParamLst(paramLst);
                 lst.add(vo);
             }
         }
         return lst;
     }
 
     /**
      * 获取方法的所有参数
      * 
      * @param el
      * @return 参数字符串
      */
     public static String getParamters(Element el) {
         StringBuffer buf = new StringBuffer("(");
         Element requestEl = el.element("method").element("request");
         if (!StringUtil.isNullOrEmpty(requestEl)) {
             if (requestEl.hasContent()) {
                 for (Element paramEl : (List<Element>) requestEl.elements()) {
                     if ("param".equals(paramEl.getName())) {
                         buf.append(paramEl.attributeValue("type") + "  " + paramEl.attributeValue("name") + ",   ");
                     }
                     if ("representation".equals(paramEl.getName())) {
                         if (paramEl.hasContent()) {
                             for (Element pEl : (List<Element>) paramEl.elements()) {
                                 buf.append(pEl.attributeValue("type") + "  " + pEl.attributeValue("name") + ",   ");
                             }
                         }
                     }
                 }
             }
         }
         buf.append(")");
         return buf.toString();
     }
 
     public static List<TransformParamVO> getParamterVO(Element el) {
         List<TransformParamVO> lst = Lists.newArrayList();
         Element requestEl = el.element("method").element("request");
         if (!StringUtil.isNullOrEmpty(requestEl)) {
             if (requestEl.hasContent()) {
                 for (Element paramEl : (List<Element>) requestEl.elements()) {
                     if ("param".equals(paramEl.getName())) {
                         TransformParamVO vo = new TransformParamVO();
                         vo.setName(paramEl.attributeValue("name"));
                         vo.setType(transform2JavaType(paramEl.attributeValue("type")));
                         lst.add(vo);
                     }
                     if ("representation".equals(paramEl.getName())) {
                         if (paramEl.hasContent()) {
                             for (Element pEl : (List<Element>) paramEl.elements()) {
                                 TransformParamVO vo = new TransformParamVO();
                                 vo.setName(pEl.attributeValue("name"));
                                 vo.setType(transform2JavaType(pEl.attributeValue("type")));
                                 lst.add(vo);
                             }
                         }
                     }
                 }
             }
         }
         return lst;
     }
 
     /*
      * 获取返回类型
      */
     public static String getReturnType(Element el) {
         String returnType = "";
         List<Element> returnTypeEls = el.element("method").element("response").elements("representation");
         if (!StringUtil.isNullOrEmpty(returnTypeEls)) {
             if (returnTypeEls.isEmpty()) {
                 if (!StringUtil.isNullOrEmpty(el.element("method").element("response").attribute("status"))) {
                     if ("204".equals(el.element("method").element("response").attribute("status").getText())) {
                         returnType = "void";
                     }
                 }
             } else {
                 for (Element returnTypeEl : returnTypeEls) {
                     if (returnTypeEl.hasContent()) {
                         for (Element pEl : (List<Element>) returnTypeEl.elements()) {
                             returnType = pEl.attributeValue("type");
                         }
                     } else {
                         returnType = "java.lang.Object";
                     }
                 }
             }
         }
         return returnType;
     }
 
     private static String transform2JavaType(String str) {
         if (!StringUtil.isNullOrEmpty(str)) {
             if (str.contains("xs:int")) {
                 str = str.replaceAll("xs:int", "java.lang.Integer");
             }
             if (str.contains("xs:string")) {
                 str = str.replaceAll("xs:string", "java.lang.String");
             }
             if (str.contains("xs:boolean")) {
                 str = str.replaceAll("xs:boolean", "java.lang.Boolean");
             }
             if (str.contains("xs:double")) {
                 str = str.replaceAll("xs:double", "java.lang.Double");
             }
             if (str.contains("xs:dateTime")) {
                 str = str.replaceAll("xs:dateTime", "java.util.Date");
             }
             if (str.lastIndexOf(",") > 0) {
                 str = str.substring(0, str.lastIndexOf(",")) + ")";
             }
         }
         return str;
     }
     private static String replaceSeparatorLine(String str) {
         if (!StringUtil.isNullOrEmpty(str)) {
             if (str.contains("/")) {
                 str = str.replaceAll("\\/", "");
             }
         }
         return str;
     }
 
     /**
      * 后去需要转换的xml内容
      * 
      * @param url
      *            访问的webservice url
      * @return xml内容
      */
     private static String getTransformXml(String url) {
         String xml = "";
         HttpClient httpClient = new HttpClient();
         GetMethod getMethod = new GetMethod(url);
         try {
             int statusCode = httpClient.executeMethod(getMethod);
             if (statusCode != HttpStatus.SC_OK) {
                 System.err.println("Method failed: " + getMethod.getStatusLine());
             }
             // 读取内容
             byte[] responseBody = getMethod.getResponseBody();
             // 处理内容
             xml = new String(responseBody);
         } catch (Exception e) {
             System.err.println("页面无法访问");
         } finally {
             getMethod.releaseConnection();
         }
         return xml;
     }
 
 }

TransformVO.java

package com.qya.vo.transform;
 
 import java.io.Serializable;
 import java.util.List;
 
 import com.google.common.collect.Lists;
 
 public class TransformVO implements Serializable {
     
     private static final long serialVersionUID = -8192032660217273046L;
     private String url;
     private String urlMethodName;
     private String methodName;
     private String returnType;
     private List<TransformParamVO> transformParamLst = Lists.newArrayList();
     public String getUrl() {
         return url;
     }
     public void setUrl(String url) {
         this.url = url;
     }
     public String getUrlMethodName() {
         return urlMethodName;
     }
     public void setUrlMethodName(String urlMethodName) {
         this.urlMethodName = urlMethodName;
     }
     public String getMethodName() {
         return methodName;
     }
     public void setMethodName(String methodName) {
         this.methodName = methodName;
     }
     public String getReturnType() {
         return returnType;
     }
     public void setReturnType(String returnType) {
         this.returnType = returnType;
     }
     public List<TransformParamVO> getTransformParamLst() {
         return transformParamLst;
     }
     public void setTransformParamLst(List<TransformParamVO> transformParamLst) {
         this.transformParamLst = transformParamLst;
     }
 }

 TransformParamVO.java

package com.qya.vo.transform;
 
 import java.io.Serializable;
 
 public class TransformParamVO implements Serializable {
 
     private static final long serialVersionUID = 2728404017781534263L;
     private String type;
     private String name;
     public String getType() {
         return type;
     }
     public void setType(String type) {
         this.type = type;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     
 }

StringUtil.java

package com.qya.utils.string.StringUtil

public class StringUtil {

    /**
     * 判断是否为空后null
     * 
     * @param obj
     *            对象
     * @return boolean
     * @since 1.0
     */
    public static boolean isNullOrEmpty(Object obj) {
        return obj == null || "".equals(obj.toString());
    }
}