xml/map转换器

　　xml合并: xml合并

　　snagit图片:http://pan.baidu.com/s/1nuKJD13

　　git样例: https://gitee.com/KingBoBo/XmlMapBeanTool/tree/master/XmlMapBeanTool

应用场景,为什么要把xml转map?我直接用jdom,dom4j操作不行吗?

如果你了解模板引擎(像velocity,mvel,httl等),会发现map形式在模板中取数可以如下所示直接取值,而xml字符串或dom则没有这样取值的便利和易理解特性.

<爸爸的小狗毛色>PACKET.MASTER_LIST.MASTER[].DOG.COLOR</爸爸的小狗毛色>

　　以上语句中文翻译为取得PACKET报文中的第2个MASTER主人拥有的狗狗的毛色.

而map.get("key")取值的性能远胜于其它方式,针对报文中部分指定节点做类似于md5的重复性校验(查重)也非常合适.

比如我们在库中指定以下节点作为查重节点:

节点中文名	关键节点(查重节点)
地址	PACKET/FAMILY/ADDESS
主人名	PACKET/MASTER_LIST/MASTER/NAME

之后可以通过以下方式取值

map.get("PACKET").get("FAMILY").get("ADDRESS") ;

map.get("PACKET").get("MASTER_LIST").get("MASTER").get("NAME"); // 考虑到有list,在取到get("MASTER")时做instanceof LIST,之后遍历取出3个NAME

再把它们各自的value拼成 "绍兴兰亭MamaBabaSon", 最终后续来的报文也提取类似"杭州江干MamaBabaDaughter"进行历史比对,就能马上发现存在差异,至于有没有差异的后续处理得根据业务需要了. (为了更高的性能先用length,再用equals,该点很重要,属于性能优化点.)

设计思路

1. 有上下层次关系,必然递归最适合
2. 递归原则 : 一个map对应一个xml节点,key为当前xml节点名,value为当前xml节点子集
3.1 如果xml节点没有子节点(叶子节点),那么map的key为xml节点名,value为xml节点文本内容
3.2 如果xml节点有一个子节点,那么map的key为xml节点名,value为xml节点子集
3.3.1 如果xml节点有多个子节点,对应map的key不存在(每一次),map的key为xml节点名,value为xml节点子集
3.3.2 如果xml节点有多个子节点,对应map的key已存在,且value为map类型(第二次),map的key为xml节点名,值从map类型转为list,而list中添加2份当前xml节点子集
3.3.3 如果xml节点有多个子节点,对应map的key已存在,且value为list类型(第三/多次),那么直接加到list中去.

原始xml:

<?xml version="1.0" encoding="utf-8"?>

<PACKET>

    <FAMILY>

        <COLOR>red</COLOR>

        <ADDRESS>绍兴兰亭</ADDRESS>

    </FAMILY>

    <MASTER_LIST>

        <MASTER>

            <NAME>Mama</NAME>

            <CAT>

                <COLOR>yellow</COLOR>

            </CAT>

            <CAT>

                <COLOR>grey</COLOR>

            </CAT>

        </MASTER>

        <MASTER>

            <NAME>Baba</NAME>

            <DOG>

                <COLOR>black</COLOR>

            </DOG>

        </MASTER>

        <MASTER>

            <NAME>Son</NAME>

            <RABBIT>

                <COLOR>white</COLOR>

            </RABBIT>

        </MASTER>

    </MASTER_LIST>

</PACKET>

期望map:

{

    PACKET={

        FAMILY={

            ADDRESS=绍兴兰亭,

            COLOR=red

        },

        MASTER_LIST={

            MASTER=[

                {

                    NAME=Mama,

                    CAT=[

                        {

                            COLOR=yellow

                        },

                        {

                            COLOR=grey

                        }

                    ]

                },

                {

                    NAME=Baba,

                    DOG={

                        COLOR=black

                    }

                },

                {

                    NAME=Son,

                    RABBIT={

                        COLOR=white

                    }

                }

            ]

        }

    }

}

图文思路解析

总map结构

叶子节点map结构

list层次结构第一次生成时

list层次结构第二次生成时

list层次结构第三/多次生成时

初版原码

先理解初版,最重要版本.

package test.king;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.DocumentHelper;

import org.dom4j.Element;

import test.king.tool.FileTool;

public class XmlMapTool {

    public static void main(String[] args) {

        String input = FileTool.readStringFromFile("d://input.txt", "gbk");

        Map<String, Object> map = xml2map(input);

        System.out.println("最终生成的map如下:\n"+map);

    }

    public static Map<String, Object> xml2map(String xml) {

        Document doc = null;

        try {

            doc = DocumentHelper.parseText(xml);

        } catch (DocumentException e) {

            e.printStackTrace();

        }

        Map<String, Object> map = new HashMap<String, Object>();

        if (doc == null)

            return map;

        Element rootElement = doc.getRootElement();

        element2map(rootElement,map);

        return map;

    }

