精华内容
下载资源
问答
  • 对象转换xml

    2018-02-12 11:26:22
    winform窗口实现将XML文件内容转换成object对象类型,以及object对象转XML
  • 之前找了好多java对象转xml的代码,有的需要加注解很啰嗦,有的遇到结构复杂的对象就报错;没办法,只好自己研究了……
  • js转换对象xml

    2020-10-20 09:38:45
    本文主要介绍了js转换对象xml的方法。具有很好的参考价值,下面跟着小编一起来看下吧
  • 好用的对象转xml、xml转对象工具类-支持集合嵌套转换(Java实现) 网上找了很多转换工具,对于自己的业务都不是很合适,所以总结了一下网上的方案,最终定下来是这样子的,主要使用dom4j做操作 maven依赖 <...

    好用的对象转xml、xml转对象工具类-支持集合嵌套转换(Java实现)

    网上找了很多转换工具,对于自己的业务都不是很合适,所以总结了一下网上的方案,最终定下来是这样子的,主要使用dom4j做操作

    maven依赖

    <dependency>
       <groupId>dom4j</groupId>
       <artifactId>dom4j</artifactId>
       <version>1.6.1</version>
    </dependency>
    package com.aier.cloud.biz.crm.utils;
    
    
    import org.apache.commons.lang3.StringUtils;
    import org.dom4j.Document;
    import org.dom4j.DocumentException;
    import org.dom4j.DocumentHelper;
    import org.dom4j.Element;
    import org.dom4j.io.OutputFormat;
    import org.dom4j.io.SAXReader;
    import org.dom4j.io.XMLWriter;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    
    import javax.xml.XMLConstants;
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.transform.OutputKeys;
    import javax.xml.transform.Transformer;
    import javax.xml.transform.TransformerFactory;
    import javax.xml.transform.dom.DOMSource;
    import javax.xml.transform.stream.StreamResult;
    import java.io.*;
    import java.lang.reflect.Field;
    import java.math.BigDecimal;
    import java.net.URL;
    import java.text.SimpleDateFormat;
    import java.util.*;
    
    /**
     * @author szz
     * @since 2019/8/5 10:36
     */
    public class XmlUtil {
    
        /**
         * XML格式字符串转换为Map
         *
         * @param strXML XML字符串
         * @return XML数据转换后的Map
         * @throws Exception
         */
        public static Map<String, String> xmlToMap(String strXML) throws Exception {
            try {
                Map<String, String> data = new HashMap<String, String>();
                DocumentBuilder documentBuilder = newDocumentBuilder();
                InputStream stream = new ByteArrayInputStream(strXML.getBytes("GB2312"));
                org.w3c.dom.Document doc = documentBuilder.parse(stream);
                doc.getDocumentElement().normalize();
                NodeList nodeList = doc.getDocumentElement().getChildNodes();
                for (int idx = 0; idx < nodeList.getLength(); ++idx) {
                    Node node = nodeList.item(idx);
                    if (node.getNodeType() == Node.ELEMENT_NODE) {
                        org.w3c.dom.Element element = (org.w3c.dom.Element) node;
                        data.put(element.getNodeName(), element.getTextContent());
                    }
                }
                try {
                    stream.close();
                } catch (Exception ex) {
                    // do nothing
                }
                return data;
            } catch (Exception ex) {
                throw ex;
            }
    
        }
    
    
        public static DocumentBuilder newDocumentBuilder() throws ParserConfigurationException {
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            documentBuilderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
            documentBuilderFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
            documentBuilderFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
            documentBuilderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
            documentBuilderFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
            documentBuilderFactory.setXIncludeAware(false);
            documentBuilderFactory.setExpandEntityReferences(false);
    
            return documentBuilderFactory.newDocumentBuilder();
        }
    
        public static org.w3c.dom.Document newDocument() throws ParserConfigurationException {
            return newDocumentBuilder().newDocument();
        }
        /**
         * 将Map转换为XML格式的字符串
         *
         * @param data Map类型数据
         * @return XML格式的字符串
         * @throws Exception
         */
        public static String mapToXml(Map<String, String> data, String baseTagName, String encoding) throws Exception {
            org.w3c.dom.Document document = newDocument();
            org.w3c.dom.Element root = document.createElement(baseTagName);
            document.appendChild(root);
            for (String key : data.keySet()) {
                String value = data.get(key);
                if (value == null) {
                    value = "";
                }
                value = value.trim();
                org.w3c.dom.Element filed = document.createElement(key);
                filed.appendChild(document.createTextNode(value));
                root.appendChild(filed);
            }
            TransformerFactory tf = TransformerFactory.newInstance();
            Transformer transformer = tf.newTransformer();
            DOMSource source = new DOMSource(document);
            transformer.setOutputProperty(OutputKeys.ENCODING, encoding);
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            StringWriter writer = new StringWriter();
            StreamResult result = new StreamResult(writer);
            transformer.transform(source, result);
            String output = writer.getBuffer().toString(); //.replaceAll("\n|\r", "");
            try {
                writer.close();
            } catch (Exception ex) {
            }
            return output;
        }
    
    
        /**
         * 重载,默认根节点为Request 编码格式为GB2312
         *
         * @param data
         * @return
         * @throws Exception
         */
        public static String mapToXml(Map<String, String> data) throws Exception {
            return mapToXml(data, "Request", "GB2312");
        }
    
    
        /**
         * 反射设置实体不同类型字段的值 <暂时只支持 日期 字符串 boolean Integer值设置 待扩建>
         *
         * @param field
         * @param obj
         * @param value
         * @throws Exception
         */
        public static void convertValue(Field field, Object obj, String value)
                throws Exception {
            SimpleDateFormat sim = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            if (field.getGenericType().toString().equals("class java.lang.Integer")) {
                field.set(obj, Integer.parseInt(value));
            } else if (field.getGenericType().toString().equals("boolean")) {
                field.set(obj, Boolean.parseBoolean(value));
            } else if (field.getGenericType().toString().equals(
                    "class java.util.Date")) {
                field.set(obj, sim.parse(value));
            } else {
                field.set(obj, value);
            }
    
        }
    
        /**
         * 解析xml文件返回保存Map的集合,map中可能包含key值为returnCode、desc、totalCount等单字段.
         * 也可能包含存储对象为List<cls>的集合值.
         * 获取List值key cls_List
         *
         * @param requestPath
         * @param cls
         * @return map
         * @throws Exception
         */
        @SuppressWarnings("unchecked")
        public static Map<String, Object> parseXml2Map(String requestPath,
                                                       Class<?> cls) throws Exception {
            Map<String, Object> maps = new HashMap<String, Object>();
            List<Object> lists = new ArrayList<Object>();
            SAXReader saxReader = new SAXReader();
            //当传入的是xml字符串时,采用这个方案
            Document doc = doc = DocumentHelper.parseText(requestPath);
            Element et = doc.getRootElement();
            // 标记List是否为空
            // boolean bool = true ;
            // 根节点名字
            List<Element> rList = et.elements();
            for (Element element : rList) {
                List<Element> rLists = element.elements();
                if (!rLists.isEmpty() && rLists.size() > 0) {
                    //bool = false;
                    // 判断二级节点
                    for (Element e : rLists) {
                        List<Element> li = e.elements();
                        Class<?> cl = (Class<?>) Class.forName(cls.getName());
                        Object ob = cl.newInstance();
                        for (Element element2 : li) {
                            String name = element2.getName();
                            String value = element2.getText();
                            Field field = ob.getClass().getDeclaredField(name);
                            field.setAccessible(true);
                            convertValue(field, ob, value);
                        }
                        lists.add(ob);
                    }
                } else {
                    maps.put(element.getName(), element.getText());
                }
                //maps.put(cls.getSimpleName() + "_List", lists);
                maps.put("ItemList", lists);
            }
            return maps;
        }
    
    
        /**
         * https://www.cnblogs.com/interdrp/p/5825453.html1
         * 解析xml文件返回保存cls的List集合,如果返回码ResultCode=1时则返回List为null
         *
         * @param xml
         * @param cls
         * @return
         * @throws Exception
         */
        @SuppressWarnings("unchecked")
        public static List<?> parseXml2List(String xml, Class<?> cls)
                throws Exception {
            List<Object> lists = null;
            Document doc = DocumentHelper.parseText(xml);
            Element et = doc.getRootElement();
            String root = et.getName();
            // 查看返回码是否为真.
            List<Element> list = doc.selectNodes("//" + root + "/ResultCode");
            if (!list.isEmpty() && list.size() > 0) {
                Element element = list.get(0);
                String returnResult = element.getText();
                if (returnResult.equals("0")) {
                    List<Element> father = doc.selectNodes("//" + root + "/" + cls.getSimpleName() + "s");
                    //判断对象父节点是否有包含数据
                    if (father != null && !father.isEmpty() && father.size() == 1) {
                        List<Element> userLists = father.get(0).elements();
                        if (userLists != null && !list.isEmpty()) {
                            lists = new ArrayList<Object>();
                            for (Element e : userLists) {
                                List<Element> li = e.elements();
                                Class<?> cl = (Class<?>) Class.forName(cls.getName());
                                Object ob = cl.newInstance();
                                for (Element element2 : li) {
                                    String name = element2.getName();
                                    String value = element2.getText();
                                    Field field = ob.getClass().getDeclaredField(name);
                                    field.setAccessible(true);
                                    convertValue(field, ob, value);
                                }
                                lists.add(ob);
                            }
                        }
                    }
                }
    
            }
            return lists;
        }
    
        /**
         * 解析xml文件返回保存cls的List集合,如果返回码ResultCode=1时则返回List为null
         *
         * @param url
         * @param cls
         * @return
         * @throws Exception
         */
        @SuppressWarnings("unchecked")
        public static List<?> parseXml2List(URL url, Class<?> cls)
                throws Exception {
            List<Object> lists = null;
            SAXReader saxReader = new SAXReader();
            Document doc = saxReader.read(url);
            Element et = doc.getRootElement();
            String root = et.getName();
            // 查看返回码是否为真.
            List<Element> list = doc.selectNodes("//" + root + "/ResultCode");
            if (!list.isEmpty() && list.size() > 0) {
                Element element = list.get(0);
                String returnResult = element.getText();
                if (returnResult.equals("0")) {
                    List<Element> father = doc.selectNodes("//" + root + "/" + cls.getSimpleName() + "s");
                    //判断对象父节点是否有包含数据
                    if (father != null && !father.isEmpty() && father.size() == 1) {
                        List<Element> userLists = father.get(0).elements();
                        if (userLists != null && !list.isEmpty()) {
                            lists = new ArrayList<Object>();
                            for (Element e : userLists) {
                                List<Element> li = e.elements();
                                Class<?> cl = (Class<?>) Class.forName(cls.getName());
                                Object ob = cl.newInstance();
                                for (Element element2 : li) {
                                    String name = element2.getName();
                                    String value = element2.getText();
                                    Field field = ob.getClass().getDeclaredField(name);
                                    field.setAccessible(true);
                                    convertValue(field, ob, value);
                                }
                                lists.add(ob);
                            }
                        }
                    }
                }
    
            }
            return lists;
        }
    
        /**
         * 解析xml文件返回保存Map的集合,map中可能包含key值为returnCode、desc、totalCount等单字段.
         * 也可能包含存储对象为List<cls>的集合值.
         * 获取List值key cls_List
         *
         * @param requestPath
         * @param cls
         * @return map
         * @throws Exception
         */
        @SuppressWarnings("unchecked")
        public static Map<String, Object> parseXml2MapOld(String requestPath,
                                                          Class<?> cls) throws Exception {
            Map<String, Object> maps = new HashMap<String, Object>();
            List<Object> lists = new ArrayList<Object>();
            SAXReader saxReader = new SAXReader();
            //Document doc = saxReader.read(new File(requestPath));
            //Document doc = saxReader.read(new URL(requestPath));
            //当传入的是xml字符串时,采用这个方案
            Document doc = doc = DocumentHelper.parseText(requestPath);
            Element et = doc.getRootElement();
            // 标记List是否为空
            // boolean bool = true ;
            // 根节点名字
            List<Element> rList = et.elements();
            for (Element element : rList) {
                List<Element> rLists = element.elements();
                if (!rLists.isEmpty() && rLists.size() > 0) {
                    //bool = false;
                    // 判断二级节点
                    for (Element e : rLists) {
                        List<Element> li = e.elements();
                        Class<?> cl = (Class<?>) Class.forName(cls.getName());
                        Object ob = cl.newInstance();
                        for (Element element2 : li) {
                            String name = element2.getName();
                            String value = element2.getText();
                            Field field = ob.getClass().getDeclaredField(name);
                            field.setAccessible(true);
                            convertValue(field, ob, value);
                        }
                        lists.add(ob);
                    }
                } else {
                    maps.put(element.getName(), element.getText());
                }
                //maps.put(cls.getSimpleName() + "_List", lists);
                maps.put("ItemList", lists);
            }
            return maps;
        }
    
        /**
         * 只获取返回码0为保存成功(true)1为保存失败(false)
         */
        @SuppressWarnings("unchecked")
        public static boolean parseXmlReturnCode(String xml) {
            boolean bool = false;
            try {
                Document doc = DocumentHelper.parseText(xml);
                Element et = doc.getRootElement();
                String root = et.getName();
                // 查看返回码是否为真.
                List<Element> list = doc.selectNodes("//" + root + "/ResultCode");
                if (!list.isEmpty() && list.size() > 0) {
                    Element element = list.get(0);
                    String returnResult = element.getText();
                    if (returnResult.equals("0")) {
                        bool = true;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return bool;
        }
    
    
        /**
         *
         * https://blog.csdn.net/javaniche/article/details/79655473
         * 格式化输出xml
         *
         * @param document
         * @return
         * @throws DocumentException
         * @throws IOException
         */
        public static String formatXml(Document document) throws DocumentException, IOException {
            // 格式化输出格式
            OutputFormat format = OutputFormat.createPrettyPrint();
            format.setEncoding("GB2312");
            StringWriter writer = new StringWriter();
            // 格式化输出流
            XMLWriter xmlWriter = new XMLWriter(writer, format);
            // 将document写入到输出流
            xmlWriter.write(document);
            xmlWriter.close();
            return writer.toString();
        }
    
        public static Document map2Xml(Map<String, Object> map, String node, String type) throws Exception {
            Document document = DocumentHelper.createDocument();
            Element nodeElement = document.addElement(node);
            map2Xml(map, nodeElement, type);
            return document;
        }
    
        public static final String map2Xml_TYPE_listElementWrapper = "1";
    
        private static void map2Xml(Map<String, Object> map, Element nodeElement, String type) throws Exception {
    
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                String key = (String) entry.getKey();
                Object value = entry.getValue();
                if ((value instanceof List) && StringUtils.isBlank(type)) {
                    Element element = nodeElement.addElement(key);
                    List<Map<String, Object>> list = (List<Map<String, Object>>) value;
                    for (Map<String, Object> subMap : list) {
                        Element itemElement = element.addElement("Item");
                        map2Xml(subMap, itemElement, type);
                    }
                } else if ((value instanceof List) && StringUtils.isNotBlank(type) && type.contains(map2Xml_TYPE_listElementWrapper)) {
                    List<Map<String, Object>> list = (List<Map<String, Object>>) value;
                    for (Map<String, Object> subMap : list) {
                        Element element = nodeElement.addElement(key);
                        map2Xml(subMap, element, type);
                    }
                } else if (value instanceof Map) {
                    Element element = nodeElement.addElement(key);
                    Map<String, Object> valueMap = (Map<String, Object>) value;
                    map2Xml(valueMap, element, type);
                } else if (value instanceof String) {
                    Element keyElement = nodeElement.addElement(key);
                    keyElement.setText((String) value);
                } else if (value instanceof Integer) {
                    Element keyElement = nodeElement.addElement(key);
                    keyElement.setText(((Integer) value).toString());
                } else if (value instanceof BigDecimal) {
                    Element keyElement = nodeElement.addElement(key);
                    keyElement.setText(((BigDecimal) value).toString());
                } else if (value instanceof Date) {
                    Element keyElement = nodeElement.addElement(key);
                    keyElement.setText((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(value)).toString());
                } else {
                    throw new Exception("不支持的 value 类型");
                }
            }
        }
    
    
    }
    

     

    展开全文
  • 这里有三个工具都是利用jdom的jar做的 xml转对象,XmlUtil这个可以直接使用简单的对象转换,没有二级对象以及复杂对象类转换,其他的两个工具类包含其他复杂的代码转换,但是内容需要自己修改
  • JAVA XML转对象 对象转XML

    千次阅读 2018-10-18 11:17:37
    在网上看了许多XML跟Obj互相转换的Demo,但是都很复杂,现在推荐一个极度简单好理解的XML和Obj互的例子: JacksonXML,只需要简单的几个注解就能完成XML和Obj的相互转换 假设有如下xml报文: <?xml version...

    在网上看了许多XML跟Obj互相转换的Demo,但是都很复杂,现在推荐一个极度简单好理解的XML和Obj互转的例子:

    JacksonXML,只需要简单的几个注解就能完成XML和Obj的相互转换

    假设有如下xml报文:

    <?xml version="1.0" encoding="utf-8"?>
    <msgbody>
      <StringList>
        <mx>
          <paramA>Aone</paramA>
          <paramB>Bone</paramB>
        </mx>
        <mx>
          <paramA>Atow</paramA>
          <paramB>Atow</paramB>
        </mx>
      </StringList>
      <serverId>serv10000000156</serverId>
      <name>张三</name>
      <age>女</age>
      <address>武汉市</address>
    </msgbody>
    

    分析这段报文,首先报文头是 <?xml version="1.0" encoding="utf-8"?>

    然后有<msgbody>标签包住报文体,然后有属性serverId,name,age,address 和 一个列表,列表中的每一个单位用<mx>标签分隔开来,最后每个单位中都有paramA 和 paramB 两个属性。

    准备工作添加pom依赖:

    <dependency>
    	<groupId>com.fasterxml.jackson.dataformat</groupId>
    	<artifactId>jackson-dataformat-xml</artifactId>
    	<version>2.9.0</version>
    </dependency>
    <dependency>
    	<groupId>com.fasterxml.woodstox</groupId>
    	<artifactId>woodstox-core</artifactId>
    	<version>5.1.0</version>
    </dependency>

    那么第一步我们创建与这个报文对应的class:

    package com.symphony.springbootdata.demo.xmlTest;
    
    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 java.util.List;
    
    /**
     * 报文对应class
     *
     * @author <a href="***@163.com">***</a>
     * @version 1.0.0
     * @since 1.0.0
     * <p>
     * Created at 2018/9/30
     */
    
    @JacksonXmlRootElement(localName = "msgbody")
    public class Person {
        @JacksonXmlProperty(localName = "serverId")
        private String serverId;
        @JacksonXmlProperty(localName = "name")
        private String name;
        @JacksonXmlProperty(localName = "age")
        private String age;
        @JacksonXmlProperty(localName = "address")
        private String address;
        @JacksonXmlElementWrapper(localName = "StringList")
        private List<Clazz> mx;
    
        public Person() {
        }
    
        public Person(String serverId, String name, String age, String address, List<Clazz> mx) {
            this.serverId = serverId;
            this.name = name;
            this.age = age;
            this.address = address;
            this.mx = mx;
        }
    
        public String getServerId() {
            return serverId;
        }
    
        public void setServerId(String serverId) {
            this.serverId = serverId;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAge() {
            return age;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public List<Clazz> getMx() {
            return mx;
        }
    
        public void setMx(List<Clazz> mx) {
            this.mx = mx;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "serverId='" + serverId + '\'' +
                    ", name='" + name + '\'' +
                    ", age='" + age + '\'' +
                    ", address='" + address + '\'' +
                    ", mx=" + mx +
                    '}';
        }
    }
    
    package com.symphony.springbootdata.demo.xmlTest;
    
    import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
    import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
    
    /**
     * 报文中列表对应class
     *
     * @author <a href="***@163.com">***</a>
     * @version 1.0.0
     * @since 1.0.0
     * <p>
     * Created at 2018/10/9
     */
    @JacksonXmlRootElement(localName = "MX")
    public class Clazz {
        @JacksonXmlProperty(localName = "paramA")
        private String a;
        @JacksonXmlProperty(localName = "paramB")
        private String b;
    
        public String getA() {
            return a;
        }
    
        public void setA(String a) {
            this.a = a;
        }
    
        public String getB() {
            return b;
        }
    
        public void setB(String b) {
            this.b = b;
        }
    
        @Override
        public String toString() {
            return "Clazz{" +
                    "a='" + a + '\'' +
                    ", b='" + b + '\'' +
                    '}';
        }
    }
    

    创建好对应的class之后,开始XML与Obj的转换

    package com.symphony.springbootdata.demo.xmlTest;
    
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.dataformat.xml.XmlMapper;
    import org.junit.Test;
    
    import javax.xml.bind.JAXBException;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * XML Obj 互相转换
     *
     * @author <a href="mailto:***@163.com">***</a>
     * @version 1.0.0
     * @since 1.0.0
     * <p>
     * Created at 2018/9/30
     */
    public class ObjToXmlUtils {
    
        public static void main(String[] args) throws JsonProcessingException {
            List<Clazz> mx = new ArrayList<>();
            Clazz clazz = new Clazz();
            clazz.setA("Aone");
            clazz.setB("Bone");
            mx.add(clazz);
            clazz = new Clazz();
            clazz.setA("Atow");
            clazz.setB("Atow");
            mx.add(clazz);
    
            ObjectMapper mapper = new XmlMapper();
            String s = mapper.writeValueAsString(new Person("serv10000000156", "张三", "女", "武汉市", mx));
            System.out.println("<?xml version=\"1.0\" encoding=\"utf-8\"?>" + s);
        }
    
        @Test
        public void xmlToObj() throws JAXBException, IOException {
            String xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><msgbody><StringList><mx><paramA>Aone</paramA><paramB>Bone</paramB></mx><mx><paramA>Atow</paramA><paramB>Atow</paramB></mx></StringList><serverId>serv10000000156</serverId><name>张三</name><age>女</age><address>武汉市</address></msgbody>\n";
            ObjectMapper mapper = new XmlMapper();
            Object po = null;
            po = mapper.readValue(xml, Person.class);
            System.out.println(po.toString());
        }
    }
    

    综上,我们看到了注解

     @JacksonXmlElementWrapper:指定用于包装List和Map属性的XML元素
     @JacksonXmlProperty:为属性指定XML名称空间和本地名称; 以及是否将属性写为XML元素或属性
     @JacksonXmlRootElement:指定用于包装根元素的XML元素
     @JacksonXmlText:指定当前这个值,没有xml标签包裹

    展开全文
  • xstream-1.4.3.jar 包 对象转xmlxstream-1.4.3.jar 包 对象转xmlxstream-1.4.3.jar 包 对象转xmlxstream-1.4.3.jar 包 对象转xmlxstream-1.4.3.jar 包 对象转xmlxstream-1.4.3.jar 包 对象转xmlxstream-1.4.3.jar 包...
  • xStream可以轻易的将Java对象和xml文档相互转换,本实例详细介绍了运用xStream将对象转xml和xml转对象操作.zip,太多无法一一验证是否可用,程序如果跑不起来需要自调,部分代码功能进行参考学习。
  • NULL 博文链接:https://hfkiss44.iteye.com/blog/567137
  • 实现 XML字符串VO对象的实现 1.0:标签读取,属性读取,List类型标签实现 以下是 测试说明 原XML: <?xml version="1.0" encoding="UTF-8"?> <HEADER NAME="HEADERname" name_cn="头名称">标签text...
  • JAVA对象转XML-使用xtream框架心得

    千次阅读 2018-08-02 00:01:39
    最近跟第三方对接,对方需要的数据为XML格式的,索性就把以前拼接字符串的做法给抛弃了,改用JavaBean直接转XML的方式来做,所以本次研究了Xstream框架来将JaveBeanXML 1.创建基本对象,用于指定生成XML的格式,...

    最近跟第三方对接,对方需要的数据为XML格式的,索性就把以前拼接字符串的做法给抛弃了,改用JavaBean直接转XML的方式来做,所以本次研究了Xstream框架来将JaveBean转成XML
    1.创建基本对象,用于指定生成XML的格式,如下图
    @XStreamAlias(“sitemap”)注解用于指定该对象生成的XML节点名称,比如指定类Sitemap生成的节点名称就如



    这里写图片描述
    当类中包含List属性时,又不想生成这个节点,则可使用注解
    @XStreamImplicit,该注解作用为忽略这个list,不生成该节点,只生成list所包含对象的所有属性所对应的节点,如下图
    这里写图片描述
    当类中属性不用指定别名时,会根据类中属性名称生成对应的节点,如:
    这里写图片描述

    2.如果对象里的值为null,则生成的XML结构里则没有该节点,为了将所有属性都能生成对应的节点,需要改写转换器并使用该转换器讲对象转换XML,所以自定义转换器必须要继承Converter接口,该接口中有三个方法:
    (1):marshal:
    序列化,将JAVA对象转换成XML
    (2):canConvert:
    判断需要序列化的对象是否使用此转换器

    (3):unmarshal:
    序列化,将XML对象转换成JAVA
    因为目前只用将对象转换成xml,故重写方法1.如下图,重写marshal方法,用反射将所有属性都生成节点,当属性值为空时,给个默认值null。
    这里写图片描述

    这里写图片描述

    如果只对指定类使用该转换器方法,需要重写canConvert方法,并进行相应判断,为true时则执行上图方法
    这里写图片描述

    如需要指定类使用该转换器,需要类上注明,如下图
    这里写图片描述

    4.Xstream是一种生成XML结构体的框架,意思就是生成不带头部文件的XML,这是一个问题,目前没有好的解决方式,因项目较赶,故采取拼接的方式加上头部文件,如下图即可将对象实例在指定位置生成对应的XML文件
    这里写图片描述

    初次写技术文章,如有不足之处,欢迎指出,感谢!

    展开全文
  • JAXB工具类 xml转为java对象 java对象转为xml ,本人亲测,可以使用!!!
  • NULL 博文链接:https://zw7534313.iteye.com/blog/2422138
  • 对象转xml并替换包名为xml自定义标签 1、依赖 &amp;lt;!--对象转xml--&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;com.thoughtworks.xstream&amp;lt;/groupId&...

    前言

    对象转xml并替换包名为xml自定义标签

    1、将对象转化为xml

    1.1、依赖

    <!--对象转xml-->
    <dependency>
        <groupId>com.thoughtworks.xstream</groupId>
        <artifactId>xstream</artifactId>
        <version>1.4.9</version>
    </dependency>
    
    

    1.2、工具类开始转化

    如果不写xstream.alias,如果遇到有些对象,则xml中某些标签后根据包名显示,比如下面的NesArticle,它存在于其他标签内部。这样就不会得到正确的结果

    
    /**
     * 文本消息转化为xml
     *
     * @param object
     * @return
     */
    public static String textMessageToXml(Object object) {
        XStream xstream = new XStream(new DomDriver("utf-8"));
        //默认是包名加类名为标签,这里改为xml为标签
        xstream.alias("xml", object.getClass());
        //默认是包名加类名为标签,这里改为item为标签
        xstream.alias("item", new NewsArticle().getClass());
        //这里遇到了一点点挫折,原来官网文档错了
        xstream.alias("Image", new Image().getClass());
    
        return xstream.toXML(object);
    
    }
    
    

    2、将xml转化为map

    正常情况下,当微信公众好收到用户的消息的是,会按照request给我们的服务端进行返回,这个reque(HttpServletRequtst)其实也就是一个xml内容,现在我们为了将来使用我们需要制作它成为一个map类型

    
    /**
     * 将xml转化为Map集合
     *
     * @param request
     * @return
     */
    public static Map<String, String> xmlToMap(HttpServletRequest request) {
        Map<String, String> map = new HashMap<String, String>();
        SAXReader reader = new SAXReader();
        InputStream ins = null;
        try {
            ins = request.getInputStream();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        Document doc = null;
        try {
            doc = reader.read(ins);
        } catch (DocumentException e1) {
            e1.printStackTrace();
        }
        Element root = doc.getRootElement();
        @SuppressWarnings("unchecked")
        List<Element> list = root.elements();
        for (Element e : list) {
            map.put(e.getName(), e.getText());
        }
        try {
            ins.close();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        return map;
    }
    
    

    ContactAuthor

    展开全文
  • php将对象转成数组,php将xml转成数组 一个自定义函数搞定纯原创。
  • NULL 博文链接:https://675990021.iteye.com/blog/2276670
  • XML 元素中,"和 "&" 是非法的。"会产生错误,因为解析器会把该字符解释为新元素的开始。"&" 也会产生错误,因为解析器会把该字符解释为字符实体的开始。CDATA:在标记CDATA下,所有的标记、实体引用都被忽略,而被XML...
  • xStream.alias("xml",textMessage.getClass()); return xStream.toXML(textMessage); } 调用时报错 public static void main(String args[]){ TextMessage s=new TextMessage(); s....
  • 使用java jdk的JAXB技术实现xml与java对象互相转化代码教程: JDK中JAXB相关的重要Class和Interface:(来源于百度百科JAXB) •JAXBContext类,是应用的入口,用于管理XML/Java绑定信息。 •Marshaller接口,将Java...
  • json转xml插件工具

    2018-06-01 09:43:44
    - JQuery - jquery.json2xml.js - jquery.xml2json.js 2. XML 字符串转换成 JSON 对象 $.xml2json(str); 3. JSON 对象转换成 XML 字符串 $.json2xml(obj);
  • android XMl 解析神奇xstream 三: 把复杂对象转换成 xml
  • XML报文JAVA对象-JAVA对象转XML报文

    千次阅读 2016-08-08 14:03:02
    public class XmlToObject { @Test public void XMLTobean() { Person p = new Person(1, "小红", "10", "北京"); ObjectDemo ob = new ObjectDemo("小明", "11", p); try { JAXBContext context = ...
  • Java把一个对象转换成xml数据

    千次阅读 2019-08-23 15:13:43
    使用jdk自带注解 在一个实体类上添加注解 @XmlRootElement(name="AppAccountList") public class AppAccountListVO { private List... // 生成XML字符串 System.out.println(xmlObj); } } 结果
  • 使用方法2.1 xml报文示例2.2 对象xml标签的添加2.3 xml转对象的示例2.4 对象转xml的示例 1. xml工具类代码   先贴上工具类代码。如下: package znxd.lxynzl.bank.base; import javax.xml.bind.JAXBContext; ...
  • NULL 博文链接:https://yangyongbyjava.iteye.com/blog/2068636
  • C#将实体对象转换成XML

    千次阅读 2020-07-22 12:18:08
    C# 将实体对象转换成XML将实体对象转换成XML 将实体对象转换成XML using System; using System.IO; using System.Xml.Serialization; namespace YG._CommonFunctions { /// <summary> /// 将实体对象转换成...
  • java对象转换为xml格式字符串

    千次阅读 2017-06-13 22:35:49
    它提供了管理实现 JAXB 绑定框架操作所需的 XML/Java 绑定信息的抽象,这些操作包括:解组、编组和验证。 1.编写工具类 /** * Jaxb工具类 * * @author LittleNewbie * @date 2016年10月11日 */ public ...
  • Java对象XML相互转换

    万次阅读 多人点赞 2018-08-19 13:33:40
    最近在项目中一直出现Java对象XML之间的相互转换,一开始由于项目很庞大,我又是临时调度过去,导致在按照项目组长的要求进行写代码的同时,总是在这块云里雾里,最近才慢慢开始搞清楚项目中具体的使用缘由。...
  • 运用泛型实现复杂对象XML 的互

    千次阅读 2018-06-04 23:34:05
    在之前的一篇文章中,我们使用常规方法实现看 Java...XML报文JAVA对象-JAVA对象转XML报文 介绍一下 JAXB-看红字即可 JAXB能够使用Jackson对JAXB注解的支持实现(jackson-module-jaxb-annotations),既方便...
  • C#对象Xml对象的相互转化

    热门讨论 2010-05-21 11:02:27
    C#对象Xml对象的相互转化 C#对象Xml对象的相互转化

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,374,187
精华内容 549,674
关键字:

对象转xml