JavaBean转XML

最新推荐文章于 2024-07-15 03:19:55 发布
最新推荐文章于 2024-07-15 03:19:55 发布
阅读量965 收藏 1
点赞数 1
文章标签： xml java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengwuJ/article/details/130997806
版权

前言：

        某些业务场景，需要传输xml文件，本案例基于jackson-xml实现了javaBean向XML的转化，同时自定义了某些注解和DIY序列化方法；支持自定义xml-header信息；支持对list数组的特殊处理，如将list序列化为<list><object><prop></prop></object><object><prop></prop></object></list>  或者 <list><prop></prop></list><list><prop></prop></list>

XmlEncoder：本来是用于openfeign序列化的，现在单独提出来当作工具类使用，主要基于注解实现的序列化功能定制

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import feign.codec.EncodeException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

@Slf4j
public class XmlEncoder {

    private static final String XML_ELEMENT_SPLIT_SYMBOL = ";";

    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    //解析为 xml格式数据
    public static String encode(Object object) throws EncodeException {

        if (Objects.isNull(object)) {
            return null;
        }

        ObjectMapper objectMapper = new XmlMapper();
        String body = null;
        try {
            body = objectMapper.writeValueAsString(object);
        } catch (JsonProcessingException ex) {
            throw new RuntimeException(ex);
        }

        //fix hide list sub table ---- 不带头部信息 ---document.asXML默认会使用utf-8 encoding
        body = hideListSubTable(body, object);

        //append xml header ---- 自定义头部信息
        body = appendHeader(body, object);

        return body;
    }

    private static String hideListSubTable(String body, Object object) {
        //判断是否需要对List列表进行特殊处理
        if (StringUtils.isNotBlank(body) && object.getClass().isAnnotationPresent(XmlListHideSubTableEnabled.class)) {
            XmlListHideSubTableEnabled xmlListHideSubTableEnabled = object.getClass().getAnnotation(XmlListHideSubTableEnabled.class);
            if (!xmlListHideSubTableEnabled.value()) {
                return body;
            }

            //读取Body信息文档
            try {
                //装载Body为Document文档
                Document document = DocumentHelper.parseText(body);

                //查询该文档下需要处理的XML List数组，递归平铺----key: 从根节点开始到当前对象（节点）链路   v: 当前对象（节点）的多个List属性
                Map<String, Set<Field>> nameFieldsMap = findHideListSubTableFields(document.getRootElement().getName(), object);

                //处理List数据
                for (String elePath : nameFieldsMap.keySet()) {
                    Set<Field> fields = nameFieldsMap.get(elePath);
                    for (Field field : fields) {
                        doHideListSubTable(document,elePath, field);
                    }
                }

                //去除头部信息
                body = document.getRootElement().asXML();

            } catch (DocumentException ex) {
                throw new RuntimeException(ex);
            }
        }
        return body;
    }

    /*
     * 源数据结构
     * <root>
     *     <model>
     *         <products>
     *             <product>
     *                 <id>1111</id>
     *             </product>
     *             <product>
     *                 <id>2222</id>
     *             </product>
     *         </products>
     *     </model>
     * <root/>
     *
     * 目标结构
     * <root>
     *     <model>
     *         <products>
     *             <id>1111</id>
     *         </products>
     *         <products>
     *             <id>2222</id>
     *         </products>
     *     </model>
     * <root/>
     *
     * PS:暂不支持List中再次嵌套List的数据处理
     */
    /**
     * @param document  文档
     * @param listTablePath list标签的上级地址，如有数组标签 root;model;products --> 此处则为 root;model ---> /表示为从根节点开始
     * @param field products
     */
    private static void doHideListSubTable(Document document, String listTablePath, Field field) {
        Element parent = findElement(document, listTablePath, true);
        Element listEle = parent.element(getXmlName(field));
        List<List<Element>> listEleContents = findListEleContents(listEle, field);
        if (CollectionUtils.isNotEmpty(listEleContents)) {
            //删除原有的list
            parent.remove(listEle);
            //追加新的list
            for (List<Element> listEleContent : listEleContents) {
                //新增list节点
                Element newListEle = parent.addElement(listEle.getName());
                if (CollectionUtils.isNotEmpty(listEleContent)) {
                    for (Element element : listEleContent) {
                        //为list节点赋值内容
                        newListEle.add(element);
                    }
                }
            }
        }

    }

