您现在的位置：程式碼之家 >> 編程語言 > >> Java 程式設計 >> J2ME

J2ME 最佳實踐：打造靈活易維護的 RMS 儲存框架 — StorageHandler 模式

編輯：J2ME

痛點分析

RMS 雖提供持久化能力，但原生 API 存在三大短板：

唯一鍵值限於整數 Record ID，無法直接使用 String 等業務鍵值查詢。
枚舉遍歷效能低落，需逐筆反序列化比對。
業務邏輯與儲存細節耦合，導致程式碼分散、難以維護。

解決方案：引入「索引 RecordStore」+「Storable 介面」

核心思想：建立一個專用的 "index" RecordStore 當作查找表，將業務鍵值映射至實際資料的 Record ID，實現 O(1) 級別的鍵值查找。

架構圖解

+----------------+       +----------------+       +------------------+
|  業務物件       | ----> |  IndexEntry    | ----> |  資料 RecordStore |
|  (UserInfo等)   |  Key  |  (key -> recId) |  ID   |  (byte[] payload) |
+----------------+       +----------------+       +------------------+
        ^                         ^
        |                         |
   實作 Storable            記憶體中維護
   介面序列化               Vector 快取

核心元件實作

1. Storable 介面：統一序列化契約

public interface Storable {
    String getKey();                              // 業務唯一鍵值
    void getData(DataOutputStream out) throws IOException; // 序列化
    void setData(DataInputStream in) throws IOException;   // 反序列化
}

2. IndexEntry：索引實體


class IndexEntry {
    private int selfId;    // 索引自身在 index Store 的 Record ID
    private int recordId;  // 指向資料 Store 的 Record ID
    private String key;    // 業務鍵值

    // Getter/Setter 略...
}

3. 業務物件範例：UserInfo

public class UserInfo implements Storable {
    private String username;
    private String password;
    private boolean autoLogin;

    public String getKey() { return "user.info"; } // 單例鍵值

    public void getData(DataOutputStream out) throws IOException {
        out.writeUTF(username);
        out.writeUTF(password);
        out.writeBoolean(autoLogin);
    }

    public void setData(DataInputStream in) throws IOException {
        username = in.readUTF();
        password = in.readUTF();
        autoLogin = in.readBoolean();
    }
    // Getter/Setter 略...
}

4. StorageHandler：唯一存取入口

public class StorageHandler {
    private static final String INDEX_STORE = "index";
    private static final String DATA_STORE = "data";
    private RecordStore indexRs, dataRs;
    private Vector indexCache = new Vector<>(); // 記憶體快取

    private static StorageHandler instance;
    public static synchronized StorageHandler getInstance() {
        if (instance == null) instance = new StorageHandler();
        return instance;
    }

    private StorageHandler() {
        try {
            indexRs = RecordStore.openRecordStore(INDEX_STORE, true);
            dataRs = RecordStore.openRecordStore(DATA_STORE, true);
            loadIndexCache(); // 啟動時載入索引至記憶體
        } catch (RecordStoreException e) {
            throw new RuntimeException("RMS 初始化失敗", e);
        }
    }

    // 載入所有索引至 Vector，O(N) 一次性成本
    private void loadIndexCache() throws RecordStoreException {
        RecordEnumeration enum = indexRs.enumerateRecords(null, null, false);
        try {
            while (enum.hasNextElement()) {
                byte[] data = enum.nextRecord();
                IndexEntry entry = deserializeIndex(data);
                indexCache.addElement(entry);
            }
        } finally {
            enum.destroy();
        }
    }

    // 查找索引：記憶體中線性搜尋 (索引量通常 < 100，效能足夠)
    private IndexEntry findIndex(String key) {
        for (int i = 0; i < indexCache.size(); i++) {
            IndexEntry e = (IndexEntry) indexCache.elementAt(i);
            if (e.getKey().equals(key)) return e;
        }
        return null;
    }

    // 核心：儲存或更新
    public void storeOrUpdate(Storable obj) {
        String key = obj.getKey();
        IndexEntry idx = findIndex(key);
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
        try {
            obj.getData(dos);
            dos.flush();
            byte[] payload = bos.toByteArray();

            if (idx == null) {
                // 新增
                int dataId = dataRs.addRecord(payload, 0, payload.length);
                idx = new IndexEntry();
                idx.setKey(key);
                idx.setRecordId(dataId);
                // 寫入索引並取得索引自身 ID
                idx.setSelfId(indexRs.addRecord(serializeIndex(idx), 0, serializeIndex(idx).length));
                indexCache.addElement(idx);
            } else {
                // 更新現有資料
                dataRs.setRecord(idx.getRecordId(), payload, 0, payload.length);
            }
        } catch (IOException | RecordStoreException e) {
            throw new RuntimeException("儲存失敗: " + key, e);
        }
    }

    // 核心：讀取
    public void load(Storable obj) {
        IndexEntry idx = findIndex(obj.getKey());
        if (idx == null) return; // 保持物件預設值

        try {
            byte[] data = dataRs.getRecord(idx.getRecordId());
            DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data));
            obj.setData(dis);
        } catch (RecordStoreException | IOException e) {
            throw new RuntimeException("讀取失敗: " + obj.getKey(), e);
        }
    }

    // 刪除
    public void delete(String key) {
        IndexEntry idx = findIndex(key);
        if (idx == null) return;
        try {
            dataRs.deleteRecord(idx.getRecordId());
            indexRs.deleteRecord(idx.getSelfId());
            indexCache.removeElement(idx);
        } catch (RecordStoreException e) {
            throw new RuntimeException("刪除失敗", e);
        }
    }

    // 序列化/反序列化 IndexEntry 略...
}

使用方式：極簡呼叫

// 儲存使用者設定
UserInfo info = new UserInfo();
info.setUsername("ming");
info.setPassword("123456");
info.setAutoLogin(true);
StorageHandler.getInstance().storeOrUpdate(info);

// 讀取使用者設定
UserInfo loaded = new UserInfo();
StorageHandler.getInstance().load(loaded);
// loaded 現在已填入持久化資料

優勢總結

維度	原生 RMS	StorageHandler 框架
查詢鍵值型別	僅 int (Record ID)	任意 String
查詢效能	O(N) 枚舉 + 反序列化	O(1) 記憶體快取查找 + 單次讀取
業務程式碼耦合度	高 (到處散落 RMS API)	零 (僅實作 Storable)
新增資料類型成本	需修改多處 DAO 程式碼	僅建立新類別實作 Storable
程式碼可測試性	難 (依賴真實 RMS)	易 (可 Mock StorageHandler)