Java中Xml和实体互转

心已赠人 2024-03-23 15:41 124阅读 0赞

文章目录

  • Java中Xml和实体互转
      1. 工具类 JaxbUtil
      1. 实体转Xml演示
      • 2-1 实体类，Main方法中，含实体和Xml互转的测试代码
      • 2-2 生成的Xml结果
      1. [Java中操作Xml，可参考我写的另一篇博客【更完整、使用推荐】](https://blog.csdn.net/qq\_17847881/article/details/130855130)

Java中Xml和实体互转

1. 工具类 JaxbUtil

  1. import java.io.StringReader;
  2. import java.io.StringWriter;
  3. import java.util.Collection;
  4. import java.util.concurrent.ConcurrentHashMap;
  5. import java.util.concurrent.ConcurrentMap;
  7. import javax.xml.bind.JAXBContext;
  8. import javax.xml.bind.JAXBElement;
  9. import javax.xml.bind.JAXBException;
  10. import javax.xml.bind.Marshaller;
  11. import javax.xml.bind.Unmarshaller;
  12. import javax.xml.bind.annotation.XmlAnyElement;
  13. import javax.xml.namespace.QName;
  15. import org.apache.commons.lang3.StringUtils;
  16. import org.apache.commons.lang3.Validate;
  17. import sun.awt.geom.AreaOp;
  19. public class JaxbUtil {
  22.     @SuppressWarnings("rawtypes")
  23.     private static ConcurrentMap<Class, JAXBContext> jaxbContexts = new ConcurrentHashMap<Class, JAXBContext>();
  25.     /**
  26.      * Java Object->Xml without encoding.
  27.      */
  28.     @SuppressWarnings("rawtypes")
  29.     public static String toXml(Object root) {
  31.         Class clazz = root.getClass();
  32.         return toXml(root, clazz, null);
  33.     }
  35.     /**
  36.      * Java Object->Xml with encoding.
  37.      */
  38.     @SuppressWarnings("rawtypes")
  39.     public static String toXml(Object root, String encoding) {
  41.         Class clazz = root.getClass();
  42.         return toXml(root, clazz, encoding);
  43.     }
  45.     /**
  46.      * Java Object->Xml with encoding.
  47.      */
  48.     @SuppressWarnings("rawtypes")
  49.     public static String toXml(Object root, Class clazz, String encoding) {
  51.         try {
  53.             StringWriter writer = new StringWriter();
  54.             createMarshaller(clazz, encoding).marshal(root, writer);
  55.             return writer.toString();
  56.         } catch (JAXBException e) {
  58.             e.printStackTrace();
  59.         }
  60.         return null;
  61.     }
  63.     /**
  64.      * Java Collection->Xml without encoding, 特别支持Root Element是Collection的情形.
  65.      */
  66.     @SuppressWarnings("rawtypes")
  67.     public static String toXml(Collection<?> root, String rootName, Class clazz) {
  69.         return toXml(root, rootName, clazz, null);
  70.     }
  72.     /**
  73.      * Java Collection->Xml with encoding, 特别支持Root Element是Collection的情形.
  74.      */
  75.     @SuppressWarnings("rawtypes")
  76.     public static String toXml(Collection<?> root, String rootName, Class clazz, String encoding) {
  78.         try {
  80.             CollectionWrapper wrapper = new CollectionWrapper();
  81.             wrapper.collection = root;
  83.             JAXBElement<CollectionWrapper> wrapperElement = new JAXBElement<CollectionWrapper>(new QName(rootName),
  84.                     CollectionWrapper.class, wrapper);
  86.             StringWriter writer = new StringWriter();
  87.             createMarshaller(clazz, encoding).marshal(wrapperElement, writer);
  89.             return writer.toString();
  90.         } catch (JAXBException e) {
  92.             e.printStackTrace();
  93.         }
  94.         return null;
  95.     }
  97.     /**
  98.      * Xml->Java Object.
  99.      */
  100.     @SuppressWarnings("unchecked")
  101.     public static <T> T fromXml(String xml, Class<T> clazz) {
  103.         try {
  105.             StringReader reader = new StringReader(xml);
  106.             return (T) createUnmarshaller(clazz).unmarshal(reader);
  107.         } catch (JAXBException e) {
  109.             e.printStackTrace();
  110.         }
  111.         return null;
  112.     }
  114.     /**
  115.      * 创建Marshaller并设定encoding(可为null).
  116.      * 线程不安全，需要每次创建或pooling。
  117.      */
  118.     @SuppressWarnings("rawtypes")
  119.     public static Marshaller createMarshaller(Class clazz, String encoding) {
  121.         try {
  123.             JAXBContext jaxbContext = getJaxbContext(clazz);
  125.             Marshaller marshaller = jaxbContext.createMarshaller();
  127.             marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
  129.             if (StringUtils.isNotBlank(encoding)) {
  131.                 marshaller.setProperty(Marshaller.JAXB_ENCODING, encoding);
  132.             }
  133.             return marshaller;
  134.         } catch (JAXBException e) {
  136.             e.printStackTrace();
  137.         }
  138.         return null;
  139.     }
  141.     /**
  142.      * 创建UnMarshaller.
  143.      * 线程不安全，需要每次创建或pooling。
  144.      */
  145.     @SuppressWarnings("rawtypes")
  146.     public static Unmarshaller createUnmarshaller(Class clazz) {
  148.         try {
  150.             JAXBContext jaxbContext = getJaxbContext(clazz);
  151.             return jaxbContext.createUnmarshaller();
  152.         } catch (JAXBException e) {
  154.             e.printStackTrace();
  155.         }
  156.         return null;
  157.     }
  159.     @SuppressWarnings("rawtypes")
  160.     protected static JAXBContext getJaxbContext(Class clazz) {
  162.         Validate.notNull(clazz, "'clazz' must not be null");
  163.         JAXBContext jaxbContext = jaxbContexts.get(clazz);
  164.         if (jaxbContext == null) {
  166.             try {
  168.                 jaxbContext = JAXBContext.newInstance(clazz, CollectionWrapper.class);
  169.                 jaxbContexts.putIfAbsent(clazz, jaxbContext);
  170.             } catch (JAXBException ex) {
  172.                 throw new RuntimeException("Could not instantiate JAXBContext for class [" + clazz + "]: "
  173.                         + ex.getMessage(), ex);
  174.             }
  175.         }
  176.         return jaxbContext;
  177.     }
  179.     /**
  180.      * 封装Root Element 是 Collection的情况.
  181.      */
  182.     public static class CollectionWrapper {
  185.         @XmlAnyElement
  186.         protected Collection<?> collection;
  187.     }
  188. }

2. 实体转Xml演示

2-1 实体类，Main方法中，含实体和Xml互转的测试代码

  1. package com.ruoyi.system.controller;
  4. import com.alibaba.fastjson.JSON;
  6. import java.io.Serializable;
  7. import java.util.ArrayList;
  8. import java.util.List;
  10. import javax.xml.bind.annotation.XmlAccessType;
  11. import javax.xml.bind.annotation.XmlAccessorType;
  12. import javax.xml.bind.annotation.XmlElement;
  13. import javax.xml.bind.annotation.XmlRootElement;
  14. import javax.xml.bind.annotation.XmlTransient;
  17. //设置生成的xml的根节点的名称
  18. @XmlRootElement(name="sendHospitalInfo")
  19. //设置根据字段还是方法生成
  20. @XmlAccessorType(XmlAccessType.FIELD)
  21. public class Hospital implements Serializable {
  23.     //xml节点的名称
  24.     @XmlElement(name="hospitalId")
  25.     private String hospitalid;
  27.     //忽略此属性
  28.     @XmlTransient
  29.     private long id;
  31.     @XmlElement(name="hospitalName")
  32.     private String hospitalname;
  34.     public String getHospitalid() {
  36.         return hospitalid;
  37.     }
  39.     public void setHospitalid(String hospitalid) {
  41.         this.hospitalid = hospitalid;
  42.     }
  44.     public long getId() {
  46.         return id;
  47.     }
  49.     public void setId(long id) {
  51.         this.id = id;
  52.     }
  54.     public String getHospitalname() {
  56.         return hospitalname;
  57.     }
  59.     public void setHospitalname(String hospitalname) {
  61.         this.hospitalname = hospitalname;
  62.     }
  64.     public static void main(String[] args) {
  66.         Hospital sydw = new Hospital();
  67.         sydw.setHospitalid("001");
  68.         sydw.setHospitalname("hospital_name");
  71.         Hospital sydw2 = new Hospital();
  72.         sydw2.setHospitalid("002");
  73.         sydw2.setHospitalname("hospital_name");
  75.         List<Hospital> lists = new ArrayList<>();
  76.         lists.add(sydw);
  77.         lists.add(sydw2);
  78.         Demo demo = new Demo();
  79.         demo.setHospitals(lists);
  80.         // 实体转xml
  81.         System.out.println(JaxbUtil.toXml(demo));
  82.         System.out.println(JaxbUtil.toXml(sydw));
  84.         // xml 转实体
  85.         Demo demo1 = new Demo();
  86.         demo1=JaxbUtil.fromXml(JaxbUtil.toXml(demo),Demo.class);
  87.         System.out.println(JSON.toJSONString(demo1));
  88.     }
  89. }
  91. @XmlRootElement(name="sendHospitalInfoList")
  92. //设置根据字段还是方法生成
  93. @XmlAccessorType(XmlAccessType.FIELD)
  94. class Demo{
  96.     private List<Hospital> hospitals;
  98.     public List<Hospital> getHospitals() {
  100.         return hospitals;
  101.     }
  103.     public void setHospitals(List<Hospital> hospitals) {
  105.         this.hospitals = hospitals;
  106.     }
  107. }

2-2 生成的Xml结果

  1. <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  2. <sendHospitalInfoList>
  3.     <hospitals>
  4.         <hospitalId>001</hospitalId>
  5.         <hospitalName>hospital_name</hospitalName>
  6.     </hospitals>
  7.     <hospitals>
  8.         <hospitalId>002</hospitalId>
  9.         <hospitalName>hospital_name</hospitalName>
  10.     </hospitals>
  11. </sendHospitalInfoList>
  13. <!-- 对应的Json
  14.     {"hospitals":[{"hospitalid":"001","hospitalname":"hospital_name","id":0},
  15.     {"hospitalid":"002","hospitalname":"hospital_name","id":0}]}
  16. -->

3. Java中操作Xml，可参考我写的另一篇博客【更完整、使用推荐】

发表评论

表情：
评论列表 （有 0 条评论，124人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java 中Xml与对象的互转

    在java开发中我们经常会遇到Xml与对象互相转换的情况，尤其是针对WebService访问时会涉及到xml与对象的转换问题。目前可以用于xml与对象互转的方式有很多这里采用j

    你的名字你的名字/ 0 赞/ 361 阅读