打造自己的RMS框架

RMS提供的记录操作可以实现根据ID直接获得记录，或者枚举出一个表中的所有记录。

但是枚举记录的效率是非常低的，因为只能比较byte[]数据来确定该记录是否是所需要的记录。通过ID获得记录是高效而方便的，类似于SQL语句中”selecte byteArrayData from recordStoreName where RecordID = ?”。然而，通常应用程序很难知道某条激流的ID号，而RMS记录的“主键”又仅限于int类型，无法使用其他类型如String作为“主键”来查找。因此，对于需要存取不同类型对象的应用程序而言，就需要一个灵活的RMS操作框架。

我们的基本设想是，如果能使用String作为“主键”来查找记录，就能非常方便地获得所需的内容。例如，应用程序设置可以通过"sys.settings"获得byte[]数组，并依次读取出设置，用户登录信息可以通过"user.info"获得byte[]数组，再分解出用户名和口令。

因此，我们实现一个StorageHandler类，提供唯一的RMS访问接口，使得其他类完全不必考虑底层的RMS操作，只需提供能标识自身的一个String即可。

如果我们能实现一种类似于数据库索引的查找表，就能根据String关键字查找某条记录。因此，我们使用一个名为"index"的RecordStore来存储所有的索引，每一条索引都指向某一条具体记录的ID，设计一个IndexEntry表示一条索引：

class IndexEntry {
private int selfId;   // IndexEntry的ID
private int recordId; // 对应记录的ID
private String key;   // 访问记录的Key
}

根据索引查找，分3步进行：

1．在名为"index"的RecordStore中根据String查找对应的IndexEntry。
2．取出IndexEntry，获得记录ID号。
3．根据ID号获得另一个RecordStore的记录，然后就可以读取、更新和删除该记录。

根据网上的那一篇J2ME最佳实践之RMS操作（建议先看看这篇），我写了一个自己的RMS框架，包含完整的代码。
首先看看示意图，示意图总是看着让我思路清晰一些。

这幅图摘自J2ME最佳实践之RMS操作，很明显我需要两个RecordStore，一个index存储String类型的主键和RecordId，另一个data存储记录。

我为我的RMS框架也做了一份示意图，从图中可以看出我的类结构

• RecordManager——用于操作RecordStore的类，提供了一些操作RMS的基本方法
• StoreHandler——仓库处理类，提供了LoadData、StoreData、StoreIndex方法
• IndexEntry——主键、记录ID实体类，对应上图RecordStore中的index
• IStore——接口，提供SaveData(保存数据)、ReadData(读取数据)的方法，需要进行存储的对象，只需要对象对应的类实现IStore接口
• User,Person——实体类，实现IStore接口
   

RecordManager类：

package com.org.sunny.rms;

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import javax.microedition.rms.RecordStore;
import javax.microedition.rms.RecordStoreException;

/**
 *
 * @author Administrator
 */
public class RecordManager {


//RMS是否打开
boolean isOpen = false;
public RecordStore rs;

/**
     * 打开RMS，分别可以传入index和data
     * index存储主键、RecordId
     * data存储数据
     * @param rsName
     */
public void open(String rsName) {
try {
            rs = RecordStore.openRecordStore(rsName, true, RecordStore.AUTHMODE_ANY, true);
        } catch (RecordStoreException ex) {//存储系统异常
            System.out.print(ex);
        } catch (IllegalArgumentException ex) {//参数错误异常
            System.out.println(ex);
        }
    }

/**
     * 关闭RMS
     */
public void close() {
try {
            rs.closeRecordStore();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

/**
     * 添加一条记录，并返回添加的记录ID
     * @param rsName
     * @param data
     * @return
     */
public int add(String rsName, byte[] data) {
int recordId = 0;
        open(rsName);
try {
            recordId = rs.addRecord(data, 0, data.length);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
return recordId;
    }

/**
     * 通过key获取记录ID
     * @param rsName
     * @param key
     * @return
     * @throws java.io.IOException
     */
public int getRecordId(String rsName, String key) throws IOException {
int recordId = 0;
try {
            open(rsName);

            IndexEntry index = new IndexEntry();
int total = rs.getNumRecords();
byte[] data;
for (int i = 0; i < total; i++) {
                data = rs.getRecord(i + 1);

                ByteArrayInputStream bais = new ByteArrayInputStream(data, 0, data.length);
                DataInputStream dis = new DataInputStream(bais);

//获取recordId,key
                index.ReadKey(dis);
if (key.equals(index.key)) {//如果读取的key和传入的key相同，跳出循环
                    recordId = index.recordId;
                    dis.close();
                    bais.close();
break;
                }
            }
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        }
        close();
return recordId;
    }

/**
     * 通过key获取记录
     * @param rsName
     * @param key
     * @return
     * @throws java.io.IOException
     */
public byte[] get(String rsName, String key) throws IOException {
        open(rsName);
byte[] data = null;
int recordId = getRecordId(StoreHandler.INDEX_RS, key);
        data = get(rsName, recordId);
        close();
return data;
    }

/**
     * 通过记录ID获取记录
     * @param rsName
     * @param recordId
     * @return
     */
public byte[] get(String rsName, int recordId) {
        open(rsName);
byte[] data = null;
try {
            data = rs.getRecord(recordId);
        } catch (RecordStoreException ex) {
            ex.printStackTrace();
        }
        close();
return data;
    }
}

IStore接口：

package com.org.sunny.rms;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
/**
 *
 * @author Administrator
 */
public interface IStore {

    String getKey();

//存入数据
void SaveData(DataOutputStream output) throws IOException;

//获取数据
void ReadData(DataInputStream input) throws IOException;
}

IndexEntry类：

package com.org.sunny.rms;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

/**
 *
 * @author Administrator
 */
public class IndexEntry {

public int selfId;
public int recordId;
public String key;

public void SaveKey(DataOutputStream output) throws IOException {
//注意这里output是按照顺序来写的，取出来的时候也安装这种顺序来读
//这样就能解决一条数据有多列，而又不必去可以添加分隔符
        output.writeInt(recordId);
        output.writeUTF(key);
    }

public void ReadKey(DataInputStream input) throws IOException {
        recordId = input.readInt();
        key = input.readUTF();
    }
}

User类：

package com.org.sunny.rms;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

/**
 *
 * @author Administrator
 */
public class User implements IStore {

int id;
    String name;
    String sex;
int age;
    String city;
    String description;

public String getKey() {
//由于从服务器获取数据时，每条数据都有一个相应的int类型的主键ID（这个是唯一的）
//所以我在构造key时根据：类+数据库的主键ID
//这样不仅能够确保唯一性，而且从key中我就能够知道这条数据的含义
return "user.info" + id;
    }

//存入数据
public void SaveData(DataOutputStream output) throws IOException {
//注意这里output是按照顺序来写的，取出来的时候也安装这种顺序来读
//这样就能解决一条数据有多列，而又不必去可以添加分隔符
        output.writeUTF(name);
        output.writeUTF(sex);
        output.writeInt(age);
        output.writeUTF(city);
        output.writeUTF(description);

    }

//取出数据
public void ReadData(DataInputStream input) throws IOException {
        name = input.readUTF();
        sex = input.readUTF();
        age = input.readInt();
        city = input.readUTF();
        description = input.readUTF();
    }
}

StoreHandler类（很关键的一个类）：

package com.org.sunny.rms;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

/**
 *
 * @author Administrator
 */
public class StoreHandler {

    RecordManager rm = new RecordManager();
public static final String INDEX_RS = "index";
public static final String DATA_RS = "data";

/**
     * 存入数据对应的key
     * @param index
     */
public void StoreIndex(IndexEntry index) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);

//写入key
        index.SaveKey(dos);

byte[] key = baos.toByteArray();

        String keyName = new String(key);
        System.out.println("keyName" + keyName);

        dos.close();
        baos.close();

        rm.add(INDEX_RS, key);
    }

/**
     * 存入数据
     * @param store
     * @throws java.io.IOException
     */
public void StoreData(IStore store) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);
//写入数据
        store.SaveData(dos);

byte[] data = baos.toByteArray();

int recordId = rm.add(DATA_RS, data);

        IndexEntry index = new IndexEntry();
        index.recordId = recordId;
        index.key = store.getKey();

//关闭流
        dos.close();
        baos.close();

//存入唯一的key
        StoreIndex(index);

    }

/**
     * 读取数据
     * @param store
     * @throws java.io.IOException
     */
public IStore LoadData(IStore store) throws IOException {
byte[] data = rm.get(DATA_RS, store.getKey());

        ByteArrayInputStream bais = new ByteArrayInputStream(data, 0, data.length);
        DataInputStream dis = new DataInputStream(bais);

//给Store类的各个属性赋值
        store.ReadData(dis);

//关闭流
        dis.close();
        bais.close();

return store;


    }

}

下面是我进行测试的界面和结果：
一个SaveForm，一个ReadForm。

转载于:https://www.cnblogs.com/psunny/archive/2009/12/23/1630993.html