DIV CSS 佈局教程網

您现在的位置: DIV+CSS佈局教程網 >> 網頁腳本 >  >> XML學習教程 >> XML詳解
以 XML 作為持久化儲存介質的 Java 實作方案
編輯:XML詳解     

以 XML 作為持久層解決方案,基本上要具備以下功能:

  1. 物件的 CRUD 功能(本例的基本物件是 Member 類)。
  2. 保證執行緒安全,對桌面程式與 Web 程式同樣適用。
  3. 具備快取機制,即使儲存介質(XML 檔)突然丟失,系統仍能維持有效運作。

本例採用 MemberService 與 MemberPersistence 兩個類別協作完成這些功能。

MemberService 是業務層與持久層之間的橋梁,負責 Member 物件的 CRUD 操作。它內建一個 Hashtable 來快取 Member 物件,即使檔案突然丟失,快取中的資料也不受影響;同時它內含一個 MemberPersistence 成員,負責與持久介質互動。

add()、delete()、update() 三個方法都透過 lockObj 實作了同步,因此無須擔心執行緒安全;其他方法因未修改 members 成員,故不需要同步。以下以 add() 為例:

try {
    memberPersistence.add(member);
    members.put(member.getId(), member);
    return true;
}
catch (XmlFileWriteException ex) {
    System.out.println("Member:" + member.getId() + " add error!");
    return false;
}

關鍵在於:只有當 MemberPersistence 成功加入物件後,才會把它加入 members 快取,這樣能確保快取與實際資料的同步。若顛倒順序,一旦 MemberPersistence 加入失敗丟出 XmlFileWriteException,就還得在 catch 中刪除剛才加入的物件,反而人為增加了程式碼的複雜度,不如上面的做法簡單高效。

以下是 MemberService 類別的完整程式碼:

package com.sitinspring.service;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import com.sitinspring.domain.Member;
import com.sitinspring.domain.MemberFilter;
import com.sitinspring.exception.XmlFileReadException;
import com.sitinspring.exception.XmlFileWriteException;
import com.sitinspring.persistence.MemberPersistence;

public class MemberService {
    private static Hashtable<String, Member> members;
    private static MemberPersistence memberPersistence;
    private static final Object lockObj = new Object();

    static {
        try {
            memberPersistence = new MemberPersistence("member.xml");
            members = memberPersistence.loadMemberFromFile();
        } catch (XmlFileReadException ex) {
            System.out.println("Can't read the file: member.xml");
        } catch (XmlFileWriteException ex) {
            System.out.println("Can't write to the file: member.xml");
        }
    }

    public boolean hasMember(String id) {
        return members.containsKey(id);
    }

    public boolean hasMember(Member member) {
        return hasMember(member.getId());
    }

    public boolean add(Member member) {
        if (hasMember(member)) {
            System.out.println("Member:" + member.getId() + " has been exist!");
            return false;
        } else {
            synchronized (lockObj) {
                try {
                    memberPersistence.add(member);
                    members.put(member.getId(), member);
                    return true;
                } catch (XmlFileWriteException ex) {
                    System.out.println("Member:" + member.getId() + " add error!");
                    return false;
                }
            }
        }
    }

    public boolean update(Member member) {
        if (hasMember(member)) {
            synchronized (lockObj) {
                try {
                    memberPersistence.update(member);
                    Member oldMember = members.get(member.getId());
                    oldMember.setName(member.getName());
                    oldMember.setAge(member.getAge());
                    return true;
                } catch (XmlFileWriteException ex) {
                    System.out.println("Member:" + member.getId() + " update error!");
                    return false;
                }
            }
        } else {
            System.out.println("Member:" + member.getId() + " can't be found!");
            return false;
        }
    }

    public boolean saveOrUpdate(Member member) {
        if (hasMember(member)) return update(member);
        else return add(member);
    }

    public boolean delete(Member member) {
        if (hasMember(member)) {
            synchronized (lockObj) {
                try {
                    memberPersistence.delete(member.getId());
                    members.remove(member.getId());
                    return true;
                } catch (XmlFileWriteException ex) {
                    System.out.println("Member:" + member.getId() + " delete error!");
                    return false;
                }
            }
        } else {
            System.out.println("Member:" + member.getId() + " can't be found!");
            return false;
        }
    }

    @SuppressWarnings("unchecked")
    public List<Member> search(MemberFilter memberFilter) {
        ArrayList<Member> retval = new ArrayList<Member>();
        for (Iterator it = members.keySet().iterator(); it.hasNext();) {
            String key = (String) it.next();
            Member member = members.get(key);
            if (memberFilter.accept(member)) {
                retval.add(member);
            }
        }
        Collections.sort(retval);
        return retval;
    }

