Go语言视频零基础入门到精通

javalearner

在J2ME中，RMS作为唯一的永久性存储工具，其重要性是不言而喻的。但是很多刚刚开始学习J2ME的...

J2ME中RMS的使用解析

      在J2ME中，RMS作为唯一的永久性存储工具，其重要性是不言而喻的。但是很多刚刚开始学习J2ME的新人总是抱怨在这方面的资料很少，或者是针对性不强。因此，我想把自己在这方面的一些学习心得和大家交流一下。

      RMS即Record Manager System，在手机应用中常常作为得分记录、游戏信息存储等的工具使用。
  
RMS的使用可以分为两个部分：
一、单一记录的构造；
                                                                                    
二、RecordStore的使用和操作。
   
  
  
   下面就这两方面进行详细说明。

一、单一记录的构造。
     我们在存储记录时可能需要记录很多相似的条目，在这里我们可以把这种结构看成数据库，我们在这一步就是要构造数据库中的一行，即单一记录的构造。程序的源码如下：
package com.cuilichen.usual;

1. import java.io.ByteArrayInputStream;//要使用到的各种输入输出流
   
2. import java.io.ByteArrayOutputStream;
   
3. import java.io.DataInputStream;
   
4. import java.io.DataOutputStream;
   
5. public class Appointment {//单一记录的类名
   
6. private int int1; //
   
7. private int int2; //
   
8. private long long1;
   
9. private String str1; //str1作为保留字段，记录检索的关键字
   
10. private String str2; //
    
11. private String str3; //
    
12. private boolean WroteFlag; //
    
13. 
    
14. public Appointment() {
    
15. }
16. 
    
17. public Appointment(int _int1,int _int2,long _long1,String _str1,String _str2,String _str3,boolean _WroteFlag){
    
18.   this.int1 = _int1; //写入RMS的构造函数
    
19.   this.int2 = _int2;
    
20.   this.long1 = _long1;
    
21.   this.str1 = _str1;
    
22.   this.str2 = _str2;
    
23.   this.str3 = _str3;
    
24.   this.WroteFlag = _WroteFlag;
    
25. }
    
26. public Appointment(byte[] rec) {
    
27.   initAppointmnet(rec); //读取RMS内容的构造函数
    
28. }
    
29. public byte[] toBytes() { //写成字节
    
30. byte[] data = null;
    
31. try {
    
32.   ByteArrayOutputStream baos = new ByteArrayOutputStream();
    
33.   DataOutputStream dos = new DataOutputStream(baos);
    
34.   dos.writeInt(int1);
    
35.   dos.writeInt(int2);
    
36.   dos.writeLong(long1);
    
37.   dos.writeUTF(str1);
    
38.   dos.writeUTF(str2);
    
39.   dos.writeUTF(str3);
    
40.   dos.writeBoolean(WroteFlag);
    
41.   data = baos.toByteArray();
    
42.   baos.close();
    
43.   dos.close();
    
44. } catch (Exception e) {
    
45.   e.printStackTrace();
    
46. }
    
47.   return data;
    
48. }
    
49. public void initAppointmnet(byte[] rec) { //从字节读取内容
    
50.   ByteArrayInputStream bais = new ByteArrayInputStream(rec);
    
51.   DataInputStream dis = new DataInputStream(bais);
    
52.   try {
    
53.    int1 = dis.readInt();
    
54.    int2 = dis.readInt();
    
55.    long1 = dis.readLong();
    
56.    str1 = dis.readUTF();
    
57.    str2 = dis.readUTF();
    
58.    str3 = dis.readUTF();
    
59.    WroteFlag = dis.readBoolean();
    
60. } catch (Exception e) {
    
61.    e.printStackTrace();
    
62. }
    
63. }
    
64. public int getInt1() { //int
    
65.   return int1;
    
66. }
    
67. public int getInt2() {
    
68.   return int2;
    
69. }
    
70. public long getLong1() {
    
71.   return long1;
    
72. }
    
73. public String getStr1() { //String
    
74.   return str1;
    
75. }
    
76. public String getStr2() { //String
    
77.   return str2;
    
78. }
    
79. public String getStr3() {
    
80.   return str3;
    
81. }
    
82. public boolean getWroteFlag() { //返回写入标志
    
83.   return WroteFlag;
    
84. }
    
85. }
    

复制代码

??????????     这个类的使用保证了我们在使用流时，内容的写入和输出。当然，就如同数据库表的设计一样，我们可以任意对每一条记录增加或减少字段，在上面的类中我只使用了int1，int2，long1，str1，str2，str3和WroteFlag一共7个字段。 二、RecordStore的操作。
类RMS如下：
package com.cuilichen.usual;

1. import javax.microedition.rms.RecordEnumeration;
   
2. import javax.microedition.rms.RecordStore;
   