    private static List<List<Element>> findListEleContents(Element listEle, Field field) {
        if (Objects.isNull(listEle) || Objects.isNull(field) || CollectionUtils.isEmpty(listEle.elements())) {
            return Collections.emptyList();
        }

        String name = field.getName();
        if (field.isAnnotationPresent(JacksonXmlProperty.class)) {
            JacksonXmlProperty annotation = field.getAnnotation(JacksonXmlProperty.class);
            if (StringUtils.isNotBlank(annotation.localName())) {
                name = annotation.localName();
            }
        }

        List<List<Element>> partions = new ArrayList<>();
        for (Element element : listEle.elements()) {
            List<Element> properties = new ArrayList<>();
            if (StringUtils.equals(name, element.getName()) && CollectionUtils.isNotEmpty(element.elements())) {
                for (Element property : element.elements()) {
                    properties.add((Element) property.clone());
                }
            }
            if (CollectionUtils.isNotEmpty(properties)) {
                partions.add(properties);
            }

        }
        return partions;
    }

    private static Element findElement(Document document, String listTablePath, boolean pathIncludeRoot) {

        Element element = document.getRootElement();

        if (StringUtils.isBlank(listTablePath)) {
            return element;
        }

        List<String> eleNames = Arrays.stream(listTablePath.split(XML_ELEMENT_SPLIT_SYMBOL)).collect(Collectors.toList());
        if (pathIncludeRoot) {
            eleNames = eleNames.stream().skip(1).collect(Collectors.toList());
        }

        for (String eleName : eleNames) {
            element = element.element(eleName);
            if (Objects.isNull(element)) {
                throw new RuntimeException("can not find xml element from path: " + listTablePath + ", error ele name: " + eleName);
            }
        }

        return element;
    }

    private static Map<String, Set<Field>> findHideListSubTableFields(String name, Object object) {
        //root name
        if (StringUtils.isBlank(name)) {
            name = getXmlName(object);
        }
        Map<String, Set<Field>> nameFieldsMap = new HashMap<>();
        Set<Field> fieldSet = new HashSet<>();
        Field[] fields = object.getClass().getDeclaredFields();
        BeanWrapper beanWrapper = new BeanWrapperImpl(object);
        for (Field field : fields) {
            if (!isJavaClass(field.getType())) {
                String eleName = getXmlName(field);
                nameFieldsMap.putAll(findHideListSubTableFields(name + XML_ELEMENT_SPLIT_SYMBOL + eleName,
                        beanWrapper.getPropertyValue(field.getName())));
            }
            if (field.isAnnotationPresent(XmlListHideSubTable.class) && field.getAnnotation(XmlListHideSubTable.class).value()) {
                fieldSet.add(field);
            }
        }
        if (CollectionUtils.isNotEmpty(fieldSet)) {
            nameFieldsMap.put(name, fieldSet);
        }
        return nameFieldsMap;
    }

    private static String getXmlName(Object object) {
        if (object.getClass().isAnnotationPresent(JacksonXmlRootElement.class)) {
            return object.getClass().getAnnotation(JacksonXmlRootElement.class).localName();
        }

        String name = object.getClass().toString();
        if (object instanceof Field) {
            Field field = (Field) object;
            if (field.isAnnotationPresent(JacksonXmlElementWrapper.class)) {
                JacksonXmlElementWrapper anno = field.getAnnotation(JacksonXmlElementWrapper.class);
                if (StringUtils.isNotBlank(anno.localName())) {
                    name = anno.localName();
                }
            } else if (field.isAnnotationPresent(JacksonXmlProperty.class)) {
                JacksonXmlProperty anno = field.getAnnotation(JacksonXmlProperty.class);
                if (StringUtils.isNotBlank(anno.localName())) {
                    name = anno.localName();
                }
            }
        }
        return name;
    }

    //判断是否为内置对象，false-->则为用户自定义对象
    private static boolean isJavaClass(Class<?> clz) {
        return clz != null && clz.getClassLoader() == null;
    }

    //判断是否为数组--集合--map类型
    private static boolean isMultiClass(Class<?> clazz) {
        return null != clazz && (clazz.isArray()
                || Collection.class.isAssignableFrom(clazz)
                || Map.class.isAssignableFrom(clazz));
    }

    private static String appendHeader(String body, Object object) {
        if (object.getClass().isAnnotationPresent(XmlHeader.class)) {
            String xmlHeader = object.getClass().getAnnotation(XmlHeader.class).value();
            body = xmlHeader + body;
        }

        return body;
    }


    public static String parseJsonPayload(EmailRequest emailRequest) {
        String xmlStr = encode(emailRequest);
        if (StringUtils.isBlank(xmlStr)) {
            return null;
        }

        // 匹配规则
        //提取xml中的标签
        String xml = extractXml(xmlStr, emailRequest.getEmailBodyNodeNames());
        //转义xml 为 str给到notification
        return StringEscapeUtils.escapeXml(xml);
    }