    public List<Member> getAll() {
        MemberFilter filter = new MemberFilter() {
            public boolean accept(Member member) {
                return true;
            }
        };
        return search(filter);
    }
}

MemberPersistence 類別是與 XML 檔打交道的部分,資料透過它才能真正存入持久介質。它的函數都容易理解,運作時實際只會引發兩種例外——讀 XML 檔例外(通常由多個根節點導致)與寫 XML 檔例外;會觸發這些例外的函數都應妥善捕獲並拋出處理。

package com.sitinspring.persistence;

import java.io.File;
import java.io.FileWriter;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import com.sitinspring.domain.Member;
import com.sitinspring.exception.XmlFileReadException;
import com.sitinspring.exception.XmlFileWriteException;

public class MemberPersistence {
    private String xmlFilePos;
    private Document document;

    public MemberPersistence(String xmlFilePos)
            throws XmlFileReadException, XmlFileWriteException {
        this.xmlFilePos = xmlFilePos;
        if (isFileExist(this.xmlFilePos) == false) {
            createDocument();
            return;
        } else {
            SAXReader reader = new SAXReader();
            try {
                document = reader.read(new File(this.xmlFilePos));
            } catch (Exception ex) {
                throw new XmlFileReadException(ex.getMessage());
            }
        }
    }

    private void createDocument() throws XmlFileWriteException {
        String text = "<members></members>";
        try {
            document = DocumentHelper.parseText(text);
            writeDocumentToFile();
        } catch (XmlFileWriteException ex) {
            throw ex;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    private void writeDocumentToFile() throws XmlFileWriteException {
        try {
            XMLWriter writer = new XMLWriter(new FileWriter(this.xmlFilePos));
            writer.write(document);
            writer.close();
        } catch (Exception ex) {
            throw new XmlFileWriteException(ex.getMessage());
        }
    }

    public Hashtable<String, Member> loadMemberFromFile() {
        Hashtable<String, Member> retval = new Hashtable<String, Member>();
        List nodes = document.getRootElement().elements("member");
        for (Iterator it = nodes.iterator(); it.hasNext();) {
            Element elm = (Element) it.next();
            Member member = new Member(elm.attributeValue("id"),
                elm.elementText("name"), Integer.parseInt(elm.elementText("age")));
            retval.put(member.getId(), member);
        }
        return retval;
    }

    public boolean add(Member member) throws XmlFileWriteException {
        try {
            Element rootElm = document.getRootElement();
            Element newMemberElm = rootElm.addElement("member");
            newMemberElm.addAttribute("id", member.getId());
            Element nameElm = newMemberElm.addElement("name");
            nameElm.setText(member.getName());
            Element ageElm = newMemberElm.addElement("age");
            ageElm.setText(String.valueOf(member.getAge()));
            writeDocumentToFile();
            return true;
        } catch (XmlFileWriteException ex) {
            throw ex;
        }
    }

    public boolean update(Member member) throws XmlFileWriteException {
        try {
            Element rootElm = document.getRootElement();
            List nodes = rootElm.elements("member");
            for (Iterator it = nodes.iterator(); it.hasNext();) {
                Element elm = (Element) it.next();
                if (elm.attributeValue("id").equals(member.getId())) {
                    elm.element("name").setText(member.getName());
                    elm.element("age").setText(String.valueOf(member.getAge()));
                    break;
                }
            }
            writeDocumentToFile();
            return false;
        } catch (XmlFileWriteException ex) {
            throw ex;
        }
    }

    public boolean delete(String id) throws XmlFileWriteException {
        try {
            Element rootElm = document.getRootElement();
            List nodes = rootElm.elements("member");
            for (Iterator it = nodes.iterator(); it.hasNext();) {
                Element elm = (Element) it.next();
                Member member = new Member(elm.attributeValue("id"),
                    elm.elementText("name"), Integer.parseInt(elm.elementText("age")));
                if (member.getId().equals(id)) {
                    rootElm.remove(elm);
                    break;
                }
            }
            writeDocumentToFile();
            return false;
        } catch (XmlFileWriteException ex) {
            throw ex;
        }
    }

    public static boolean isFileExist(String filePath) {
        boolean exists = (new File(filePath)).exists();
        return exists;
    }
}

整體而言,MemberService 負責業務邏輯與快取同步,MemberPersistence 負責與 XML 檔實際讀寫,兩者透過明確的例外處理機制協同運作,既保證了執行緒安全,也在檔案異常時透過快取維持了系統的可用性——這正是以 XML 作為輕量級持久化儲存時,一個值得參考的實作思路。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved