打造自己的RMS框架（三）_rms框架项目-CSDN博客

本文链接：https://blog.csdn.net/pjw100/article/details/5065820

本文介绍了一种针对J2ME平台RMS（Record Management System）的改进方案，通过引入String作为主键，提高了记录检索的灵活性。文中详细阐述了实现原理并提供了核心代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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;


    }

}