解析XML文件

在项目中，我们经常将配置文件写为xml格式，并在properties文件里，给出xml文件路径。

对于properties文件读取，这里给出propertyUtil工具类。

　　在这之前，请注意：Java 的 Properties 加载属性文件后是无法保证输出的顺序与文件中一致的，因为 Properties 是继承自 Hashtable 的， key/value 都是直接存在 Hashtable 中的，而 Hashtable 是不保证进出顺序的。

　　解决办法：继承java.util.Properties类，用LinkedHashSet 来保存它的所有 key。

OrderedProperties类如下

package com.test;

import java.util.Collections;
import java.util.Enumeration;
import java.util.LinkedHashSet;
import java.util.Properties;
import java.util.Set;

public class OrderedProperties extends Properties{

    private static final long serialVersionUID = 1L;
    
    private final LinkedHashSet<Object> keys = new LinkedHashSet<Object>();  
       
    public Enumeration<Object> keys() {  
        return Collections.<Object> enumeration(keys);  
    }  
   
    public Object put(Object key, Object value) {  
        keys.add(key);  
        return super.put(key, value);  
    }  
   
    public Set<Object> keySet() {  
        return keys;  
    }  
   
    public Set<String> stringPropertyNames() {  
        Set<String> set = new LinkedHashSet<String>();  
   
        for (Object key : this.keys) {  
            set.add((String) key);  
        }  
   
        return set;  
    }  

}

读取配置文件properties并解析xml的main方法：

package com.test;


public class T {

    public static void main(String[] args) {
        // 加载properties文件
        propertityUtil pu = propertityUtil.getInstance("project-config.properties");
        // 得到业务配置文件的路径
        String WorkConfigureFile = pu.getProperty("WorkConfigureFile");
        // 解析该xml文件
        ConfigureFileFw configureFileFw = new ConfigureFileFw();
        configureFileFw.parseConfigXmlFile(WorkConfigureFile);
        
        
    }
}

propertityUtil类如下

