使用 xmlSerializer 解析xml 数据方法

由于项目需求，接口协议是xml数据格式传输，所以就需要对发送的数据和接收的数据进行xml封装和解析  

网上有很多使用 dom，dom4j的方式来封装或者解析xml数据，但是需要自己写处理逻辑，我也上网查了下，发现xmlSerializer 又进行封装了一层，直接把json转为xml，xml转成json，感觉更方便了（其实是我偷懒了），我的项目基本是些一个 类，类中的属性就是需要发送的xml属性名称，然后构造出这个类之后，直接用 gson 转成json，再用xmlSerializer 把json转成xml，最后http发出去就行了，返回结果的时候，直接把结果字符串 用xmlSerializer 转成json，再用 gson 直接把json值转成 结果类的属性，感觉方便了许多

使用的jar

<dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.0</version>
</dependency>
    <dependency>
      <groupId>net.sf.json-lib</groupId>
      <artifactId>json-lib</artifactId>
      <version>2.4</version>
</dependency>

贴代码：

xml请求结构：
<?xml version="1.0" encoding="GBK" ?> 
<operation_in>
     <process_code>uuuuuuuu</process_code> 
     <app_id>22222222</app_id> 
     <access_token>abababababba</access_token> 
     <sign /> 
     <verify_code /> 
     <req_type /> 
     <terminal_id /> 
     <accept_seq /> 
     <req_time>20170213154229</req_time> 
     <req_seq>123123123</req_seq> 
 		 <content>
         <eccode>asdadad</eccode> 
         <cycle>1231</cycle> 
      </content>
</operation_in>


public interface AbstractRequest {

    String getOrderId();
}
public class XmlRequest implements AbstractRequest {

    public String app_id = "22222222";
    public String access_token = "abababababba";
    public String sign = "";
    public String verify_code = "";
    public String terminal_id = "";
    public String req_seq;
    public String req_time;

    public XmlRequest(){
        String seq = DateUtil.getDaysAndTimeForSerialKey(System.currentTimeMillis());
        this.req_time = seq;
        this.req_seq = seq + RandomUtils.getByteRandom(5);
    }
 		@Override
    public String getOrderId() {
        return this.req_seq;
    }
}

public class SpecificXmlRequest extends XmlRequest {
    public String process_code = "uuuuuuuu";
    public String req_type = "01";
    public String accept_seq = "";
    public JSONObject content;

    public SpecificXmlRequest(String eccode,String cycle ){
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("eccode",eccode);
        jsonObject.put("cycle",cycle);
        this.content = jsonObject;
    }

}

public String serialization(AbstractRequest abstractRequest) {
        try {
            Gson gson = new Gson();
            JSONObject object = JSONObject.fromObject(gson.toJson(abstractRequest));
            LOGGER.info("serialization object:" + object.toString());

            XMLSerializer xmlSerializer = new XMLSerializer();
            //设置xml根域名，设置xml不显示字段类型
            xmlSerializer.setRootName("operation_in");
            xmlSerializer.setTypeHintsEnabled(false);

            LOGGER.info("serialization result" + object.toString());
            return xmlSerializer.write(object,"GBK");
        }catch (Exception e){
            LOGGER.error("serialization error" + abstractRequest,e);
            return null;
        }
    }

xml结果结构：
<?xml version="1.0" encoding="GBK" ?>
<operation_out>
    <req_seq>2017030118415778780</req_seq>
    <resp_seq>0</resp_seq>
    <resp_time>20170301184200
    </resp_time>
    <response>
        <resp_type>0</resp_type>
        <resp_code>0000</resp_code>
        <resp_desc>
            <![CDATA[成功]]>
        </resp_desc>
    </response>
    <content>
        <resultlist>
            <gprsinfo>
                <user_id>925046300047634331</user_id>
                <usercount>0</usercount>
                <max_value>0</max_value>
                <cumulate_value>0</cumulate_value>
            </gprsinfo>
            <gprsinfo>
                <user_id>925046300047634345</user_id>
                <usercount>10008</usercount>
                <max_value>82001920</max_value>
                <cumulate_value>344</cumulate_value>
            </gprsinfo>
        </resultlist>
    </content>
    <emergency_status>0</emergency_status>