    private static String extractXml(String xmlStr, List<String> xmlNames) {
        if (CollectionUtils.isEmpty(xmlNames)) {
            return xmlStr;
        }
        StringBuilder sb = new StringBuilder();
        for (Object xmlName : xmlNames) {
            String startNode = "<" + xmlName;
            String endNode = "</" + xmlName + ">";
            String reg = startNode + "(.*?)" + endNode;
            Pattern pattern = Pattern.compile(reg);
            Matcher matcher = pattern.matcher(xmlStr);
            while (matcher.find()) {
                sb.append(matcher.group());
            }
        }
        return sb.toString();
    }

}

PS：以上代码使用encode方法就好，其他的方法是基于encode之后的数据做了一些xml标签的提取工作

相关注解：

//JacksonXmlElementWrapper: jackson的标记list的注解，encode的时候会获取该注解信息
//JacksonXmlProperty：jackson的标记对象标签或者值标签的注解
//JacksonXmlRootElement: jackson的标记根标签的注解

//XmlHeader: 自定义注解，标记在最外层的javaBean上，和xml最外层跟标签一个层级, encode的时候获取该注解信息---> xml头信息
//XmlListHideSubTable: 自定义注解, 标记在List<Model>的javabean属性上，用于判定是否要对list进行特殊处理
//XmlListHideSubTableEnabled: 自定义注解, 标记在最外层的javaBean上，和xml最外层跟标签一个层级

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface XmlHeader {

    String value() default "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";

}

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface XmlListHideSubTable {

    boolean value() default true;

}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface XmlListHideSubTableEnabled {

    boolean value() default true;

}

JavaBean写法

@XmlListHideSubTableEnabled
@XmlHeader
@JsonIgnoreProperties(ignoreUnknown = true)
@JacksonXmlRootElement(localName = "Root")
@AllArgsConstructor
@NoArgsConstructor
@Data
@Builder
public class EmailContentLeaTempRequest extends EmailRequest {

    @Builder.Default
    @JacksonXmlProperty(localName = "xmlns", isAttribute = true)
    private String ns = "ns1";

    @Builder.Default
    @JacksonXmlProperty(localName = "xmlns:xsi", isAttribute = true)
    private String otherNs = "ns2";


    @JacksonXmlProperty(localName = "Model")
    private Model model;


    @Data
    @Builder
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Model {

        @JacksonXmlProperty(localName = "Detail")
        private Detail detail;

        @JsonIgnoreProperties(ignoreUnknown = true)
        @Data
        @Builder
        @AllArgsConstructor
        @NoArgsConstructor
        public static class Detail {

            @Builder.Default
            @JacksonXmlProperty(localName = "xmlns", isAttribute = true)
            private String namespace = "http://xxx.detail/1.0";

            @XmlListHideSubTable
            @JacksonXmlProperty(localName = "Product")
            @JacksonXmlElementWrapper(localName = "Products")
            private List<Product> products;

            @Data
            @Builder
            @AllArgsConstructor
            @NoArgsConstructor
            public static class Product {

                @JacksonXmlProperty(localName = "Name")
                private String productName;

            }
        }
    }

}

