对象与xml互相转换、通过xml报文形式发送请求

已于 2022-03-08 15:26:40 修改
阅读量3.1k 收藏 14
点赞数 3
分类专栏： java 文章标签： java xml
于 2021-03-29 21:57:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49319251/article/details/115230884
版权

本文提供两种方式：
方式一：解析固定格式xml报文更方便，但未找到使用泛型时，解析的方式；
方式二：可根据不同接口，报文不同，改变实体（更复杂，功能更强大）；
方式三：可使用泛型；

方法一

所需依赖：

    <dependency>
        <groupId>dom4j</groupId>
        <artifactId>dom4j</artifactId>
        <version>1.6.1</version>
    </dependency>

    <!--解析xml报文-->
    <dependency>
        <groupId>com.thoughtworks.xstream</groupId>
        <artifactId>xstream</artifactId>
        <version>1.4.10</version>
    </dependency>

发送xml报文请求：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;


public class HttpPostXml {

    //获取数据超时时间60秒
    private final int OVERTIME = 60000;

    /*@Value("${sysHead.userLang}")
    private String userLang;*/

    /**
     * 创建连接，发送xml请求报文，获取响应报文
     *
     * @param urlStr  请求路径
     * @param bodyStr body标签数据字符串
     * @return
     */
    public String httpRequestAndTransData(InputSysHead sysHead, InputAppHead appHead, String urlStr, String bodyStr) {
        String line = "";
        StringBuffer resXmlStr = new StringBuffer();
        try {
            //1.声明URL
            URL url = new URL(urlStr);
            //2.创建链接
            URLConnection con = url.openConnection();
            //3.封装报文传输进行传输
            //调用getXmlInfo()进行报文封装
            String xmlInfo = getXmlInfo(sysHead, appHead, bodyStr);
            byte[] xmlData = xmlInfo.getBytes();
            con.setDoOutput(true);
            con.setDoInput(true);
            con.setUseCaches(false);
            con.setRequestProperty("Pragma:", "no-cache"); //指示请求或响应消息不能缓存
            /*
             * Cache-Control 指定请求和响应遵循的缓存机制
             *  在请求消息或响应消息中设置Cache-Control并不会修改另一个消息处理过程中的缓存处理过程
             *   请求时的缓存指令包括no-cache、no-store、max-age、max-stale、min-fresh、only-if-cached
             *   响应消息中的指令包括public、private、no-cache、no-store、no-transform、must-revalidate、proxy-revalidate、max-age
             *  Public指示响应可被任何缓存区缓存。
             *  Private指示对于单个用户的整个或部分响应消息，不能被共享缓存处理。这允许服务器仅仅描述当用户的部分响应消息，此响应消息对于其他用户的请求无效。
             *  no-cache指示请求或响应消息不能缓存
             *  no-store用于防止重要的信息被无意的发布。在请求消息中发送将使得请求和响应消息都不使用缓存。
             *  max-age指示客户机可以接收生存期不大于指定时间（以秒为单位）的响应。
             *  min-fresh指示客户机可以接收响应时间小于当前时间加上指定时间的响应。
             *  max-stale指示客户机可以接收超出超时期间的响应消息。如果指定max-stale消息的值，那么客户机可以接收超出超时期指定值之内的响应消息。
             */
            con.setRequestProperty("Cache-Control", "no-cache");
            con.setRequestProperty("Content-Type", "text/xml");
            //设置超时时间60s
            con.setReadTimeout(OVERTIME);
            con.setRequestProperty("Content-length", String.valueOf(xmlData.length));
            OutputStreamWriter out = new OutputStreamWriter(con.getOutputStream());
            out.write(new String(xmlInfo.getBytes("ISO-8859-1")));
            out.flush();
            out.close();
            //4.获取响应报文
            BufferedReader br = new BufferedReader(new InputStreamReader(
                    con.getInputStream()));
            //返回响应报文
            for (line = br.readLine(); line != null; line = br.readLine()) {
                resXmlStr.append(line);
            }
            return resXmlStr.toString();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return resXmlStr.toString();
    }

    /**
     * 接收数据,拼接生成请求报文。需要根据需求自行添加body标签
     *
     * @param sysHead  输入系统头
     * @param appHead  输出应用头
     * @param bodyStr  body标签数据字符串
     * @return
     */
    private static String getXmlInfo(InputSysHead sysHead, InputAppHead appHead, String bodyStr) {

        // 系统头和应用头标签是死的.数据是活的，根据接口不同变化，body标签、数据是活的 （读配置文件）
        // 系统头和应用头
        StringBuilder sb = new StringBuilder();
        sb.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
        sb.append("<service>");
        sb.append("    <SYS_HEAD>");
        sb.append("        <SvcCd>" + sysHead.getSvcCd() + "</SvcCd>");
        sb.append("        <SvcScn>" + sysHead.getSvcScn() + "</SvcScn>");
        sb.append("        <CnsmSysId>" + sysHead.getCnsmSysId() + "</CnsmSysId>");
        sb.append("        <ChnlTp>" + sysHead.getChnlTp() + "</ChnlTp>");
        sb.append("        <SrcSysId>" + sysHead.getSrcSysId() + "</SrcSysId>");
        sb.append("        <SrcSysSeqNo>" + sysHead.getSrcSysSeqNo() + "</SrcSysSeqNo>");
        sb.append("        <CnsmSysSeqNo>" + sysHead.getCnsmSysSeqNo() + "</CnsmSysSeqNo>");
        sb.append("        <Mac/>");
        sb.append("        <TranMD>" + sysHead.getTranDt() + "</TranMD>");
        sb.append("        <TranDt>" + sysHead.getTranDt() + "</TranDt>");
        sb.append("        <TranTm>" + sysHead.getTranTm() + "</TranTm>");
        sb.append("        <TmnlNo>" + sysHead.getTmnlNo() + "</TmnlNo>");
        sb.append("        <SrcSysTmnlNo/>");
        sb.append("        <CnsmSysSvrId/>");
        sb.append("        <SrcSysSvrId/>");
        sb.append("    </SYS_HEAD>");
        sb.append("    <APP_HEAD>");
        sb.append("        <TlrNo>" + appHead.getTlrNo() + "</TlrNo>");
        sb.append("        <BranchId>" + appHead.getBranchId() + "</BranchId>");
        sb.append("        <TlrPswd/>");
        sb.append("        <TlrLvl/>");
        sb.append("        <TlrTp/>");
        sb.append("        <AprvFlg/>");
        sb.append("        <AuthFlg/>");
        sb.append("    </APP_HEAD>");
		/*sb.append("    <BODY>");
		sb.append("        <AuthTlrStts>" + authTlrStts + "</AuthTlrStts>");
		sb.append("        <InfoNo>" + infoNo + "</InfoNo>");
		sb.append("    </BODY>");*/

//		sb.append("</service>");
        return sb.toString() + bodyStr;
    }
}

解析响应报文：

public class XmlToBean {

