Jackson工具--实现微信支付对象的封装

Jackson工具包

本文工具类，是在支付系统中，针对微信支付的xml解析，和服务之间json解析：

Xml和对象之间转换

Json和对象之间转换

目录

Jackson工具包
目录

Jackson介绍

依赖包

工具类

xml解析

总结

Jackson介绍

Jackson 是一个 Java 用来处理 JSON 格式数据的类库，性能非常好。同时也提供对xml的处理，具体源码请参考Github.

依赖包

项目适应SpringBoot架构，只需要导入xml解析包即可：

<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
</dependency>

工具类

/**
* hxgy Inc.
* Copyright (c) 2004-2017 All Rights Reserved.
*/
package com.hxgy.pay.commons.utils;

import java.io.IOException;
import java.io.StringWriter;
import java.util.Map;

import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;

/**
* jackson工具包
* @author XiongYu
* @version $Id: JacksonUtils.java, v 0.1 2017年4月27日 下午1:52:52 XiongYu Exp $
*/
public class JacksonUtils {

private static final XmlMapper xmlMapper = new XmlMapper();

private static ObjectMapper objectMapper = new ObjectMapper();

//--------------------------------------XML工具---------------------------------------------
/**
* 对象解析出xmlString
* @param request
* @return
* @throws IOException
* @throws JsonMappingException
* @throws JsonGenerationException
* @throws Exception
*/
public static String objectParseXml(Object object) throws JsonGenerationException,
JsonMappingException, IOException {
StringWriter sw = new StringWriter();
xmlMapper.writeValue(sw, object);
return sw.toString();
}

/**
* 输出全部属性 如果xml中存在，对象中没有，则自动忽略该属性 失败返回null
*
* @param xmlContent
* @param clazz
* @return
* @throws IOException
* @throws JsonMappingException
* @throws JsonParseException
*/
public static <T> T xmlToNormalObject(String xmlContent, Class<T> clazz) throws JsonParseException, JsonMappingException, IOException {
return xmlToObject(xmlContent, clazz);
}

/**
* 输出全部属性
* 如果xml中存在，对象中没有，则自动忽略该属性
* 失败返回null
* @param inputStream
* @param clazz
* @return
* @throws IOException
* @throws JsonMappingException
* @throws JsonParseException
*/
public static <T> T xmlToNormalObject(byte[] bytes, Class<T> clazz) throws JsonParseException, JsonMappingException, IOException {
return xmlToObject(bytes, clazz);
}

/**
* 输出全部属性
*
* @param object
* @return
* @throws JsonProcessingException
*/
public synchronized static byte[] toNormalXml(Object object) throws JsonProcessingException {
return objectToXml(Include.ALWAYS, object);
}

private static <T> T xmlToObject(byte[] bytes, Class<T> clazz) throws JsonParseException, JsonMappingException, IOException {
return xmlMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES).readValue(bytes,
clazz);
}

private static <T> T xmlToObject(String xmlContent, Class<T> clazz) throws JsonParseException, JsonMappingException, IOException {
return xmlMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)

4000
.readValue(xmlContent, clazz);
}

private static <T> byte[] objectToXml(Include include, T object) throws JsonProcessingException {
return xmlMapper.setSerializationInclusion(include).writerWithDefaultPrettyPrinter()
.writeValueAsBytes(object);
}

//---------------------------------------------json工具------------------------------------------------

/**
* 输出全部属性
* @param object
* @return
* @throws JsonProcessingException
*/
public static String toNormalJson(Object object) throws JsonProcessingException {
return toJson(Include.ALWAYS, object);
}

/**
* 输出非空属性
* @param object
* @return
* @throws JsonProcessingException
*/
public static String toNonNullJson(Object object) throws JsonProcessingException {
return toJson(Include.NON_NULL, object);
}

/**
* 输出非Null且非Empty(如List.isEmpty)的属性
* @param object
* @return
* @throws JsonProcessingException
*/
public static String toNonEmptyJson(Object object) throws JsonProcessingException {
return toJson(Include.NON_EMPTY, object);
}

/**
* 输出非空属性
* @param object
* @return
* @throws JsonProcessingException
*/
public static String mapToJson(Map<?, ?> map) throws JsonProcessingException {
return objectMapper.writeValueAsString(map);
}

/**
* 转成Json
* @param include
* @param object
* @return
* @throws JsonProcessingException
*/
private static String toJson(Include include, Object object) throws JsonProcessingException {
objectMapper.setSerializationInclusion(include);
return objectMapper.writeValueAsString(object);
}

/**
* 输出全部属性
* 如果json中存在，对象中没有，则自动忽略该属性
* 失败返回null
*
* @param json
* @param clazz
* @return
* @throws IOException
* @throws JsonMappingException
* @throws JsonParseException
*/
public static <T> T jsonToNormalObject(String json, Class<T> clazz) throws JsonParseException, JsonMappingException, IOException {
return toObject(json, clazz);
}

/**
* 转成Object
* @param include
* @param json
* @param clazz
* @return
* @throws IOException
* @throws JsonMappingException
* @throws JsonParseException
*/
private static <T> T toObject(String json, Class<T> clazz) throws JsonParseException, JsonMappingException, IOException {
objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
return objectMapper.readValue(json, clazz);
}

}

