java 操作 xml 看了这一篇再去选择具体技术

fenghuashao

于 2022-10-13 10:47:29 发布

阅读量351

点赞数

分类专栏： java 文章标签： java xml 前端

原文链接：https://developer.aliyun.com/article/937810?accounttraceid=4d4375473c814d7b888464d68007c857keyx

版权

java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

java 操作 xml 看了这一篇再去选择具体技术

简介： 在java的世界里，xml这块领域被两种黑暗势力所统治：XML API 和 OXMapping（Object-XML Mapping）。

在java的世界里，xml这块领域被两种黑暗势力所统治：XML API 和 OXMapping（Object-XML Mapping）。

XML API 下有

DOM解析；
SAX解析；
JDOM解析；
DOM4J解析四大魔王；

而OXMapping下则有XStream 、 Digester 、 Castor 等众多猛将。

我们先来看看XML API 这股黑暗势力：

作为XML处理的元老，秉承工匠精神，XML API 通过对xml的底层的操作，让我们能够很好的解析xml文件。其中DOM解析与SAX解析属于基础方法，是官方提供的平台无关的解析方式，使用之广自不必说。而JDOM解析和DOM4J解析则是两个元老的入门弟子，针对java语言专门做了一定的语言特性处理与扩展，使得在java中使用此二人处理xml变得游刃有余。

介绍了XML API 家族势力，我们再来看看OXMapping这股黑暗势力：

作为xml解析领域的后起之秀，OXMapping如今也是混的风生水起，其创作者们秉承了ORMapping的思想，我们可以将 XML 文件映射成一个 JavaBean 对象，也可以把一个 JavaBean 对象保存成一个 XML 文件，这大大简化了我们的开发工作量，使得开发人员能更多的关注应用层面的东西。开源世界中涌现出很多 OXMapping 框架，包括 XStream 、 Digester 、 Castor 等。

他们的思想也都是类似ORMapping的思想。但是，正所谓姜还是老的辣，OXMapping 内部实现还是使用 XML API 来完成。

两股势力在xml领域都混的风生水起，可是面对众多的能人上将，选择哪个去处理我们的xml呢？不多bb,直接给出答案，在我们java届，好用且用的最多的XML API 中当属DOM4J,而OXMapping中，则当属XStream。

DOM4J优势如下：

1、JDOM的一种智能分支，它合并了许多超出基本XML文档表示的功能。
2、它使用接口和抽象基本类方法。
3、具有性能优异、灵活性好、功能强大和极端易用的特点。
4、是一个开放源码的文件。
5、采用了Java集合框架并完全支持DOM，SAX和JAXP。

DOM4J使用起来非常简单。只要你了解基本的XML-DOM模型，就能使用。DOM4J性能最好，连Sun的JAXM也在用DOM4J。目前许多开源项目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性，那就采用DOM4J。

XStream优势如下：

与 Digester 比起来， XStream 的主要优点就是更加小巧，使用也更加方便，不过目前使用 Digester 是“开源名牌” Apache 下的子项目，但是用起来略显繁琐，而 XStream 比较简洁，所以XStream 还是比较受欢迎。而 Castor 则需要写一个和 Hibernate 中 cfg.xml 类似的映射配置文件，使用上就更显繁琐啦。

所以，综上所述，我们了解和学习DOM4J和XStream就可以了。

那么我们下面就通过一些简单的例子来了解DOM4J和XStream吧（具体或更深入的学习和使用就不再这里说啦，说也说不完，毕竟人家可是一个领域的巨头啊，我一两句话说能说清楚，那不是伪巨了不是）：

Dom4J:


