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

    在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(示例代码来自:http://www.cnblogs.com/longqingyang/p/5577937.html):

public class DOM4JTest {
    private static ArrayList<Book> bookList = new ArrayList<Book>();
    /**
     * @param args
     */
    public static void main(String[] args) {
        // 解析books.xml文件
        // 创建SAXReader的对象reader
        SAXReader reader = new SAXReader();
        try {
            // 通过reader对象的read方法加载books.xml文件,获取docuemnt对象。
            Document document = reader.read(new File("src/res/books.xml"));
            // 通过document对象获取根节点bookstore
            Element bookStore = document.getRootElement();
            // 通过element对象的elementIterator方法获取迭代器
            Iterator it = bookStore.elementIterator();
            // 遍历迭代器,获取根节点中的信息(书籍)
            while (it.hasNext()) {
                System.out.println("=====开始遍历某一本书=====");
                Element book = (Element) it.next();
                // 获取book的属性名以及 属性值
                List<Attribute> bookAttrs = book.attributes();
                for (Attribute attr : bookAttrs) {
                    System.out.println("属性名:" + attr.getName() + "--属性值:"
                            + attr.getValue());
                }
                Iterator itt = book.elementIterator();
                while (itt.hasNext()) {
                    Element bookChild = (Element) itt.next();
                    System.out.println("节点名:" + bookChild.getName() + "--节点值:" + bookChild.getStringValue());
                }
                System.out.println("=====结束遍历某一本书=====");
            }
        } catch (DocumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

DOM4J

XStream(XStream将xml转Map,实用方便):

public class PojoMapConverter implements Converter {
    public PojoMapConverter() {
        super();
    }

    public boolean canConvert(Class clazz) {
        String classname = clazz.getName();
        if (classname.indexOf("Map") >= 0
                || classname.indexOf("List") >= 0
                || classname.indexOf("Bean") >= 0)
            return true;
        else
            return false;
    }

    public void marshal(Object value, HierarchicalStreamWriter writer,
                        MarshallingContext context) {

        map2xml(value, writer, context);
    }

    protected void map2xml(Object value, HierarchicalStreamWriter writer,
                           MarshallingContext context) {
        boolean bMap = true;
        String classname = value.getClass().getName();

        bMap = (classname.indexOf("List") < 0);
        Map<String, Object> map;
        List<Object> list;
        String key;
        Object subvalue;
        if (bMap) {
            map = (Map<String, Object>) value;
            for (Iterator<Map.Entry<String, Object>> iterator = map.entrySet()
                    .iterator(); iterator.hasNext();) {
                Map.Entry<String, Object> entry = (Map.Entry<String, Object>) iterator
                        .next();
                key = (String) entry.getKey();
                subvalue = entry.getValue();
                writer.startNode(key);
                if (subvalue.getClass().getName().indexOf("String") >= 0) {
                    writer.setValue((String) subvalue);
                } else {
                    map2xml(subvalue, writer, context);
                }
                writer.endNode();
            }

        } else {
            list = (List<Object>) value;
            for (Object subval : list) {
                subvalue = subval;
                writer.startNode("child");
                if (subvalue.getClass().getName().indexOf("String") >= 0) {
                    writer.setValue((String) subvalue);
                } else {
                    map2xml(subvalue, writer, context);
                }
                writer.endNode();
            }
        }
    }

    public Map<String, Object> unmarshal(HierarchicalStreamReader reader,
                                         UnmarshallingContext context) {
        Map<String, Object> map = (Map<String, Object>) populateMap(reader,
                context);
        return map;
    }

    protected Object populateMap(HierarchicalStreamReader reader,
                                 UnmarshallingContext context) {
        boolean bMap = true;
        Map<String, Object> map = new HashMap<String, Object>();
        List<Object> list = new ArrayList<Object>();
        while (reader.hasMoreChildren()) {
            reader.moveDown();
            String key = reader.getNodeName();
            Object value = null;
            if (reader.hasMoreChildren()) {
                value = populateMap(reader, context);
            } else {
                value = reader.getValue();
            }
            if (bMap) {
                if (map.containsKey(key)) {
                    // convert to list
                    bMap = false;
                    Iterator<Map.Entry<String, Object>> iter = map.entrySet()
                            .iterator();
                    while (iter.hasNext())
                        list.add(iter.next().getValue());
                    // insert into list
                    list.add(value);
                } else {
                    // insert into map
                    map.put(key, value);
                }
            } else {
                // insert into list
                list.add(value);
            }
            reader.moveUp();
        }
        if (bMap)
            return map;
        else
            return list;
    }
}
 public static void main(String[] args) {
        
        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> ";
        
        XStream xstream = new XStream(new DomDriver());
        xstream.registerConverter(new PojoMapConverter());
        Map<String, Object> map = (Map<String, Object>)xstream.fromXML(xml);
        System.out.println(map);
        xml = xstream.toXML(map);
        System.out.println(xml);
        System.out.println((Map<String, Object>)xstream.fromXML(xml));
}

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


本文代码及内容参考:

https://blog.csdn.net/thunder09/article/details/5555946

http://www.cnblogs.com/longqingyang/p/5577937.html

http://guobin6125.iteye.com/blog/1535612


   

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值