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

本文涉及的产品
全局流量管理 GTM,标准版 1个月
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
云解析 DNS,旗舰版 1个月
简介: 在java的世界里,xml这块领域被两种黑暗势力所统治:XML API 和 OXMapping(Object-XML Mapping)。

在java的世界里,xml这块领域被两种黑暗势力所统治:XML API 和 OXMapping(Object-XML Mapping)。


XML API 下有:


1、DOM解析;

2、SAX解析;

3、JDOM解析;

4、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:


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,实用方便):


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的解析及使用技术就差不多足够了。


相关文章
|
5天前
|
XML 数据采集 存储
使用Java和XPath在XML文档中精准定位数据
在数据驱动的时代,从复杂结构中精确提取信息至关重要。XML被广泛用于数据存储与传输,而XPath则能高效地在这些文档中导航和提取数据。本文深入探讨如何使用Java和XPath精准定位XML文档中的数据,并通过小红书的实际案例进行分析。首先介绍了XML及其挑战,接着阐述了XPath的优势。然后,提出从大型XML文档中自动提取特定产品信息的需求,并通过代理IP技术、设置Cookie和User-Agent以及多线程技术来解决实际网络环境下的数据抓取问题。最后,提供了一个Java示例代码,演示如何集成这些技术以高效地从XML源中抓取数据。
使用Java和XPath在XML文档中精准定位数据
|
4天前
|
算法 Java 程序员
在Java的编程世界里,多态不仅仅是一种代码层面的技术,它是思想的碰撞,是程序员对现实世界复杂性的抽象映射,是对软件设计哲学的深刻领悟。
在Java的编程世界里,多态不仅仅是一种代码层面的技术,它是思想的碰撞,是程序员对现实世界复杂性的抽象映射,是对软件设计哲学的深刻领悟。
25 9
|
8天前
|
Java 关系型数据库 MySQL
"解锁Java Web传奇之旅:从JDK1.8到Tomcat,再到MariaDB,一场跨越数据库的冒险安装盛宴,挑战你的技术极限!"
【8月更文挑战第19天】在Linux上搭建Java Web应用环境,需安装JDK 1.8、Tomcat及MariaDB。本指南详述了使用apt-get安装OpenJDK 1.8的方法,并验证其版本。接着下载与解压Tomcat至`/usr/local/`目录,并启动服务。最后,通过apt-get安装MariaDB,设置基本安全配置。完成这些步骤后,即可验证各组件的状态,为部署Java Web应用打下基础。
23 1
|
1天前
|
Java 程序员 数据库连接
Java中的异常处理:从基础到高级云计算与网络安全:技术融合的双刃剑
【8月更文挑战第26天】在Java编程的世界中,异常处理是一块基石,它确保了程序的健壮性和稳定性。本文将带你从异常处理的基本概念出发,逐步深入到高级应用,包括自定义异常和最佳实践。你将学会如何优雅地处理程序中可能遇到的各种问题,以及如何设计异常处理策略来提升代码质量和维护性。
|
2天前
|
XML JavaScript Java
【JAVA XML 探秘】DOM、SAX、StAX:揭秘 Java 中 XML 解析技术的终极指南!
【8月更文挑战第25天】本文详细探讨了Java中三种主流的XML解析技术:DOM、SAX与StAX。DOM将XML文档转换为树状结构,便于全方位访问和修改;SAX采取事件驱动模式,适用于大型文件的顺序处理;StAX则兼具DOM和SAX的优点,支持流式处理和随机访问。文中提供了每种技术的示例代码,帮助读者理解如何在实际项目中应用这些解析方法。
19 1
|
4天前
|
XML 存储 JavaScript
在 Java 中如何将 ArrayList 转换为 XML
【8月更文挑战第23天】
11 3
|
12天前
|
Java
Java BasePooledObjectFactory 对象池化技术
Java BasePooledObjectFactory 对象池化技术
14 1
|
22天前
|
安全 Java
Java RMI技术详解与案例分析
在实际的银行系统中,当然还需要考虑安全性、事务性、持久性以及错误处理等多方面的因素,RMI的网络通信也需要在安全的网络环境下进行,以防止数据泄露或被篡改。你在应用中是怎么使用 RMI 的,欢迎关注威哥爱编程,一起交流一下哈。
135 4
|
28天前
|
存储 Java 索引
Java ArrayList操作指南:如何移除并返回第一个元素
通过上述方法,你可以方便地从Java的 `ArrayList` 中移除并返回第一个元素。这种操作在日常编程中非常常见,是处理列表时的基本技能之一。希望这篇指南能帮助你更好地理解和运用Java的 `ArrayList`。
26 4
|
5天前
|
XML 自然语言处理 Java
Java 中的 XML 数据绑定
【8月更文挑战第22天】
12 0