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

简介: 在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月前
|
监控 Cloud Native Java
Quarkus 云原生Java框架技术详解与实践指南
本文档全面介绍 Quarkus 框架的核心概念、架构特性和实践应用。作为新一代的云原生 Java 框架,Quarkus 旨在为 OpenJDK HotSpot 和 GraalVM 量身定制,显著提升 Java 在容器化环境中的运行效率。本文将深入探讨其响应式编程模型、原生编译能力、扩展机制以及与微服务架构的深度集成,帮助开发者构建高效、轻量的云原生应用。
617 44
|
5月前
|
安全 Java API
Java Web 在线商城项目最新技术实操指南帮助开发者高效完成商城项目开发
本项目基于Spring Boot 3.2与Vue 3构建现代化在线商城,涵盖技术选型、核心功能实现、安全控制与容器化部署,助开发者掌握最新Java Web全栈开发实践。
557 1
|
6月前
|
安全 Java 编译器
new出来的对象,不一定在堆上?聊聊Java虚拟机的优化技术:逃逸分析
逃逸分析是一种静态程序分析技术,用于判断对象的可见性与生命周期。它帮助即时编译器优化内存使用、降低同步开销。根据对象是否逃逸出方法或线程,分析结果分为未逃逸、方法逃逸和线程逃逸三种。基于分析结果,编译器可进行同步锁消除、标量替换和栈上分配等优化,从而提升程序性能。尽管逃逸分析计算复杂度较高,但其在热点代码中的应用为Java虚拟机带来了显著的优化效果。
201 4
|
6月前
|
Java API Maven
2025 Java 零基础到实战最新技术实操全攻略与学习指南
本教程涵盖Java从零基础到实战的全流程,基于2025年最新技术栈,包括JDK 21、IntelliJ IDEA 2025.1、Spring Boot 3.x、Maven 4及Docker容器化部署,帮助开发者快速掌握现代Java开发技能。
1224 1
|
7月前
|
人工智能 Java
Java多任务编排技术
JDK 5引入Future接口实现异步任务处理,但获取结果不够灵活。Java 8新增CompletableFuture,实现异步任务编排,支持流式处理、多任务组合及异常处理,提升执行效率与代码可读性,简化并发编程复杂度。
165 0
|
6月前
|
Java 测试技术 API
2025 年 Java 开发者必知的最新技术实操指南全览
本指南涵盖Java 21+核心实操,详解虚拟线程、Spring Boot 3.3+GraalVM、Jakarta EE 10+MicroProfile 6微服务开发,并提供现代Java开发最佳实践,助力开发者高效构建高性能应用。
941 4
|
5月前
|
安全 Cloud Native Java
Java 模块化系统(JPMS)技术详解与实践指南
本文档全面介绍 Java 平台模块系统(JPMS)的核心概念、架构设计和实践应用。作为 Java 9 引入的最重要特性之一,JPMS 为 Java 应用程序提供了强大的模块化支持,解决了长期存在的 JAR 地狱问题,并改善了应用的安全性和可维护性。本文将深入探讨模块声明、模块路径、访问控制、服务绑定等核心机制,帮助开发者构建更加健壮和可维护的 Java 应用。
404 0
|
6月前
|
JavaScript 安全 前端开发
Java开发:最新技术驱动的病人挂号系统实操指南与全流程操作技巧汇总
本文介绍基于Spring Boot 3.x、Vue 3等最新技术构建现代化病人挂号系统,涵盖技术选型、核心功能实现与部署方案,助力开发者快速搭建高效、安全的医疗挂号平台。
333 3
|
7月前
|
存储 Java Linux
操作系统层面视角下 Java IO 的演进路径及核心技术变革解析
本文从操作系统层面深入解析Java IO的演进历程,涵盖BIO、NIO、多路复用器及Netty等核心技术。分析各阶段IO模型的原理、优缺点及系统调用机制,探讨Java如何通过底层优化提升并发性能与数据处理效率,全面呈现IO技术的变革路径与发展趋势。
160 2
|
7月前
|
安全 Java 微服务
Java 最新技术和框架实操:涵盖 JDK 21 新特性与 Spring Security 6.x 安全框架搭建
本文系统整理了Java最新技术与主流框架实操内容,涵盖Java 17+新特性(如模式匹配、文本块、记录类)、Spring Boot 3微服务开发、响应式编程(WebFlux)、容器化部署(Docker+K8s)、测试与CI/CD实践,附完整代码示例和学习资源推荐,助你构建现代Java全栈开发能力。
800 1