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，幸好的是我在项目只需要解析简单类型的方法，所以想想也能达到要求.

  1 package xxx.xxx.common;

  2  

  3  import java.util.List;

  4  

  5  import org.apache.commons.httpclient.HttpClient;

  6  import org.apache.commons.httpclient.HttpStatus;

  7  import org.apache.commons.httpclient.methods.GetMethod;

  8  import org.dom4j.Document;

  9  import org.dom4j.DocumentException;

 10  import org.dom4j.DocumentHelper;

 11  import org.dom4j.Element;

 12  

 13  import com.google.common.collect.Lists;

 14  import com.qya.vo.transform.TransformParamVO;

 15  import com.qya.vo.transform.TransformVO;

 16  

 17  import com.qya.utils.string.StringUtil;

 18  

 19  public class TransformWsUrlUtil {

 20  

 21      protected final String DEFAULT_URL = "http://localhost:8080/bpms/services?_wadl";

 22  

 23      public static List<TransformVO> transform(String url) {

 24          String xml = getTransformXml(url);

 25          Document doc = null;

 26          try {

 27              doc = DocumentHelper.parseText(xml);

 28          } catch (DocumentException e) {

 29              e.printStackTrace();

 30          }

 31          List<TransformVO> lst = Lists.newArrayList();

 32          String rootPath = "";

 33          Element resourcesEl = doc.getRootElement().element("resources");

 34          if (resourcesEl.hasContent()) {

 35              List<Element> els = resourcesEl.elements();

 36              for (Element resEl : els) {

 37                  rootPath = resEl.attribute(0).getText();

 38                  if (resEl.hasContent()) {

 39                      lst.addAll(getMethod(rootPath, resEl.elements()));

 40                  }

 41              }

 42          }

 43          return lst;

 44      }

 45  

 46      // 所有方法列表

 47      public static List<TransformVO> getMethod(String rootPath, List<Element> els) {

 48          List<TransformVO> lst = Lists.newArrayList();

 49          String wsPath = "";

 50          String returnType = "";

 51          for (Element el : els) {

 52              returnType = transform2JavaType(getReturnType(el));

 53              wsPath = el.attribute("path").getText();

 54              if(!"java.lang.Object".equals(returnType)){  //此处我做了判断，只需要简单类型和void类型的方法

 55                  TransformVO vo = new TransformVO();

 56                  vo.setUrl(transform2JavaType(rootPath + wsPath));

 57                  vo.setUrlMethodName(transform2JavaType(returnType + "   " + replaceSeparatorLine(wsPath) + getParamters(el)));

 58                  vo.setMethodName(transform2JavaType(wsPath));

 59                  vo.setReturnType(returnType);

 60                  List<TransformParamVO> paramLst = getParamterVO(el);

 61                  vo.setTransformParamLst(paramLst);

 62                  lst.add(vo);

 63              }

 64          }

 65          return lst;

 66      }

 67  

 68      /**

 69       * 获取方法的所有参数

 70       * 

 71       * @param el

 72       * @return 参数字符串

 73       */

 74      public static String getParamters(Element el) {

 75          StringBuffer buf = new StringBuffer("(");

 76          Element requestEl = el.element("method").element("request");

 77          if (!StringUtil.isNullOrEmpty(requestEl)) {

 78              if (requestEl.hasContent()) {

 79                  for (Element paramEl : (List<Element>) requestEl.elements()) {

 80                      if ("param".equals(paramEl.getName())) {

 81                          buf.append(paramEl.attributeValue("type") + "  " + paramEl.attributeValue("name") + ",   ");

 82                      }

 83                      if ("representation".equals(paramEl.getName())) {

 84                          if (paramEl.hasContent()) {

 85                              for (Element pEl : (List<Element>) paramEl.elements()) {

 86                                  buf.append(pEl.attributeValue("type") + "  " + pEl.attributeValue("name") + ",   ");

 87                              }

 88                          }

 89                      }

 90                  }

 91              }

 92          }

 93          buf.append(")");

 94          return buf.toString();

 95      }

 96  

 97      public static List<TransformParamVO> getParamterVO(Element el) {

 98          List<TransformParamVO> lst = Lists.newArrayList();

 99          Element requestEl = el.element("method").element("request");

100          if (!StringUtil.isNullOrEmpty(requestEl)) {

101              if (requestEl.hasContent()) {

102                  for (Element paramEl : (List<Element>) requestEl.elements()) {

103                      if ("param".equals(paramEl.getName())) {

104                          TransformParamVO vo = new TransformParamVO();

105                          vo.setName(paramEl.attributeValue("name"));

106                          vo.setType(transform2JavaType(paramEl.attributeValue("type")));

107                          lst.add(vo);

108                      }

109                      if ("representation".equals(paramEl.getName())) {

110                          if (paramEl.hasContent()) {

111                              for (Element pEl : (List<Element>) paramEl.elements()) {

112                                  TransformParamVO vo = new TransformParamVO();

113                                  vo.setName(pEl.attributeValue("name"));

114                                  vo.setType(transform2JavaType(pEl.attributeValue("type")));

115                                  lst.add(vo);

116                              }

117                          }

118                      }

119                  }

120              }

121          }

122          return lst;

123      }

124  

125      /*

126       * 获取返回类型

127       */

128      public static String getReturnType(Element el) {

129          String returnType = "";

130          List<Element> returnTypeEls = el.element("method").element("response").elements("representation");

131          if (!StringUtil.isNullOrEmpty(returnTypeEls)) {

132              if (returnTypeEls.isEmpty()) {

133                  if (!StringUtil.isNullOrEmpty(el.element("method").element("response").attribute("status"))) {

134                      if ("204".equals(el.element("method").element("response").attribute("status").getText())) {

135                          returnType = "void";

136                      }

137                  }

138              } else {

139                  for (Element returnTypeEl : returnTypeEls) {

140                      if (returnTypeEl.hasContent()) {

141                          for (Element pEl : (List<Element>) returnTypeEl.elements()) {

142                              returnType = pEl.attributeValue("type");

143                          }

144                      } else {

145                          returnType = "java.lang.Object";

146                      }

147                  }

148              }

149          }

150          return returnType;

151      }

152  

153      private static String transform2JavaType(String str) {

154          if (!StringUtil.isNullOrEmpty(str)) {

155              if (str.contains("xs:int")) {

156                  str = str.replaceAll("xs:int", "java.lang.Integer");

157              }

158              if (str.contains("xs:string")) {

159                  str = str.replaceAll("xs:string", "java.lang.String");

160              }

161              if (str.contains("xs:boolean")) {

162                  str = str.replaceAll("xs:boolean", "java.lang.Boolean");

163              }

164              if (str.contains("xs:double")) {

165                  str = str.replaceAll("xs:double", "java.lang.Double");

166              }

167              if (str.contains("xs:dateTime")) {

168                  str = str.replaceAll("xs:dateTime", "java.util.Date");

169              }

170              if (str.lastIndexOf(",") > 0) {

171                  str = str.substring(0, str.lastIndexOf(",")) + ")";

172              }

173          }

174          return str;

175      }

176      private static String replaceSeparatorLine(String str) {

177          if (!StringUtil.isNullOrEmpty(str)) {

178              if (str.contains("/")) {

179                  str = str.replaceAll("\\/", "");

180              }

181          }

182          return str;

183      }

184  

185      /**

186       * 后去需要转换的xml内容

187       * 

188       * @param url

189       *            访问的webservice url

190       * @return xml内容

191       */

192      private static String getTransformXml(String url) {

193          String xml = "";

194          HttpClient httpClient = new HttpClient();

195          GetMethod getMethod = new GetMethod(url);

196          try {

197              int statusCode = httpClient.executeMethod(getMethod);

198              if (statusCode != HttpStatus.SC_OK) {

199                  System.err.println("Method failed: " + getMethod.getStatusLine());

200              }

201              // 读取内容

202              byte[] responseBody = getMethod.getResponseBody();

203              // 处理内容

204              xml = new String(responseBody);

205          } catch (Exception e) {

206              System.err.println("页面无法访问");

207          } finally {

208              getMethod.releaseConnection();

209          }

210          return xml;

211      }

212  

213  }

