xml文件.

读取properties文件.
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class ReadPropertiesFile ...{

    public void readPropertiesFile(String fileName) throws FileNotFoundException ...{
        String str = "";
        Properties prop = new Properties();
        
        InputStream stream = null; 
        
        //读取这个类在同一包中的properties文件
        //stream = getClass().getClassLoader().getResourceAsStream(fileName);
        System.out.println("path:" + getClass().getResource(fileName));
        
        
        //读取SRC下的的properties文件
        String path = getClass().getResource("/").getPath();
        stream = new BufferedInputStream(new FileInputStream(new File(path+fileName)));

        try ...{
            prop.load(stream);
            str = prop.getProperty("localname");
            System.out.println("localname:" + str);
            System.out.println("properties:" + prop);
            stream.close();

        } catch (IOException e) ...{
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /** *//**
     * @param args
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) throws FileNotFoundException ...{
        // TODO Auto-generated method stub
        new ReadPropertiesFile().readPropertiesFile("config.properties");

    }
}

 

 

读取xml文件

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.xml.sax.XMLFilter;


public class XMLProperties ...{
    private File file;

    private Document doc;

    private Map propertyCache;

    public XMLProperties(byte[] fileContent) throws IOException ...{
        propertyCache = new HashMap();

        // 临时注消，本项目中不考虑写入问题
        // if (!file.canWrite()) {
        // throw new IOException("XML properties file must be writable: "
        // + fileName);
        // }

        Reader reader = null;
        try ...{
            reader = new InputStreamReader(new ByteArrayInputStream(fileContent), "UTF-8");
            SAXReader saxreader = new SAXReader();
            DataUnformatFilter format = new DataUnformatFilter();
            saxreader.setXMLFilter((XMLFilter) format);
            doc = saxreader.read(reader);
        } catch (Exception e) ...{
            throw new IOException(e.getMessage());
        } finally ...{
            try ...{
                reader.close();
            } catch (Exception exception1) ...{
            }
        }

    }

    public XMLProperties(String fileName) throws IOException ...{
        propertyCache = new HashMap();
        String path = getClass().getResource("/").getPath();
        file = new File(path+fileName);
        if (!file.exists()) ...{
            File tempFile = new File(file.getParentFile(), file.getName() + ".tmp");
            if (tempFile.exists()) ...{
                tempFile.renameTo(file);
            } else ...{
                throw new FileNotFoundException("XML properties file does not exist: "
                        + fileName);
            }
        }
        if (!file.canRead()) ...{
            throw new IOException("XML properties file must be readable: " + fileName);
        }

        // 临时注消，本项目中不考虑写入问题
        // if (!file.canWrite()) {
        // throw new IOException("XML properties file must be writable: "
        // + fileName);
        // }

        Reader reader = null;
        try ...{
            reader = new InputStreamReader(new FileInputStream(file), "UTF-8");
            SAXReader saxreader = new SAXReader();
//            DataUnformatFilter format = new DataUnformatFilter();
//            saxreader.setXMLFilter((XMLFilter) format);
            doc = saxreader.read(reader);
        } catch (Exception e) ...{
            throw new IOException(e.getMessage());
        } finally ...{
            try ...{
                reader.close();
            } catch (Exception exception1) ...{
            }
        }
    }

    public synchronized String getProperty(String name) ...{
        String value = (String) propertyCache.get(name);
        if (value != null) ...{
            return value;
        }
        String propName[] = parsePropertyName(name);
        Element element = doc.getRootElement();
        for (int i = 0; i < propName.length; i++) ...{
            // element = element.getChild(propName[i]);
            element = element.element(propName[i]);
            if (element == null) ...{
                return null;
            }
        }

        value = element.getText();
        if ("".equals(value)) ...{
            return null;
        } else ...{
            value = value.trim();
            propertyCache.put(name, value);
            return value;
        }
    }

    public String[] getChildrenProperties(String parent) ...{
        String propName[] = parsePropertyName(parent);
        Element element = doc.getRootElement();
        for (int i = 0; i < propName.length; i++) ...{
            element = element.element(propName[i]);
            if (element == null) ...{
                return new String[0];
            }
        }

        List children = element.elements();
        int childCount = children.size();
        String childrenNames[] = new String[childCount];
        for (int i = 0; i < childCount; i++) ...{
            childrenNames[i] = ((Element) children.get(i)).getName();
        }

        return childrenNames;
    }

    public synchronized void setProperty(String name, String value) ...{
        if (value == null) ...{
            value = "";
        }
        propertyCache.put(name, value);
        String propName[] = parsePropertyName(name);
        Element element = doc.getRootElement();
        for (int i = 0; i < propName.length; i++) ...{
            if (element.element(propName[i]) == null) ...{
                element.addElement(propName[i]);
            }
            element = element.element(propName[i]);
        }

        element.setText(value);
        saveProperties();
    }

    public synchronized void deleteProperty(String name) ...{
        propertyCache.remove(name);
        String propName[] = parsePropertyName(name);
        Element element = doc.getRootElement();
        for (int i = 0; i < propName.length - 1; i++) ...{
            element = element.element(propName[i]);
            if (element == null) ...{
                return;
            }
        }

        // element.remove(propName[propName.length - 1]);
        element.remove((Element) element.elements(propName[propName.length - 1]));
        saveProperties();
    }

    private synchronized void saveProperties() ...{
        Writer writer = null;
        boolean error = false;
        File tempFile = null;
        try ...{
            tempFile = new File(file.getParentFile(), file.getName() + ".tmp");
            // XMLOutputter outputter = new XMLOutputter(" ", true);
            writer = new OutputStreamWriter(new FileOutputStream(tempFile), "UTF-8");
            // outputter.output(doc, writer);
            OutputFormat fmt = new OutputFormat("    ", true);
            XMLWriter xmlwriter = new XMLWriter(writer, fmt);
            xmlwriter.write(doc);
            xmlwriter.close();
        } catch (Exception e) ...{
            error = true;
        } finally ...{
            try ...{
                writer.close();
            } catch (Exception e) ...{
                error = true;
            }
        }
        if (!error) ...{
            error = false;
            if (!file.delete()) ...{
                return;
            }
            try ...{
                // XMLOutputter outputter = new XMLOutputter(" ", true);
                writer = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
                // outputter.output(doc, writer);

                OutputFormat fmt = new OutputFormat("    ", true);
                XMLWriter xmlwriter = new XMLWriter(writer, fmt);
                xmlwriter.write(doc);
                xmlwriter.close();
            } catch (Exception e) ...{
                error = true;
            } finally ...{
                try ...{
                    writer.close();
                } catch (Exception e) ...{
                    error = true;
                }
            }
            if (!error) ...{
                tempFile.delete();
            }
        }
    }

    private String[] parsePropertyName(String name) ...{
        List propName = new ArrayList(5);
        for (StringTokenizer tokenizer = new StringTokenizer(name, "."); tokenizer
                .hasMoreTokens(); propName.add(tokenizer.nextToken())) ...{
            ;
        }
        return (String[]) propName.toArray(new String[propName.size()]);
    }

    public static String parseSysPath(String path) ...{
        try ...{
            path = URLDecoder.decode(path, "UTF-8");
        } catch (Exception e) ...{
        }
        return path;
    }
    
    public static void main(String[] args) throws IOException ...{
        XMLProperties xp = new XMLProperties("testEmp.xml");
        System.out.println(xp.getProperty("response.validate"));
        System.out.println(xp.getProperty("response.employee.username"));
        System.out.println(xp.getProperty("response.employee.phone"));
        xp.getChildrenProperties("response");
    }
}