    public static Map element2map (Element outele,Map outmap) {

        System.out.println("当前位于"+outele.getName()+"节点");

        List<Element> list = outele.elements();//必定返回0,1,2,3,....... 不会异常

        int size = list.size();

        if(size == 0){//当前节点是叶子节点

            outmap.put(outele.getName(), outele.getTextTrim());

        }else if(size == 1){

            Map<String, Object> innermap = new HashMap<String, Object>();

            Element ele1 = list.get(0);

            element2map(ele1,innermap);

            outmap.put(outele.getName(), innermap);

        }else if(size > 1){

            Map<String, Object> innermap = new HashMap<String, Object>();

            for(Element ele1 : list){

                String eleName = ele1.getName();

                Object obj =  innermap.get(eleName);//获取MASTER

                if(obj == null){//如果该MASTER不存在,现在有一个MASTER过来

                    element2map(ele1,innermap);

                }else{

                    if(obj instanceof java.util.Map){//如果没有生成过list,把原来的单个map合并到新的list

                        innermap.remove(eleName);

                        List<Map> list1 = new ArrayList<Map>();

                        list1.add((Map) obj);

                        Map<String, Object> map1 = new HashMap<String, Object>();

                        element2map(ele1,map1);

                        list1.add((Map) map1.get(eleName));

                        innermap.put(eleName, list1);

                    }else if(obj instanceof java.util.List){//如果已经生成过list

                        element2map(ele1,innermap);

                        ((List)obj).add(innermap);

                    }

                }

            }

            outmap.put(outele.getName(), innermap);

        }

        return outmap;

    }

}

优化后原码

最终发现else if( size == 1 ){...... }的功能在 else if( size >1 ) 中已完全包含,所以可以舍掉 (size == 1) 这个多余处理.

且这里没有使用Iterator<Element> eleItor = outele.elementIterator();用法,因为亲自经过10000次大报文自测发现还是size()判断更快.

size用法(推荐):

package test.king;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.DocumentHelper;

import org.dom4j.Element;

import test.king.tool.FileTool;

import test.king.tool.TLTimeContainer;

public class XmlMapToolIngenious {

    public static void main(String[] args) {

        String input = FileTool.readStringFromFile("d://input.txt", "gbk");

        Map<String, Object> map = null;

        TLTimeContainer.recordTime();

        for(int i = 0 ; i < 10000 ; i++){

            map = xml2map(input);

        }

        TLTimeContainer.recordTime();

        TLTimeContainer.print();

        System.out.println("最终生成的map如下:\n"+map);

    }

    public static Map<String, Object> xml2map(String xml) {

        Document doc = null;

        try {

            doc = DocumentHelper.parseText(xml);

        } catch (DocumentException e) {

            e.printStackTrace();

        }

        Map<String, Object> map = new HashMap<String, Object>();

        if (doc == null)

            return map;

        Element rootElement = doc.getRootElement();

        element2map(rootElement,map);

        return map;

    }

    public static Map element2map (Element outele,Map outmap) {

        List<Element> list = outele.elements();//必定返回0,1,2,3,....... 不会异常

        int size = list.size();

        if(size == 0){//当前节点是叶子节点(outele如果为叶子节点,是不可能有子节点的,因为它里面是纯文本)

            outmap.put(outele.getName(), outele.getTextTrim());

        }else{

            Map<String, Object> innermap = new HashMap<String, Object>();

            for(Element ele1 : list){

                String eleName = ele1.getName();

                Object obj =  innermap.get(eleName);//获取MASTER

                if(obj == null){//如果该MASTER不存在,现在有一个MASTER过来

                    element2map(ele1,innermap);

                }else{

                    if(obj instanceof java.util.Map){//如果没有生成过list,把原来的单个map合并到新的list

                        List<Map> list1 = new ArrayList<Map>();

                        list1.add((Map) innermap.remove(eleName));

                        element2map(ele1,innermap);

                        list1.add((Map) innermap.remove(eleName));

                        innermap.put(eleName, list1);

                    }else{//如果不是map,必然是list,只有这两种情况,所以不再else if 条件判断

                        element2map(ele1,innermap);

                        ((List)obj).add(innermap);

                    }

                }

            }

            outmap.put(outele.getName(), innermap);

        }

        return outmap;

    }

}

同事施明方法,比我的更优雅更简洁更高效(强烈推荐)