TransformVO.java

 1 package com.qya.vo.transform;

 2  

 3  import java.io.Serializable;

 4  import java.util.List;

 5  

 6  import com.google.common.collect.Lists;

 7  

 8  public class TransformVO implements Serializable {

 9      

10      private static final long serialVersionUID = -8192032660217273046L;

11      private String url;

12      private String urlMethodName;

13      private String methodName;

14      private String returnType;

15      private List<TransformParamVO> transformParamLst = Lists.newArrayList();

16      public String getUrl() {

17          return url;

18      }

19      public void setUrl(String url) {

20          this.url = url;

21      }

22      public String getUrlMethodName() {

23          return urlMethodName;

24      }

25      public void setUrlMethodName(String urlMethodName) {

26          this.urlMethodName = urlMethodName;

27      }

28      public String getMethodName() {

29          return methodName;

30      }

31      public void setMethodName(String methodName) {

32          this.methodName = methodName;

33      }

34      public String getReturnType() {

35          return returnType;

36      }

37      public void setReturnType(String returnType) {

38          this.returnType = returnType;

39      }

40      public List<TransformParamVO> getTransformParamLst() {

41          return transformParamLst;

42      }

43      public void setTransformParamLst(List<TransformParamVO> transformParamLst) {

44          this.transformParamLst = transformParamLst;

45      }

46  }

 TransformParamVO.java

 1 package com.qya.vo.transform;

 2  

 3  import java.io.Serializable;

 4  

 5  public class TransformParamVO implements Serializable {

 6  

 7      private static final long serialVersionUID = 2728404017781534263L;

 8      private String type;

 9      private String name;

10      public String getType() {

11          return type;

12      }

13      public void setType(String type) {

14          this.type = type;

15      }

16      public String getName() {

17          return name;

18      }

19      public void setName(String name) {

20          this.name = name;

21      }

22      

23  }

StringUtil.java

 1 package com.qya.utils.string.StringUtil

 2 

 3 public class StringUtil {

 4 

 5     /**

 6      * 判断是否为空后null

 7      * 

 8      * @param obj

 9      *            对象

10      * @return boolean

11      * @since 1.0

12      */

13     public static boolean isNullOrEmpty(Object obj) {

14         return obj == null || "".equals(obj.toString());

15     }

16 }