    public ServiceXml readStringXml(String xmlStr) {

        XStream xs = new XStream();
        // 设置默认安全性。解决Security framework of XStream not initialized, XStream is probably vulnerable.
        XStream.setupDefaultSecurity(xs);
        // 允许类型
        xs.allowTypes(new Class[]{ServiceXml.class});
        // 转换类型
        xs.processAnnotations(new Class[]{ServiceXml.class});
        //把xml转成对象,强转成ServiceXml对象
        ServiceXml obj = (ServiceXml) xs.fromXML(xmlStr);
        return obj;
    }
}

实体：

ServiceXml 类：
@XStreamAlias("service")
public class ServiceXml<T> {

    @XStreamAlias("SYS_HEAD")
    private OutSysHead sysHead;

    @XStreamAlias("APP_HEAD")
    private OutAppHead appHead;

    @XStreamAlias("BODY")
    private Body body;
    // private T body;

}
OutAppHead 类：
@XStreamAlias("APP_HEAD")
public class OutAppHead {

    // 机构Id
    @XStreamAlias("BranchId")
    private String branchId;
    
}
OutSysHead 类：
@XStreamAlias("SYS_HEAD")
public class OutSysHead {

    // 服务代码
    @XStreamAlias("SvcCd")
    private String svcCd;