1. 有上下层次关系,必然递归最适合
2. 递归原则 : 一个map对应一个xml节点,key为当前xml节点名,value为当前xml节点子集
3. 如果xml节点没有子节点(叶子节点),那么map的key为xml节点名,value为xml节点内文本内容
4. 如果xml节点有子节点,那么让子节点和新生成子map去递归(子节点和新map会关联到一起)
5. 然后就要把子map或子list置入上一层map中
5.2如果子map第一次生成,用上层map直接添加子map
5.3如果子map第二次生成,用新list把两份子map添加,再用上一层map添加新list
5.4如果子map第三/多次,用list把第三/多次子map直接添加

public void element2map(Element elmt, Map<Object, Object> map) {

        if (null == elmt) {

            return;

        }

        String name = elmt.getName();

        if (elmt.isTextOnly()) {

            map.put(name, elmt.getText());

        } else {

            Map<Object, Object> mapSub = new HashMap<Object, Object>();

            List<Element> elements = (List<Element>) elmt.elements();

            for (Element elmtSub : elements) {

                element2map(elmtSub, mapSub);

            }

            Object first = map.get(name);

            if (null == first) {

                map.put(name, mapSub);

            } else {

                if (first instanceof List<?>) {

                    ((List) first).add(mapSub);

                } else {

                    List<Object> listSub = new ArrayList<Object>();

                    listSub.add(first);

                    listSub.add(mapSub);

                    map.put(name, listSub);

                }

            }

        }

    }

微整后

/**

     *

     * @param elmt 当前元素

     * @param map 主键为当前元素的节点名,值为当前元素的所有直接子元素

     */

    public static void element2map(Element elmt, Map<String, Object> map) {

        if (null == elmt) {

            return;

        }

        String name = elmt.getName();

        if (elmt.isTextOnly()) {

            map.put(name, elmt.getText());

        } else {

            Map<String, Object> mapSub = new HashMap<String, Object>();

            List<Element> elements = (List<Element>) elmt.elements();

            for (Element elmtSub : elements) {

                element2map(elmtSub, mapSub);

            }

            Object first = map.get(name);

            if (null == first) {

                map.put(name, mapSub);

            } else {

                if (first instanceof List<?>) {

                    ((List) first).add(mapSub);

                } else {

                    List<Object> listSub = new ArrayList<Object>();

                    listSub.add(first);

                    listSub.add(mapSub);

                    map.put(name, listSub);

                }

            }

        }

    }

iterator用法(不推荐):

因为在10000次循环时间对比中,还没有size()判断比iterator()快1秒左右. 起码在dom4j中是这样的情况.

package test.king;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.DocumentHelper;

import org.dom4j.Element;

import test.king.tool.FileTool;

import test.king.tool.TLTimeContainer;

public class XmlMapToolIngenious {

    public static void main(String[] args) {

        String input = FileTool.readStringFromFile("d://input.txt", "gbk");

        Map<String, Object> map = null;

        TLTimeContainer.recordTime();

        for(int i = 0 ; i < 10000 ; i++){

            map = xml2map(input);

        }

        TLTimeContainer.recordTime();

        TLTimeContainer.print();

        System.out.println("最终生成的map如下:\n"+map);

    }

    public static Map<String, Object> xml2map(String xml) {

        Document doc = null;

        try {

            doc = DocumentHelper.parseText(xml);

        } catch (DocumentException e) {

            e.printStackTrace();

        }

        Map<String, Object> map = new HashMap<String, Object>();

        if (doc == null)

            return map;

        Element rootElement = doc.getRootElement();

        element2map(rootElement,map);

        return map;

    }

    public static Map element2map (Element outele,Map outmap) {

        List<Element> list = outele.elements();//必定返回0,1,2,3,....... 不会异常

        int size = list.size();

        Iterator<Element> eleItor = outele.elementIterator();

        if(!eleItor.hasNext()){//当前节点是叶子节点(outele如果为叶子节点,是不可能有子节点的,因为它里面是纯文本)

            outmap.put(outele.getName(), outele.getTextTrim());

        }else{

            Map<String, Object> innermap = new HashMap<String, Object>();

            for(;eleItor.hasNext();){

                Element ele1 = eleItor.next();

                String eleName = ele1.getName();

                Object obj =  innermap.get(eleName);//获取MASTER

                if(obj == null){//如果该MASTER不存在,现在有一个MASTER过来

                    element2map(ele1,innermap);

                }else{

                    if(obj instanceof java.util.Map){//如果没有生成过list,把原来的单个map合并到新的list

                        List<Map> list1 = new ArrayList<Map>();

                        list1.add((Map) innermap.remove(eleName));

                        element2map(ele1,innermap);

                        list1.add((Map) innermap.remove(eleName));

                        innermap.put(eleName, list1);

                    }else{//如果不是map,必然是list,只有这两种情况,所以不再else if 条件判断

                        element2map(ele1,innermap);

                        ((List)obj).add(innermap);

                    }

                }

            }

            outmap.put(outele.getName(), innermap);

        }

        return outmap;

    }

}