用于将对象持久化到XML文件以及读取，删除的持久化类（dom4j,xstream实现）

弄着玩的，不看也罢。

在此类的帮助下，你不必关注细节就能将对象持久化到XML文件以及读取，删除，只有更新麻烦一点，你需要先删除再添加。

具体代码：
XmlPersistence类：

package com.sitinspring.persist;

import java.io.File;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

import com.thoughtworks.xstream.XStream;

/** *//**
 * 用于将任意对象持久化到XML文件及其逆过程的持久化类（dom4j,xstream实现）
 * 
 * @author: sitinspring(junglesong@gmail.com)
 * @date: 2008-1-8
 */
public class XmlPersistence<T> {
    // XML文件名
    private final String xmlFile;

    // XML 文档对象
    private Document document;

    // 根节点
    private Element root;

    // 根节点名称
    private final String rootText = "root";

    /** *//**
     * 单参数构造函数，指定存储的文件名
     * 
     * @param xmlFile
     */
    public XmlPersistence(String xmlFile) {
        this.xmlFile = xmlFile;

        init();
    }

    /** *//**
     * 添加一个对象對應的節點到XML文件
     * 
     * @param type
     */
    public void add(T type) {
        // 将对象转化为XML文字
        XStream xStream = new XStream();
        String xml = xStream.toXML(type);

        try {
            // 将转化后的文字变成节点
            Document docTmp = DocumentHelper.parseText(xml);
            Element typeElm = docTmp.getRootElement();

            // 添加这个节点
            root.add(typeElm);

            // 保存文件
            saveDocumentToFile();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /** *//**
     * 从XML文件中,删除一个对象對應的節點
     * 
     * @param type
     */
    public void del(T type) {
        // 将对象转化为XML文字
        XStream xStream = new XStream();
        String xml = xStream.toXML(type);

        try {
            List nodes = root.elements();

            for (Iterator it = nodes.iterator(); it.hasNext();) {
                Element companyElm = (Element) it.next();

                // 查找，节点全文相同必定元素相同
                if (companyElm.asXML().equals(xml)) {
                    // 删除原有节点
                    root.remove(companyElm);

                    // 保存文件
                    saveDocumentToFile();
                    return;
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /** *//**
     * 从XML中取得所有对象
     * 
     * @return
     */
    public List<T> loadAll() {
        List<T> retval = new ArrayList<T>();

        try {
            List nodes = root.elements();

            for (Iterator it = nodes.iterator(); it.hasNext();) {
                // 取得每個節點
                Element companyElm = (Element) it.next();

                // 將節點轉化為對象
                XStream xStream = new XStream();
                T t = (T) xStream.fromXML(companyElm.asXML());

                retval.add(t);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return retval;
    }

    // 初始化文档对象及根节点
    private void init() {
        File file = new File(xmlFile);

        try {
            // 判断文件的存在以增强程序的健壮性
            if (file.exists()) {
                // 文件存在,直接从文件读取文档对象
                SAXReader reader = new SAXReader();
                document = reader.read(file);
                root = document.getRootElement();
            } else {
                // 文件不存在,创建文档对象
                document = DocumentHelper.createDocument();
                root = document.addElement(rootText);// 创建根节点
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /** *//**
     * 将Document写回文件
     * 
     */
    private void saveDocumentToFile() {
        try {
            OutputFormat format = OutputFormat.createPrettyPrint();
            format.setEncoding("GBK"); // 指定XML编码
            XMLWriter writer = new XMLWriter(new FileWriter(xmlFile), format);

            writer.write(document);
            writer.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

测试类及测试代码：
Company类：

package com.sitinspring.domain;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;

/** *//**
 * 领域对象-公司类
 * 
 * @author sitinspring
 * 
 * @date 2007-12-30
 */
public class Company {
    //     公司名
    private String name;

    // 成员哈希表
    private Map<String, Employee> staff;

    /** *//**
     * 构造函数
     * @param name
     */
    public Company(String name){
        this.name=name;
    }

    public String toString(){
        String retval="公司:名称="+name;

        if(staff != null){
            Iterator<Employee> iter=staff.values().iterator();
            retval+=" 雇员有:";

            while(iter.hasNext()){
                Employee tmp=iter.next();
                retval+=tmp.getName()+",";                
            }
        }

        return retval;
    }

    /** *//**
     * 向成员哈希表中添加成员
     * 
     * @param employee
     * @return true:添加成功;false:有同名成员存在,添加失败
     */
    public boolean add(Employee employee) {
        if (staff == null) {
            staff = new Hashtable<String, Employee>();
        }

        if (staff.containsKey(employee.getName())) {
            // 存在同名成员
            return false;
        } else {
            // 不存在同名成员
            staff.put(employee.getName(), employee);

            // 给member赋上自己的指针,以便让成员示例能找到自己所在的公司
            employee.setCompany(this);

            return true;
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

测试类Employee:

package com.sitinspring.domain;

/** *//**
 * 领域对象-雇员类
 * 
 * @author sitinspring
 * 
 * @date 2007-12-30
 */
public class Employee implements Comparable {

    private String name;// 姓名

    // 指向包含自己的公司的指针
    private Company company;

    public Employee(String name){
        this.name=name;
    }

    public int compareTo(Object obj) {
        Employee another = (Employee) obj;

        return this.name.compareTo(another.name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Company getCompany() {
        return company;
    }

    public void setCompany(Company company) {
        this.company = company;
    }
}
测试代码：
1.存储过程
// 1.存储过程
        Company google=new Company("google");
        google.add(new Employee("Andy"));
        google.add(new Employee("Bill"));

        Company microsoft=new Company("Microsoft");
        microsoft.add(new Employee("Cindy"));
        microsoft.add(new Employee("Douglas"));

        XmlPersistence<Company> persistCmp=new XmlPersistence<Company>("company.xml");
        persistCmp.add(google);
        persistCmp.add(microsoft);
2.读取过程
        XmlPersistence<Company> persistCmp=new XmlPersistence<Company>("company.xml");
        List<Company> ls=persistCmp.loadAll();
        for(Company company:ls){
            System.out.println(company);
        }
3.删除及更新过程
        // 3.删除及更新过程
        Company google=new Company("google");
        google.add(new Employee("Andy"));
        google.add(new Employee("Bill"));

        Company microsoft=new Company("Microsoft");
        microsoft.add(new Employee("Cindy"));
        microsoft.add(new Employee("Douglas"));

        XmlPersistence<Company> persistCmp=new XmlPersistence<Company>("company.xml");
        persistCmp.add(google);
        persistCmp.add(microsoft);

        // 删除一个公司
        persistCmp.del(microsoft);

        // 更新一个公司(先删除旧的再添加新的)
        persistCmp.del(google);        
        google.setName("谷歌");
        google.add(new Employee("sitinspring"));
        persistCmp.add(google);

        List<Company> ls=persistCmp.loadAll();
        for(Company company:ls){
            System.out.println(company);
        }