    // 服务场景
    @XStreamAlias("SvcScn")
    private String svcScn;

	// 系统头中的array标签
    @XStreamAlias("array")
    private OutSysHeadArray sysHeadArray;
	
}
OutSysHeadArray 类：
/**
 * 系统头中的array标签
 */
@XStreamAlias("array")
public class OutSysHeadArray {

    // 交易返回信息数组
    @XStreamImplicit(itemFieldName = "RetInf")
    private List<OutSysRetInfo> retInfos;

}
OutSysRetInfo 类：
/**
 * 系统头交易返回数组中元素
 */
@XStreamAlias("RetInfo")
public class OutSysRetInfo {

    // 交易返回代码
    @XStreamAlias("RetCode")
    private String retCd;

    // 交易返回信息
    @XStreamAlias("RetMsg")
    private String retMsg;

}
响应报文：
String xmlStr = "<?xml version="1.0" encoding="utf-8"?><service><SYS_HEAD><SvcCd>123</SvcCd>" +
                "<SvcScn>22</SvcScn><array><RetInf><RetMsg>交易成功</RetMsg></RetInf></array></SYS_HEAD>" +
                "<APP_HEAD><BranchId>0099</BranchId></APP_HEAD><BODY><InfoNo>0</InfoNo></BODY></service>";
问题：

以上方法，解析响应报文时，ServiceXml 使用泛型，会报错，暂未找到解决方法

方法二：

所需依赖：

    <dependency>
        <groupId>com.squareup.retrofit2</groupId>
        <artifactId>retrofit</artifactId>
        <version>2.6.1</version>
    </dependency>
    <dependency>
        <groupId>com.squareup.retrofit2</groupId>
        <artifactId>adapter-rxjava2</artifactId>
        <version>2.6.1</version>
    </dependency>
    <dependency>
        <groupId>io.reactivex.rxjava2</groupId>
        <artifactId>rxjava</artifactId>
        <version>2.2.11</version>
    </dependency>
    <dependency>
        <groupId>javax.xml.bind</groupId>
        <artifactId>jaxb-api</artifactId>
        <version>2.3.1</version>
    </dependency>
    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>3.14.2</version>
    </dependency>
    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>logging-interceptor</artifactId>
        <version>3.14.2</version>
    </dependency>

application.yml

third: 
	url: http://locahost:9091/	# 结尾必须有/

Config类：从config类入

import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Configuration
public class Config {


    private static Map<String, Object> services = new HashMap<String, Object>();
    private static Logger logger = LoggerFactory.getLogger(Config.class);

    @Autowired
    private ThirdRequestUrl thirdRequestUrl;

    protected HttpLoggingInterceptor loggingInterceptor() {
        //Log相关
        HttpLoggingInterceptor logging = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
            @Override
            public void log(String s) {
                logger.info(s);
            }
        });
        logging.setLevel(HttpLoggingInterceptor.Level.BODY);
        return logging;
    }

    /**
     * 缺省OKHttp配置
     *
     * @return
     */
    private OkHttpClient.Builder getdefOkhttp() {
        OkHttpClient.Builder okHttpClient = new OkHttpClient.Builder();
        okHttpClient.connectTimeout(60, TimeUnit.SECONDS); //连接超时时间
        okHttpClient.readTimeout(60, TimeUnit.SECONDS); //读取超时时间
        okHttpClient.writeTimeout(60, TimeUnit.SECONDS); //写超时
        okHttpClient.addInterceptor(loggingInterceptor()); //写日志拦截器
        okHttpClient.addInterceptor(customHttpLogInterceptor()); //自定义日志拦截器
        //失败重连
        okHttpClient.retryOnConnectionFailure(true);
        return okHttpClient;
    }

    // 拦截器的加载在springcontext之前，所以自动注入的mapper是null，需要添加拦截器之前用@bean注解将拦截器注入工厂，接着添加拦截器
    @Bean
    public CustomHttpLogInterceptor customHttpLogInterceptor(){
        return new CustomHttpLogInterceptor();
    }

    protected <T> T createService(Class<T> serviceClass, String baseUrl) {
        OkHttpClient.Builder okHttpClient = getdefOkhttp();
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(baseUrl)
                //设置OKHttpClient
                .client(okHttpClient.build())
                .addConverterFactory(JaxbConverterFactory.create())
//                .addConverterFactory(JacksonConverterFactory.create()) // json 格式转换
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())//
                .build();
        T service = retrofit.create(serviceClass);
        return service;
    }

	//  入口
	@Bean
    public CardServiceAPI cardServiceAPI() {
        return this.createService(CardServiceAPI.class, thirdRequestUrl.getCards());
    }
    
}

