Java用DOM方法解析xml

最近我们项目在做系统界面颜色配置，用java dom解析xml文件来自动生成css。我上网查了些资料，简单的把java用DOM解析XML文档的方法和实例列在文章里，供自己参考。

1. DOM(Document Object Model)

　　DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点的集合。由于它是基于信息层次的，所以DOM被视为是基于树或基于对象的。你可以把它想象成一颗DOM树， 通过节点以及节点之间的关系操作XML文档。不过用DOM操作XML需要加载整个XML文档来构造层次结构，因此消耗资源大。

　　下面这个XML文件是用来生成界面css的

<cssStyleItems>
    <cssItem>
        <cssClass>
            <element>#header</element>
        </cssClass>
        <inherentCss>
            <element>margin-bottom:20px;</element>
            <element>min-height: 70px;</element>
            <element>padding: 28px 0px 0;</element>
            <element>box-shadow: 0 5px 10px rgba(0, 0, 0, 0.4);</element>
            <element>background-image: -moz-linear-gradient(top, rgba(255, 255, 255, 0.1) 0%, rgba(0, 0, 0, 0.1) 40%, rgba(0, 0, 0, 0.2) 98%, #FFFFFF 100%);</element>
            <element>background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0%, rgba(255, 255, 255, 0.1)),
                     color-stop(40%, rgba(0, 0, 0, 0.1)), color-stop(98%, rgba(0, 0, 0, 0.2)),color-stop(100%, #FFFFFF));</element>
            <element>background-image: -webkit-linear-gradient(top, rgba(255, 255, 255, 0.1) 0%, rgba(0, 0, 0, 0.1) 40%, rgba(0, 0, 0, 0.2) 98%, #FFFFFF 100%);</element>
            <element>background-image: -o-linear-gradient(top, rgba(255, 255, 255, 0.1) 0%, rgba(0, 0, 0, 0.1) 40%, rgba(0, 0, 0, 0.2) 98%, #FFFFFF 100%);</element>   
            <element>filter: progid:DXImageTransform.Microsoft.Gradient(GradientType=0, StartColorStr='#22FFFFFF', EndColorStr='#33000000');</element>
            <element>background-image: linear-gradient(to bottom, rgba(255, 255, 255, 0.1) 0%, rgba(0, 0, 0, 0.1) 40%, rgba(0, 0, 0, 0.2) 98%, #FFFFFF 100%);</element>
        </inherentCss>
        <configCss>
            <element cssClass_id="headerBackgroundColor">background-color:</element>
        </configCss>
    </cssItem>
<cssStyleItems>

　　Java调用DOM解析XML

package com.utils;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import com.bean.CssLibBean;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;


public class CssStyleBuilderAdv {
    private static final String IMPORTANT = "important"; //读取xml里important属性
    private static final String CSS_CLASS_ID = "cssClass_id"; //读取xml里cssClass_id属性
    private static final String CONFIG_CSS = "configCss"; //读取xml里configCss节点
    private static final String INHERENT_CSS = "inherentCss"; //读取xml里inherentCss节点
    private static final String CSS_CLASS = "cssClass"; //读取xml里cssClass节点
    private static final String WRAPPER = "    "; //设置空格

    private Map<String, String> cssElementMap;

    public CssStyleBuilderAdv(Map<String, String> cssElementMap) {
        this.cssElementMap = cssElementMap;
    }


    /**
     * 在现在的主题上解析xml生成css_build.css
     *
     * @return
     */
    //    
    public void buildCssFile(String currentTheme) throws FileNotFoundException {
        writeCssFile(readXMLFile(currentTheme), currentTheme);
    }


    /**
     * 读取CSS template.xml
     *
     * @return Css build
     */
    public String readXMLFile(String currentTheme) {
        String rebuiltCss = "";
        DocumentBuilderFactory domfac = DocumentBuilderFactory.newInstance();
        try {
            DocumentBuilder domBuilder = domfac.newDocumentBuilder();
            String cssTemplateUrl = SystemParameters.getConfigPath() + "/" + currentTheme + "/cssTemplate.xml"; //获取指定位置的xml
            File file = new File(cssTemplateUrl);
            InputStream is = new FileInputStream(file);
            Document doc = domBuilder.parse(is);
            NodeList cssItemList = doc.getElementsByTagName("cssItem"); //获取cssItem节点
            if (cssItemList != null) {
                for (int i = 0; i < cssItemList.getLength(); i++) {  //遍历cssItem节点列表
                    StringBuffer cssClassList = new StringBuffer();  //定义cssItem的孩子节点cssClass列表
                    StringBuffer inherentCssList = new StringBuffer(); //定义cssItem的孩子节点inherentCss列表
                    StringBuffer configCssList = new StringBuffer();  //定义cssItem的孩子节点configCss列表
                    Node cssItem = cssItemList.item(i);  
                    NodeList childNodes = cssItem.getChildNodes();  //获取cssItem的孩子列表
                    for (int j = 0; j < childNodes.getLength(); j++) {  //遍历列表
                        StringBuffer cssClassItem = new StringBuffer();
                        StringBuffer inherentCss = new StringBuffer();
                        StringBuffer configCss = new StringBuffer();
                        Node cssNode = childNodes.item(j);
                        if (cssNode.getNodeType() == Node.ELEMENT_NODE) {
                            NodeList elementNodes = cssNode.getChildNodes(); //如果节点等于Node.ELEMENT_NODE,获取该节点的孩子列表
                            for (int z = 0; z < elementNodes.getLength(); z++) { //遍历列表
                                Node elementNode = elementNodes.item(z);
                                if (elementNode.getNodeType() == Node.ELEMENT_NODE) {
                                    if (cssNode.getNodeName().equals(CSS_CLASS)) {  
                                        cssClassItem.append(elementNode.getTextContent()); //将节点CSS_CLASS内容存到cssClassItem变量
                                        cssClassItem.append(",
");
                                    }
                                    if (cssNode.getNodeName().equals(INHERENT_CSS)) {
                                        inherentCss.append(WRAPPER);
                                        inherentCss.append(elementNode.getTextContent()); //将节点INHERENT_CSS内容存到inherentCss变量
                                        inherentCss.append("
");
                                    }
                                    if (cssNode.getNodeName().equals(CONFIG_CSS)) {
                                        configCss = configCss.append(switchValueByAttrId(elementNode, configCss)); //将节点CONFIG_CSS内容存到configCss变量
                                    }
                                }
                            }
                            cssClassList.append(cssClassItem);
                            inherentCssList.append(inherentCss);
                            configCssList.append(configCss);
                        }
                    }
                    rebuiltCss += cssClassList.toString().substring(0, cssClassList.length() - 2) + "{
"
                            + inherentCssList + configCssList + "}

"; //rebuiltCss存放生成的css
                }
            }
        } catch (ParserConfigurationException e) {
            LOGGER.warn("ParserConfigurationException : ", e);
        } catch (FileNotFoundException e) {
            LOGGER.warn("FileNotFoundException : ", e);
        } catch (SAXException e) {
            LOGGER.warn("SAXException : ", e);
        } catch (IOException e) {
            LOGGER.warn("IOException : ", e);
        }
        return rebuiltCss;  //返回生成的css样式
    }

    /**
     * 将xml解析出的css写入css_build.css
     *
     * @param generatedCss
     */
    public void writeCssFile(String generatedCss, String currentTheme) {
        String packageName = currentTheme.substring(0, 1).toLowerCase() + currentTheme.substring(1);
        String url = SystemParameters.getCssPath() + "/" + packageName + "/CSS_Build.css";
        try {
            File f = new File(url);
            if (f.exists()) {
                BufferedWriter output = new BufferedWriter(new FileWriter(f));
                f.setWritable(true);
                output.write(generatedCss); 
                output.close();
            } else {
                if (f.createNewFile()) {
                    f.setWritable(true);
                    BufferedWriter output = new BufferedWriter(new FileWriter(f));
                    output.write(generatedCss);
                    output.close();
                } else {
                    LOGGER.info("Create Failed");
                }
            }
        } catch (Exception e) {
            LOGGER.warn("Exception : ", e);
        }
    }

    /**
     * 通过获取不同主题的配色方案生成动态css
     *
     * @param elementNode
     * @param configCss
     * @return
     */
    private StringBuffer switchValueByAttrId(Node elementNode, StringBuffer configCss) {
        NamedNodeMap elementAttMap = elementNode.getAttributes();
        String attributeValue = elementAttMap.getNamedItem(CSS_CLASS_ID).getTextContent(); //获取CSS_CLASS_ID属性的值
        String importantValue = "";
        String nodeTextContext = WRAPPER + elementNode.getTextContent() + " ";
        if (elementAttMap.getNamedItem(IMPORTANT) != null) {
            importantValue = "!important"; //获取important值
        }
        configCss.append(nodeTextContext + cssElementMap.get(attributeValue));  //cssElementMap函数调用attributeValue获取不同主题的颜色
        configCss.append(importantValue);
        configCss.append(";
");
        return configCss; //返回获取主题颜色后的configCss
    }
}