</operation_out>


/**
 * response 接口，定义一些判断接口是否成功  取接口结果的方法
 */
public interface AbstractResponse {

    boolean isSuccess();

    String getResultCode();

    String getResultMsg();

    String getDealResult();

    String getDealMsg();

    void parserResponse(String response);
}
/**
 * XmlResponse类，定义基本的response类，属性是公共的一些属性   比如 resp_code，resp_desc等等 根据具体接口返回结构构造
 */
public class XmlResponse implements AbstractResponse {
    protected String resp_type;
    protected String resp_code;
    protected String resp_desc;
    protected JSONObject content;
    @Override
    public boolean isSuccess() {
        return "0000".equals(resp_code);
    }

    @Override
    public String getResultCode() {
        return resp_code;
    }

    @Override
    public String getResultMsg() {
        return resp_desc;
    }

    @Override
    public String getDealResult() {
        return content.toString();
    }

    @Override
    public String getDealMsg() {
        return resp_desc;
    }
}
/**
 * SpecificXmlResponse类，对应特定接口的类，
 		属性是这个接口自己特有的属性，如gprsInfo
 */
public class SpecificXmlResponse extends XmlResponse {
    protected Object gprsInfo;

		//给特定接口的特定属性进行赋值  下面的判断是因为 返回结果中不一定会有多个gprsInfo 多个的时候 xmlSerializer会解析成 JSONArray  单个时解析成JSONObject
    @Override
    public void parserResponse(String response) {
    /*if(content != null && content.size()>0){
            Object object = content.get("resultlist");
            if( object instanceof JSONArray){
                gprsInfo = new JSONArray();
                gprsInfo = object;
            }else if(object instanceof JSONObject){
                gprsInfo = new JSONObject();
                gprsInfo = ((JSONObject) object).get("gprsinfo");
            }else {
                gprsInfo = "";
            }
        }*/
        if(content != null && content.size()>0){
            gprsInfo =content.get("resultlist");
            if( gprsInfo instanceof JSONArray){
                Iterator iterator = ((JSONArray) gprsInfo).iterator();
                while (iterator.hasNext()){
                    JSONObject jsonObject = (JSONObject) iterator.next();
                    System.out.println(jsonObject.toString());
                }
            }else if(gprsInfo instanceof JSONObject){
                gprsInfo = ((JSONObject) gprsInfo).get("gprsinfo");
                System.out.println(gprsInfo.toString());
            }else {
                System.out.println(gprsInfo.getClass());
            }
        }
    }
}
/**
 * xmlSerializer 方法，用来解析http返回的xml 对应生成 SpecificXmlResponse类对象
 */
public static void xmlSerializer(String xml ){
        XMLSerializer xmlSerializer = new XMLSerializer();
        JSONObject json = (JSONObject) xmlSerializer.read(xml.toString());//xmlSerializer直接构造成json
        System.out.println(json.toString());

				//从构造出的json中取出需要的数据
        JSONObject result = new JSONObject();
        JSONObject resultResponse = (JSONObject) json.get("response");

        result.put("resp_type",resultResponse.getString("resp_type"));
        result.put("resp_code",resultResponse.getString("resp_code"));
        result.put("resp_desc",resultResponse.getString("resp_desc"));

        JSONObject resultContent = (JSONObject) json.get("content");
        result.put("content",resultContent);

        Gson gson = new Gson();
        //使用gson 直接把json数据赋值给 结果类
        SpecificXmlResponse specificXmlResponse = gson.fromJson(result.toString(),SpecificXmlResponse.class);
        //给特定的属性进行赋值
        specificXmlResponse.parserResponse(xml);
        System.out.println(jiangSuMobileGprsPoolResponse.getDealResult());
    }