CardServiceAPI接口：

import org.springframework.stereotype.Repository;
import retrofit2.Call;
import retrofit2.http.Body;
import retrofit2.http.POST;

@Repository
public interface CardServiceAPI {

    @POST("testCard") // 发送post请求，必须要有路径。即"testCard"不可少
    Call<CardMessage> selectCard(@Body CardMessage message);

}
说明：

1、service层注入此接口；
2、若同一URL（ip + 端口）下，仅具体的“testCard”不同，可写在同一个XxxServiceAPI接口中，改变“testCard”即可。
3、“testCard”不为“/testCard”

JaxbRequestConverter类：请求转换器：请求实体转换为xml

import com.sun.xml.internal.bind.marshaller.CharacterEscapeHandler;
import okhttp3.RequestBody;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import retrofit2.Converter;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.*;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;

final class JaxbRequestConverter<T> implements Converter<T, RequestBody> {


    private static Logger logger = LoggerFactory.getLogger(JaxbRequestConverter.class);
    final JAXBContext context;
    final Class<T> type;

    JaxbRequestConverter(JAXBContext context, Class<T> type) {
        this.context = context;
        this.type = type;
    }

    public RequestBody convert(T value) throws IOException {
        StringBuilder data = new StringBuilder("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
        try {
            StringWriter original = new StringWriter();
            Marshaller marshaller = this.context.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_ENCODING, JaxbConverterFactory.XML.charset().name());// //编码格式
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, false);// 是否格式化生成的xml串
            // 不进行转义字符的处理
            marshaller.setProperty(CharacterEscapeHandler.class.getName(), new CharacterEscapeHandler() {
                public void escape(char[] ch, int start,int length, boolean isAttVal, Writer writer) throws IOException {
                    writer.write(ch, start, length);
                }
            });
            marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);// 是否省略xm头声明信息
            marshaller.marshal(value, original);
            logger.debug(original.toString());
            data.append(original.toString());
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException(e);
        }
        return RequestBody.create(JaxbConverterFactory.XML, data.toString());
    }

}

JaxbResponseConverter类：响应转换器：响应报文xml转为实体

import com.oneconnect.sg.hub.client.utils.AesCbcPkcs5Base64Utils;
import okhttp3.ResponseBody;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import retrofit2.Converter;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import java.io.IOException;
import java.io.StringReader;

final class JaxbResponseConverter<T> implements Converter<ResponseBody, T> {

    private static Logger logger = LoggerFactory.getLogger(JaxbResponseConverter.class);

    final XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
    final JAXBContext context;
    final Class<T> type;

    JaxbResponseConverter(JAXBContext context, Class<T> type) {
        this.context = context;
        this.type = type;
    }

    public T convert(ResponseBody value) throws IOException {
        try {
            StringBuilder data = new StringBuilder(value.string());
            //String key = SpringUtils.getProperty("app.owsdl.encrypt.key");

            String key = "qyxjjb74cidnc16b";  // 加密秘钥
            String iv = "xf073abfru46awwt";  // 解密秘钥
           // String iv = SpringUtils.getProperty("app.owsdl.encrypt.iv");
            String cKey = key + "|" + iv;
            if (data.indexOf("<body>") > -1) {
                int start = data.indexOf("<body>") + 6;
                int end = data.indexOf("</body>");
                String body = data.substring(start, end);
                body = body.trim();
                String de = AesCbcPkcs5Base64Utils.getDecryString(body, cKey);
                data.replace(start, end, de);
            }
            logger.debug(data.toString());
            Unmarshaller unmarshaller = this.context.createUnmarshaller();
            XMLStreamReader streamReader = this.xmlInputFactory.createXMLStreamReader(new StringReader(data.toString()));
            return unmarshaller.unmarshal(streamReader, this.type).getValue();
        } catch (XMLStreamException | JAXBException var4) {
            throw new RuntimeException(var4);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

JaxbConverterFactory类：转换器工厂

import io.reactivex.annotations.Nullable;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import okhttp3.ResponseBody;
import retrofit2.Converter;
import retrofit2.Retrofit;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.annotation.XmlRootElement;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;

public class JaxbConverterFactory extends Converter.Factory {

    static final MediaType XML = MediaType.parse("application/xml; charset=utf-8");
    @Nullable
    private final JAXBContext context;

    public static JaxbConverterFactory create() {
        return new JaxbConverterFactory(null);
    }

    public static JaxbConverterFactory create(JAXBContext context) {
        if (context == null) {
            throw new NullPointerException("context == null");
        } else {
            return new JaxbConverterFactory(context);
        }
    }

    private JaxbConverterFactory(@Nullable JAXBContext context) {
        this.context = context;
    }

    public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
        return type instanceof Class && ((Class)type).isAnnotationPresent(XmlRootElement.class) ? new JaxbRequestConverter(this.contextForType((Class)type), (Class)type) : null;
    }

    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
        return type instanceof Class && ((Class)type).isAnnotationPresent(XmlRootElement.class) ? new JaxbResponseConverter(this.contextForType((Class)type), (Class)type) : null;
    }

    private JAXBContext contextForType(Class<?> type) {
        try {
            return this.context != null ? this.context : JAXBContext.newInstance(type);
        } catch (JAXBException var3) {
            throw new IllegalArgumentException(var3);
        }
    }
}

实体：

Message类：
import javax.xml.bind.annotation.*;

@XmlAccessorType(XmlAccessType.NONE)
//@XmlRootElement(name = "service")
//@XmlSeeAlso({String.class, CustomerBody.class, CardBody.class,})
public class Message {

    @XmlElement(name = "SYS_HEAD")
    private SysHead sysHead;

    @XmlElement(name = "APP_HEAD")
    private AppHead appHead;

//    @XmlAnyElement(lax = true)
//    private T body;

    public SysHead getSysHead() {
        return sysHead;
    }

    public void setSysHead(SysHead sysHead) {
        this.sysHead = sysHead;
    }

    public AppHead getAppHead() {
        return appHead;
    }

    public void setAppHead(AppHead appHead) {
        this.appHead = appHead;
    }

//    public T getBody() {
//        return body;
//    }
//
//    public void setBody(T body) {
//        this.body = body;
//    }
}
SysHead类：固定的（所有请求报文xml、响应报文xml都有的标签、参数）
@XmlAccessorType(XmlAccessType.NONE) //所有属性都不映射为xml的元素
@Data
public class SysHead {

    // 服务代码
    @XmlElement(name = "SvcCd")
    private String svcCd;

    // 服务场景
    @XmlElement(name = "SvcScn")
    private String svcScn;
}
AppHead类：固定的（所有请求报文xml、响应报文xml都有的标签、参数）
@XmlAccessorType(XmlAccessType.NONE) //所有属性都不映射为xml的元素
@Data
public class AppHead {

    // T号
    @XmlElement(name = "TlrNo")
    private String tlrNo;

    // 机构Id
    @XmlElement(name = "BranchId")
    private String branchId;
}
CardMessage类：可变的（根据请求不同而改变。请求报文xml、响应报文xml中BODY标签中的参数不同）
import javax.xml.bind.annotation.*;

@XmlAccessorType(XmlAccessType.FIELD)
@XmlSeeAlso({CardBody.class})
@XmlRootElement(name = "service") // 标签名
public class CardMessage extends Message {

    @XmlElement(name = "BODY")
    private CardBody body;

    public CardBody getBody() {
        return body;
    }