xml解析

以微信支付解析为例：

微信支付查询订单官方请求xml示例：

<xml>
<appid>wx2421b1c4370ec43b</appid>
<mch_id>10000100</mch_id>
<nonce_str>ec2316275641faa3aacf3cc599e8730f</nonce_str>
<transaction_id>1008450740201411110005820873</transaction_id>
<sign>FDD167FAA73459FD921B144BAF4F4CA2</sign>
</xml>

请求实体类建立：

/**
* 查询订单请求对象
* @author XiongYu
* @version $Id: OrderQueryResquest.java, v 0.1 2017年4月12日 下午3:19:04 XiongYu Exp $
*/
@ApiModel(value = "微信订单查询对象")
@JacksonXmlRootElement(localName = "xml")
public class WxPayOrderQueryRequest {

/** 公众账号ID */
@ApiModelProperty(value = "公众账号ID", required = true)
private String appid;

/** 商户号 */
@ApiModelProperty(value = "商户号", required = true)
@JacksonXmlProperty(localName = "mch_id")
private String mchId;

/** 子商户公众账号ID*/
@ApiModelProperty(value = "子商户公众账号ID")
@JacksonXmlProperty(localName = "sub_appid")
private String subAppid;

/** 子商户号 */
@ApiModelProperty(value = "子商户号", required = true)
@JacksonXmlProperty(localName = "sub_mch_id")
private String subMchId;

/** 随机字符串*/
@ApiModelProperty(value = "随机字符串", required = true)
@JacksonXmlProperty(localName = "nonce_str")
private String nonceStr;

/** 签名*/
@ApiModelProperty(value = "签名", required = true)
private String sign;

/** 签名类型 */
@ApiModelProperty(value = "签名类型")
@JacksonXmlProperty(localName = "sign_type")
private String signType;

/** 商户订单号 */
@ApiModelProperty(value = "商户订单号", required = true)
@JacksonXmlProperty(localName = "out_trade_no")
private String outTradeNo;

/** 微信订单号 */
@ApiModelProperty(value = "微信订单号")
@JacksonXmlProperty(localName = "transaction_id ")
private String transactionId;

省略getter、setter方法...
}

微信支付查询订单官方响应xml示例：

<xml>
<return_code><![CDATA[SUCCESS]]></return_code>
<return_msg><![CDATA[OK]]></return_msg>
<appid><![CDATA[wx2421b1c4370ec43b]]></appid>
<mch_id><![CDATA[10000100]]></mch_id>
</xml>

微信支付响应对象封装：

@JacksonXmlRootElement(localName = "xml")
public class WxPayRefundResponse{

/** 返回状态码 */
@JacksonXmlProperty(localName = "return_code")
private String returnCode;

/** 返回信息 */
@JacksonXmlProperty(localName = "return_msg")
private String returnMsg;
/*******************省略***********************/
* Getter method for property <tt>returnCode</tt>.
*
* @return property value of returnCode
*/
@JacksonXmlCData(value = true)
public String getReturnCode() {
return returnCode;
}

/**
* Setter method for property <tt>returnCode</tt>.
*
* @param returnCode value to be assigned to property returnCode
*/
public void setReturnCode(String returnCode) {
this.returnCode = returnCode;
}

/**
* Getter method for property <tt>returnMsg</tt>.
*
* @return property value of returnMsg
*/
@JacksonXmlCData(value = true)
public String getReturnMsg() {
return returnMsg;
}

/**
* Setter method for property <tt>returnMsg</tt>.
*
* @param returnMsg value to be assigned to property returnMsg
*/
public void setReturnMsg(String returnMsg) {
this.returnMsg = returnMsg;
}
/*******************省略***********************/

微信支付查询过程：

public ResultTemplate<WxPayOrderQueryResponse> orderQuery(WxPayOrderQueryRequest orderQueryResquest) {
try {
//1、封装请求参数
String params = JacksonUtils.objectParseXml(orderQueryResquest);
//2、请求微信端查询订单
String reponString = HttpUtil.doPost(orderqueryURL, params, "UTF-8",
"text/xml;charset=UTF-8");
//3、封装响应对象
WxPayOrderQueryResponse resultValue = JacksonUtils.xmlToNormalObject(reponString,
WxPayOrderQueryResponse.class);
//4、返回结果
return new ResultTemplate<WxPayOrderQueryResponse>(ReturnCode.OK, resultValue);
} catch (JsonGenerationException e) {
logger.error("请求对象转换为XML字符串是发生异常JsonGenerationException，", e);
} catch (JsonMappingException e) {
logger.error("请求对象转换为XML字符串是发生异常JsonMappingException，", e);
} catch (ClientProtocolException e) {
logger.error("请求微信端查询订单接口发生异常ClientProtocolException，", e);
} catch (JsonParseException e) {
logger.error("响应参数转换对象发生异常JsonParseException，", e);
} catch (IOException e) {
logger.error("微信查询订单接口发生异常，", e);
} catch (Exception e) {
logger.error("微信查询订单接口发生异常", e);
}
return new ResultTemplate<WxPayOrderQueryResponse>(ReturnCode.ERROR, null, "微信订单查询失败！！");
}

总结

使用Jackson工具包实现xml的序列化简单实现了对微信支付所需对象封装，使用简便。