fengwuJ
关注
JavaBean与xml互转的方法详解
m0_69526086的博客
05-08 686
/** @throws JAXBException */ @Test public void showMarshaller() { Book book = new Book(); book.setId(100); book.setAuthor(“lin”); book.setCalendar(new Date()); book.setPrice(23.56f); String str = JaxbUtil.converTomXml(book); System.out.println(str); } /*
JavaBean转xml
weixin_30451709的博客
12-19 111
JavaBean转xml的工具就是：XStream XStream的作用： XStream可以把JavaBean对象转换成XML！通常服务器向客户端响应的数据都是来自数据库的一组对象，当我们不能直接把对象响应给响应端，需要把对象转换成XML再响应给客户端，这时就需要使用XStream组合了。 XStream使用： 为了演示XStream的作用，我们需要先...
java数据转Xml
最新发布
weixin_29216957的博客
07-15 97
Java数据转XML 在软件开发中，数据的格式转换是一个常见的需求。其中，将Java对象转换为XML格式是一种常见的方式，用于数据的存储和传输。本文将介绍如何使用Java代码将数据转换为XML格式，并提供相关的代码示例。 什么是XML？ XML（可扩展标记语言）是一种用于存储和传输数据的标记语言。它的设计目标是传输数据，并...
java bean和xml相互转换
q821424508的专栏
08-29 300
这几天在做微信公众号 做的过程中想找个java bean转xml的工具，找了几个用着不知道是配置不好还是怎么回事，都会有一些问题， 然后脑子一热谢了一个javabean和xml的转换的工具里，自己用着还行，虽然有一些约束吧 ， 还是贴出来记录一下      顺便你提一下下，这个转换工具支持属性为集合、数组和非基本属性的对象。   package com.uke.util; ...
Java对象转xml（Object to Xml）
baomingshu的博客
04-18 2088
友情提醒:先看目录，了解文章结构，点击目录可跳转到文章指定位置。
javabean 转xml
博客
11-29 365
javabean 转xml import java.beans.XMLEncoder; import java.io.BufferedOutputStream; import java.io.ByteArrayOutputStream; import java.io.OutputStream; import java.io.UnsupportedEncodingException; import java.util.Date; import java.util.HashMap; import java.ut
xml转javaBean,javaBean转xml,xml标签大小写问题,以及对xml特殊符号的处理
12-10
1. XML转JavaBean： 在Java编程中，XML数据经常需要转换为Java对象以便于操作。这一过程通常通过XML解析器来完成，如JAXB（Java Architecture for XML Binding）或DOM4J等。JAXB提供了一种自动将XML文档映射到Java...
（javax）javaBean转xml
Tastill的博客
10-27 507
一般与第三方公司进行交互时，经常会用到xml报文，生成xml的方式有多种，以前用map转xml，后来发现，在实际工作中，会有很多局限性。 后来改用javaBean转xml，觉得还挺方便的，下面上一下案例代码： 场景一： 该场景是生成（非多层级）xml javaBean类： package test.javabeantoxml; import javax.xml.bind.annot
JavaBean 转换为xml的三种方式比较
04-02
将JavaBean转换为XML是常见的数据交换格式转换需求，特别是在Web服务、数据存储或配置文件中。本文将深入探讨三种将JavaBean转换为XML的方法，并进行比较。 1. **JavaBeans API的XMLEncoder** XMLEncoder是...
JavaBean与XML相互转换
Luck_ZZ的博客
08-04 5241
一、JavaBean注解 1. @XmlRootElement 类级别注解，name属性用于指定生成元素的名字，若不指定，默认使用类名小写作为元素名 //@XmlRootElement(name="mystudent") @XmlRootElement public class Student { } 对应xml： <student> </student> ...
如何将java对象转换成xml
03-17
NULL 博文链接：https://hfkiss44.iteye.com/blog/567137
java转xml
maqingbin8888的专栏
10-29 363
使用jackson系列 &lt;dependency&gt; &lt;groupId&gt;com.fasterxml.jackson.dataformat&lt;/groupId&gt; &lt;artifactId&gt;jackson-dataformat-xml&lt;/artifactId&gt; &lt;version&gt;2.9.5&lt;/version&gt;
JAVABEAN转换为XML
u010921439的专栏
12-24 321
public static String convertToXml(Object obj, String encoding) { String result = null; try { JAXBContext context = JAXBContext.newInstance(obj.getClass()); Marshaller marshaller = context....
JavaBean与xml之间的转换
qq_43026206的博客
03-10 1427
一、前言 做微信公众号平台开发的项目，将会用到将不同类型的对象转换为xml字符串，而后再做相应的处理，下面将对象转xml字符串的功能介绍如下。 二、引入jar包 下载jar链接： https://download.csdn.net/download/qq_43026206/84232983 三、使用方法 1、创建对象 public class BaseMessage { @XStreamAlias("ToUserName") //解决标签体第一个字母大写的问题 private String toUs
使用JAXB实现JavaBean与XML互相转换
m0_37845840的博客
04-10 847
javaBean和xml转换工具类。xml文件根元素的定义。
java bean转xml_Java bean 转为xml
weixin_39692045的博客
02-27 353
Java bean 转为xml可以采用XStream类来完成pom.xmlcom.thoughtworks.xstreamxstream1.4.9public class BaseMessage {@XStreamAliasC"ToUserName")private String toUserName;@XStreamAlias(" FromUserName")private String fro...
通过JAXB，将javaBean转xml
胜煜的博客
01-23 254
最终效果： 代码内容： 1、请求的总体结构model(RequestModel) import javax.xml.bind.annotation.XmlAccessType; import javax.xml.bind.annotation.XmlAccessorType; import javax.xml.bind.annotation.XmlElement; import j
JAXB: JavaBean与XML快速互转及其JAXBContext关键用法
JavaBean与XML之间的互转是Java开发中的一个重要技术，它极大地简化了在前后端交互过程中数据的序列化和反序列化操作。JAXB (Java Architecture for XML Binding) 是一个由Java平台提供的标准API，它允许开发者将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值