    public void setBody(CardBody body) {
        this.body = body;
    }
}
CardBody类：可变的（根据请求不同而改变。请求报文xml、响应报文xml中BODY标签中的参数不同）
@XmlAccessorType(XmlAccessType.NONE)
//@XmlRootElement(name = "BODY") //标签名 在CardMessage中有@XmlElement(name = "BODY")后，可不写此注解
@ApiModel("卡信息")
@Data
public class CardBody {

    /**
     * 卡号
     */
    @ApiModelProperty("卡号")
    @XmlElement(name = "CstNo") //标签名
    private  String cstNo;

    /**
     * 客户名
     */
    @ApiModelProperty("客户名")
    @XmlElement(name = "CstNm")
    private String cstNm;
    
}

方法三：

使用泛型。

import com.alibaba.druid.util.StringUtils;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.StringReader;
import java.io.StringWriter;

public class XmlToEntity {


    public static <T> T xmlToBean(String xmlStr, Class<T> body) throws JAXBException {
        if (null == body || StringUtils.isEmpty(xmlStr)) {
            return null;
        }
        JAXBContext context = JAXBContext.newInstance(body);
        Unmarshaller unmarshaller = context.createUnmarshaller();
        StringReader stringReader = new StringReader(xmlStr);
        Object unmarshal = unmarshaller.unmarshal(stringReader);
        return (T) unmarshal;
    }