3. public class RMS {
   
4. public static final int Int1 = 0;//各个字段的默认数值
   
5. public static final int Int2 = 0;
   
6. public static final long Long1 = 0;
   
7. public static final String Str1 = "";
   
8. public static final String Str2 = "";
   
9. public static final String Str3 = "";
   
10. public static boolean addRecord(String name, int int1, int int2,//添加记录
    
11.   long long1, String str1, String str2, String str3, boolean b) {
    
12.   boolean success = false;
    
13.   try {
    
14.    RecordStore rs = RecordStore.openRecordStore(name, true);
    
15.    Appointment app = new Appointment(int1, int2, long1, str1, str2,str3, b);
    
16.      
    
17.    byte[] data = app.toBytes();
    
18.    rs.addRecord(data, 0, data.length);
    
19.    rs.closeRecordStore();
    
20.    success = true;
    
21.   } catch (Exception e) {
    
22.     e.printStackTrace();
    
23.    }
    
24.    return success;
    
25. }
    
26. public static int getNumOfRecords(String name) {//得到RMS中记录的条数
    
27.   try {
    
28.    RecordStore rs = RecordStore.openRecordStore(name, true);
    
29.    return rs.getNumRecords();
    
30.   } catch (Exception e) {
    
31.    return 0;
    
32.   }
    
33. }
    
34. public static Appointment[] getRecords(String name) {//取得RMS中的所有记录
    
35.   Appointment[] result = { };
    
36.   try {
    
37.    RecordStore rs = RecordStore.openRecordStore(name, false);
    
38.    RecordEnumeration re = rs.enumerateRecords(null, null, false);
    
39.    result = new Appointment[rs.getNumRecords()];
    
40.    for (int i = 0; i < result.length; i++) {
    
41.     int j = re.previousRecordId();
    
42.     Appointment app = new Appointment(rs.getRecord(j));
    
43.     result[i] = app;
    
44.   }
    
45.    rs.closeRecordStore();
    
46.   }catch (Exception e) {
    
47.   }
    
48.   return result;
    
49. }
    
50. public static Appointment getRecord(String name, int j) {//根据记录编号（参数 int j）取得一条记录
    
51.   Appointment result = new Appointment();
    
52.   try {
    
53.    RecordStore rs = RecordStore.openRecordStore(name, false);
    
54.    RecordEnumeration re = rs.enumerateRecords(null, null, false);
    
55.    result = new Appointment(rs.getRecord(j));
    
56.    rs.closeRecordStore();
    
57.   } catch (Exception e) {
    
58.   }
    
59.   return result;
    
60. }
    
61. public static int getIndex(String name, String content) {//得到记录号int j，这里需要使用保留字段str1
    
62. RecordStore rs = null;
    
63. RecordEnumeration re = null;
    
64. try {
    
65.   rs = RecordStore.openRecordStore(name, false); //open
    
66.   re = rs.enumerateRecords(null, null, false); //enumeration
    
67.   for (int i = 0; i < RMS.getNumOfRecords(name); i++) {
    
68.    int j = re.nextRecordId();
    
69.    Appointment app = new Appointment(rs.getRecord(j));
    
70.    if (app.getStr1().equals(content)) {
    
71.      return j;
    
72.    }
    
73.   }
    
74. }catch (Exception e) {
    
75. }
    
76. return 1;
    
77. }
    
78. public static boolean setRecord(String name, int id, int int1, int int2,//设置记录号为id的记录
    
79.   long long1, String str1, String str2, String str3, boolean b) {
    
80.   boolean success = false;
    
81.   RecordStore rs = null;
    
82.   RecordEnumeration re = null;
    
83.   try {
    
84.    rs = RecordStore.openRecordStore(name, false); //open
    
85.    re = rs.enumerateRecords(null, null, false); //enumeration
    
86.    Appointment app = new Appointment(int1, int2, long1, str1, str2, str3, b);
    
87.    byte[] data = app.toBytes();
    
88.    rs.setRecord(id, data, 0, data.length);
    
89.    success = true;
    
90.    rs.closeRecordStore();
    
91.   } catch (Exception e) {
    
92.   }
    
93.   return success;
    
94. }
    
95. }
    

复制代码

   在这个类中，我没有将各个Exception向外抛出，一般来说这样作是不合适的，它违背了java的异常处理机制。但是在我使用这个类的各个J2ME程序中，它是可以胜任的，所以也就没有进行进一步的修改。
  
    有了以上的两个类和你对RMS的理解，在程序中，你就可以顺畅的使用RMS了, 比如在MIDlet开始时，
如下操作（增加记录）：

protected void startApp() throws MIDletStateChangeException {
    if (RMS.getNumOfRecords(rsName) = = 0) {//rsName在前面已经声明了。String rsName＝“MyRMS”；
     for (int i = 0; i <6; i++) {
      RMS.addRecord(rsName, RMS.Int1, i, RMS.Long1, Integer.toString(i), RMS.Str2, "1234567890123456789",false);
     }
   }

它就在RMS中增加了6条记录，其中int1，long1，str2，WroteFlag都没有使用，我们只是使用int2，str1（作为保留字段）和str3。
}
其他的操作也类似，完全可以依靠RMS类实现。今天就介绍这么多，有不明白的地方可以联系我 admin@andyliu.cn

  
   
     
     
      
      

        
      

        
      
     
   

  
  


源码下载：http://203.93.208.26/kj/cwb/dir7/RMS.zip