```java
1public class DOM4JTest {
 2    private static ArrayList<Book> bookList = new ArrayList<Book>();
 3    /**
 4     * @param args
 5     */
 6    public static void main(String[] args) {
 7        // 解析books.xml文件
 8        // 创建SAXReader的对象reader
 9        SAXReader reader = new SAXReader();
10        try {
11            // 通过reader对象的read方法加载books.xml文件,获取docuemnt对象。
12            Document document = reader.read(new File("src/res/books.xml"));
13            // 通过document对象获取根节点bookstore
14            Element bookStore = document.getRootElement();
15            // 通过element对象的elementIterator方法获取迭代器
16            Iterator it = bookStore.elementIterator();
17            // 遍历迭代器，获取根节点中的信息（书籍）
18            while (it.hasNext()) {
19                System.out.println("=====开始遍历某一本书=====");
20                Element book = (Element) it.next();
21                // 获取book的属性名以及 属性值
22                List<Attribute> bookAttrs = book.attributes();
23                for (Attribute attr : bookAttrs) {
24                    System.out.println("属性名：" + attr.getName() + "--属性值："
25                            + attr.getValue());
26                }
27                Iterator itt = book.elementIterator();
28                while (itt.hasNext()) {
29                    Element bookChild = (Element) itt.next();
30                    System.out.println("节点名：" + bookChild.getName() + "--节点值：" + bookChild.getStringValue());
31                }
32                System.out.println("=====结束遍历某一本书=====");
33            }
34        } catch (DocumentException e) {
35            // TODO Auto-generated catch block
36            e.printStackTrace();
37        }
38    }
39}


XStream（XStream将xml转Map,实用方便）：

```java
1public class PojoMapConverter implements Converter {
  2    public PojoMapConverter() {
  3        super();
  4    }
  5
  6    public boolean canConvert(Class clazz) {
  7        String classname = clazz.getName();
  8        if (classname.indexOf("Map") >= 0
  9                || classname.indexOf("List") >= 0
 10                || classname.indexOf("Bean") >= 0)
 11            return true;
 12        else
 13            return false;
 14    }
 15
 16    public void marshal(Object value, HierarchicalStreamWriter writer,
 17                        MarshallingContext context) {
 18
 19        map2xml(value, writer, context);
 20    }
 21
 22    protected void map2xml(Object value, HierarchicalStreamWriter writer,
 23                           MarshallingContext context) {
 24        boolean bMap = true;
 25        String classname = value.getClass().getName();
 26
 27        bMap = (classname.indexOf("List") < 0);
 28        Map<String, Object> map;
 29        List<Object> list;
 30        String key;
 31        Object subvalue;
 32        if (bMap) {
 33            map = (Map<String, Object>) value;
 34            for (Iterator<Map.Entry<String, Object>> iterator = map.entrySet()
 35                    .iterator(); iterator.hasNext();) {
 36                Map.Entry<String, Object> entry = (Map.Entry<String, Object>) iterator
 37                        .next();
 38                key = (String) entry.getKey();
 39                subvalue = entry.getValue();
 40                writer.startNode(key);
 41                if (subvalue.getClass().getName().indexOf("String") >= 0) {
 42                    writer.setValue((String) subvalue);
 43                } else {
 44                    map2xml(subvalue, writer, context);
 45                }
 46                writer.endNode();
 47            }
 48
 49        } else {
 50            list = (List<Object>) value;
 51            for (Object subval : list) {
 52                subvalue = subval;
 53                writer.startNode("child");
 54                if (subvalue.getClass().getName().indexOf("String") >= 0) {
 55                    writer.setValue((String) subvalue);
 56                } else {
 57                    map2xml(subvalue, writer, context);
 58                }
 59                writer.endNode();
 60            }
 61        }
 62    }
 63
 64    public Map<String, Object> unmarshal(HierarchicalStreamReader reader,
 65                                         UnmarshallingContext context) {
 66        Map<String, Object> map = (Map<String, Object>) populateMap(reader,
 67                context);
 68        return map;
 69    }
 70
 71    protected Object populateMap(HierarchicalStreamReader reader,
 72                                 UnmarshallingContext context) {
 73        boolean bMap = true;
 74        Map<String, Object> map = new HashMap<String, Object>();
 75        List<Object> list = new ArrayList<Object>();
 76        while (reader.hasMoreChildren()) {
 77            reader.moveDown();
 78            String key = reader.getNodeName();
 79            Object value = null;
 80            if (reader.hasMoreChildren()) {
 81                value = populateMap(reader, context);
 82            } else {
 83                value = reader.getValue();
 84            }
 85            if (bMap) {
 86                if (map.containsKey(key)) {
 87                    // convert to list
 88                    bMap = false;
 89                    Iterator<Map.Entry<String, Object>> iter = map.entrySet()
 90                            .iterator();
 91                    while (iter.hasNext())
 92                        list.add(iter.next().getValue());
 93                    // insert into list
 94                    list.add(value);
 95                } else {
 96                    // insert into map
 97                    map.put(key, value);
 98                }
 99            } else {
100                // insert into list
101                list.add(value);
102            }
103            reader.moveUp();
104        }
105        if (bMap)
106            return map;
107        else
108            return list;
109    }
110}
111
112 public static void main(String[] args) {
113
114        String xml = "<map><stars><star><id>1</id><name>littleflower</name></star><star><id>2</id><name>littleyellow</name></star></stars>   <filename>cnlab</filename>   <ra>147.0</ra>   <dec>0.0</dec>   <plate>0.0</plate>   <mdj>0.0</mdj> </map> ";
115
116        XStream xstream = new XStream(new DomDriver());
117        xstream.registerConverter(new PojoMapConverter());
118        Map<String, Object> map = (Map<String, Object>)xstream.fromXML(xml);
119        System.out.println(map);
120        xml = xstream.toXML(map);
121        System.out.println(xml);
122        System.out.println((Map<String, Object>)xstream.fromXML(xml));
123}

好啦，对于菜鸟来说，了解这些应该对于xml的解析及使用技术就差不多足够了

fenghuashao

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java 操作 xml 看了这一篇再去选择具体技术

作为xml解析领域的后起之秀，OXMapping如今也是混的风生水起，其创作者们秉承了ORMapping的思想，我们可以将 XML 文件映射成一个 JavaBean 对象，也可以把一个 JavaBean 对象保存成一个 XML 文件，这大大简化了我们的开发工作量，使得开发人员能更多的关注应用层面的东西。作为XML处理的元老，秉承工匠精神，XML API 通过对xml的底层的操作，让我们能够很好的解析xml文件。两股势力在xml领域都混的风生水起，可是面对众多的能人上将，选择哪个去处理我们的xml呢？
复制链接

扫一扫