    public static <T> String beanToXml(Class<T> body) throws JAXBException {
        JAXBContext context = JAXBContext.newInstance(body);
        Marshaller marshaller = context.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
        //去掉请求头
        marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
        StringWriter stringWriter = new StringWriter();
        stringWriter.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
        marshaller.marshal(body, stringWriter);
        return stringWriter.toString();
    }
}

说明:

1、根据Body的不同，新建不同XxxBody，同时需要新建XxxMessage类继承Message类；
2、SysHead类、AppHead类为报文中固定的标签。CardBody类根据请求不同，报文中的BODY标签不同，而对应改变；
3、使用泛型；

————以上，两种方式，欢迎交流————

林一.
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
http请求，xml格式
09-25
http请求，传输方式以xml格式，可以以文件的方式传输，或以拼接字符串的方式请求http请求，传输方式以xml格式，可以以文件的方式传输，或以拼接字符串的方式请求
java对象转化为xml报文
E=mc²
08-29 1248
package cn.evun.iLE.restful; import java.util.List; import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlElement; imp
XML请求数据和解析
Suwy say Hello
10-17 795
对JSON习以为常之后，使用XML多少有点不习惯。其实二者差不多。
发送Post请求,内容格式为xml,并获取响应内容
09-19
发送Post请求,内容格式为xml,并获取响应内容
【Ajax】XML请求
zhaohb2016的博客
07-22 1027
XMLHttpRequest是一个内建的浏览器对象，它允许使用JavaScript发送HTTP请求。现如今，我们有一个更为现代的方法叫做fetch，它的出现使得XMLHttpRequest在某种程度上被弃用。
java http 发送xml报文（java发送xml报文实例+参数）
11-24
发送XML报文通常涉及到POST或GET请求，这里以POST请求为例，因为POST更适合发送大量数据，如XML文档。 1. **创建XML文档** 在发送XML之前，我们需要先构建XML文档。可以使用DOM（Document Object Model）或者SAX...
xml报文和java对象互相转换 相关jar包和测试代码
12-20
xml报文和java对象互相转换 相关jar包和测试代码，可以与castor插件java对象和XML自动绑定maping文件生成和java对象一键生成工具1.2(https://download.csdn.net/download/kemoing/10864595)完美配合使用
json与xml互相转换工具类
03-10
json与xml互相转换工具类
xml报文与对象间的转换
12-26
最近做项目数据传输这块最后采用了xml报文的形式来进行传输，所以特地写了一个工具类分享出来，支持xml报文和java对象间的相互转换。采用的是JAXB的形式，可快速解析。具体步骤已经单独写了一个文档放进去了。
Java Bean与xml互相转换的方法分析
08-26
主要介绍了Java Bean与xml互相转换的方法,结合实例形式分析了java bean与xml转换的原理与相关操作技巧,需要的朋友可以参考下
报文与XML之间的转换
04-02
报文： {1:0000458B001 103290032030 102290068892 10329003203001555049 2013011820130205131736 9 } {2::CLZ:00000000002013020513173601555049:WD0:20130118:SBN:103290032030 :52A:103290028025 :50C:03492300040004835:50A:富国天时货币市场基金:RBN:102290068892 :59C:4367421213050341873:59A:何晓蓉:CUN:RMB:32A: 000000000001201:CEF:02:PUR:0:72A:厦门同城资金清算系统支付测试:SIG:实际加押（签）结果 }{C: } 转换后的XML： 0000458B001 103290032030 102290068892 10329003203001555049 2013011820130205131736 9 0 短报文 1 文件 00000000002013020513173601555049 20130118|103290032030|00000000002013020513173601555049|03492300040004835|102290068892|4367421213050341873|RMB12.01|
xml 转 map &&map 转 xml
“花花”公子_龙的博客
05-04 352
/** * @Author : lilong * @Description :xml 转 map * @Date : 15:37 2018/5/3 * @Param : * xml格式字符串 **/ private static Map&lt;String, String&gt; xml2Map(String xml) { ...
Requeset使用XML文件格式的报文
xin.wang的博客
12-08 1832
公司需要与中信银行做银企对接，中信那边提供的接口报文是基于XML文件的，为测试此类接口，自己封装了一个request使用XML文件格式的报文请求。 public class TestHttp { public void testRegist(){ try{ StringBuffer sb = new StringBuffer(" ");
java xml请求_JAVA发送xml格式的接口请求
weixin_39881575的博客
02-12 676
/**** @param urlStr 接口地址* @param xmlInfo xml格式参数数据* @return*/public static String sendMsgXml(String urlStr, String xmlInfo) {StringBuffer buffer = new StringBuffer();try {URL url = new URL(urlStr);...
解析xml文件中定义的请求报文和返回报文字段
wlinshan的博客
06-22 2487
//文件路径 String filePath="com/filePath/config/"+（服务编码）+"_"+（服务场景编码）+".xml";   //ClassPathResource类，如果没有指定相对的类名，该类将从类的根路径开始寻找某个resource， //如果指定了相对的类名，则根据指定类的相对路径来查找某个resource。 Resource res = new Cla
xml七种请求方式
最新发布
m0_74390904的博客
01-09 1236
3、GET方法传输的数据量一般限制在2KB，其原因在于：GET是通过URL提交数据，而URL本身对于数据没有限制，但是不同的浏览器对于URL是有限制的，比如IE浏览器对于URL的限制为2KB，而Chrome，FireFox浏览器理论上对于URL是没有限制的，它真正的限制取决于操作系统本身；显然，PUT和POST用途是不一样的。本质上来讲， PUT和POST极为相似，都是向服务器发送数据，但它们之间有一个重要区别，PUT通常指定了资源的存放位置，而POST则没有，POST的数据存放位置由服务器自己决定。
Java 以XML格式的http请求 客户端请求报文框架搭建
qq_30957059的博客
09-20 2967
//供调用的类 /**  * 平台交互控制中心  */ public abstract class PlatformController {     private static Logger logger = LoggerFactory.getLogger(PlatformController.class);     private String comCode =
掌握 Ajax，第 7 部分: 在请求和响应中使用 XML
Andrew Wang的专栏
11-02 1553
偶尔使用 Ajax 的开发人员也会注意到 Ajax 中的 x 并意识到它代表 XML。XML 是编程中最常用的数据格式之一，对于异步应用程序中的服务器响应能够带来切实的好处。在本文中，您将看到服务器如何在请求响应中发送 XML。 现在如果不使用 XML 就不能进行任何有意义的编程。无论考虑转向 XHTML 的网页设计人员、使用 JavaScript 的 Web 程序员、使用部署描述文件和数
反射技巧：Model与XML的自动转换实现
"该资源主要介绍如何利用C#中的反射机制将Model对象与XML文档进行相互转换，实现数据的便捷存储和读取。" 在.NET框架中，反射是一种强大的机制，它允许程序在运行时检查自身的信息，如类型、成员、属性等，并能动态...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值