package com.test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class propertityUtil {

    /**
     * prop对像
     */
    private OrderedProperties prop = null;

    /**
     * 配置文件位置，默认为***-config.properties
     */
    private String CONFIGPATH = "project-config.properties";

    /**
     * 构造函数
     */
    public propertityUtil() {
        init();
    }

    /**
     * 构造函数
     * 
     * @param prop
     *            prop对像
     */
    public propertityUtil(OrderedProperties prop) {
        this.prop = prop;
    }

    /**
     * 构造函数
     * 
     * @param conf
     */
    public propertityUtil(String conf) {
        this.CONFIGPATH = conf;
        init(CONFIGPATH);
    }

    /**
     * 取得属性
     * 
     * @return
     */
    public OrderedProperties getProp() {
        return prop;
    }

    /**
     * 设置属性
     * 
     * @param prop
     */
    public void setProp(OrderedProperties prop) {
        this.prop = prop;
    }

    /**
     * 实例
     * 
     * @param configpath
     * @return
     */
    public static propertityUtil getInstance(String configpath) {
        return new propertityUtil(configpath);
    }

    /**
     * 读取属性文件
     * 
     * @param configpath
     */
    private void init(String configpath) {
        this.CONFIGPATH = configpath;
        init();
    }

    /**
     * 初始化prop，从文件中读取
     */
    private void init() {
        if (this.CONFIGPATH == null || this.CONFIGPATH.length() == 0) {
            System.out.println("No configFile");
        } else {

            String srcDir = System.getProperty("user.dir");
            srcDir = srcDir + "/resources/properties/" + this.CONFIGPATH;
            prop = new OrderedProperties();
            FileInputStream fin = null;
            try {
                fin = new FileInputStream(srcDir);
                prop.load(fin);
            } catch (FileNotFoundException e2) {
                e2.printStackTrace();
            } catch (IOException e2) {
                e2.printStackTrace();
            }

            // InputStream is = getClass().getResourceAsStream(this.CONFIGPATH);
            // prop = new Properties();
            // try {
            // prop.load(is);
            // } catch (Exception e) {
            // e.printStackTrace();
            // }
        }
    }

    /**
     * 取得属性值类
     * 
     * @param propName
     * @return
     */
    public String getProperty(String propName) {
        return getProperty(propName, "");
    }

    /**
     * 取得属性值类
     * 
     * @param propName
     * @return
     */
    public String getProperty(String propName, String defValue) {
        if (prop == null)
            init();
        String s = defValue;
        try {
            s = prop.getProperty(propName);
            if (s == null) {
                s = defValue;
            } else {
                s = s.trim();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return s;
    }

    /**
     * 设置属性
     * 
     * @param propName
     * @param value
     */
    public void setProperty(String propName, String value) {
        if (prop == null)
            init();
        try {
            prop.setProperty(propName, value);
            storeProperty();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 保存属性文件
     */
    private void storeProperty() {
        try {
            String path = prop.getProperty("path");
            OutputStream out = new FileOutputStream(path);
            prop.store(out, " -- sl Soft Config File -- ");
            out.close();
        } catch (Exception ioe) {
            ioe.printStackTrace();
        }
    }
}

xml解析类

package com.test;

import java.io.File;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * 业务方法配置管理类
 * @author 
 *
 */
public class ConfigureFileFw {
    
    /**
     * 业务方法配置Map
     */
    private static Map<String, Map<String, String>> workAttributes = new HashMap<String, Map<String, String>>();
    
    private Document document = null;
    
    private Element rootElement = null;
    
    /**
     * 获取所有业务
     * @return
     */
    public Map<String, Map<String, String>> getWorkAttributes() {
        return workAttributes;
    }
    /**
     * 根据world获取对应业务
     * @return
     */
    public Map<String, String> getWorkAttributesByWorkId(String workId) {
        return workAttributes.get(workId);
    }
    
    /**
     * 判断是否包含该业务
     * @param workId
     * @return
     */
    public String hasWorkId(String workId) {
        //Modified by wxq 2016/12/29
        //return workAttributes.containsKey(workId);
        String temp = "";
        for(String configWorkId:workAttributes.keySet()){
            if (configWorkId.contains(".*")){
                temp = configWorkId.substring(0,configWorkId.indexOf("."));
            }
            else{
                temp  = configWorkId;
            }
            if(workId.contains(temp)){
                return configWorkId;
            }
        }
        return "";
        //Ended by wxq 2016/12/29
        
    }
    /**
     * 根据业务名称获取业务
     * @param workName
     * @return
     */
    public  Map<String, String> getWorkAttributesByWorkName(String workName) {
        
        for (String str : workAttributes.keySet()) {
            Map<String, String> temp = workAttributes.get(str);
            if (temp.get("name").equals(workName)) {
                return temp;
            }
        }
        return null;
    }
    //加入业务方法
    private void addToWorkAttributes(String workId, Map<String, String> attrMap) {
        workAttributes.put(workId, attrMap);
    }
    /**
     * 根据传入的配置文件，初始化所有业务
     * @param fileName
     */
    public void parseConfigXmlFile(String fileName) {
        try {
            File f = new File(fileName);
            SAXReader reader = new SAXReader();
            Document doc = reader.read(f);
            rootElement = doc.getRootElement();
            if (!rootElement.equals(null)) {
                Element works = (Element)rootElement.element("works");
                List<?> workList = works.elements();
                for (int i = 0; i < workList.size(); i++) {
                    Element work = (Element) workList.get(i);
                    String workID = work.elementText("id");
                    String workName = work.elementText("name");
                    String workDescription = work.elementText("description");
                    String workMethod = work.elementText("method");
                    String dll = work.elementText("dll");
                    String class1 = work.elementText("class");
                    String workSend = work.elementText("send");
                    String workReceive = work.elementText("receive");

                    Map<String, String> workAttrMap = new HashMap<String, String>();
                    workAttrMap.put("id", workID);
                    workAttrMap.put("name", workName);
                    workAttrMap.put("description", workDescription);
                    workAttrMap.put("method", workMethod);
                    workAttrMap.put("dll", dll);
                    workAttrMap.put("class", class1);
                    workAttrMap.put("send", workSend);
                    workAttrMap.put("receive", workReceive);
                    workAttributes.put(workID, workAttrMap);
                }
            }
            
        } catch (Exception e) {
            System.out.println("exception:" + e.getMessage());
        }
    }

}