J2ME中RMS的使用解析

在J2ME中，RMS作为唯一的永久性存储工具，其重要性是不言而喻的。但是很多刚刚开始学习J2ME的新人总是抱怨在这方面的资料很少，或者是针对性不强。因此，我想把自己在这方面的一些学习心得和大家交流一下。
RMS即Record Manager System，在手机应用中常常作为得分记录、游戏信息存储等的工具使用。
RMS的使用可以分为两个部分：一、单一记录的构造；二、RecordStore的使用和操作。下面就这两方面进行详细说明。
一、单一记录的构造。我们在存储记录时可能需要记录很多相似的条目，在这里我们可以把这种结构看成数据库，我们在这一步就是要构造数据库中的一行，即单一记录的构造。程序的源码如下：

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

 

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

1. package com.cuilichen.usual;
3. import javax.microedition.rms.RecordEnumeration;
4. import javax.microedition.rms.RecordStore;
7. public class RMS {
8. public static final int Int1 = 0;//各个字段的默认数值
9. public static final int Int2 = 0;
10. public static final long Long1 = 0;
11. public static final String Str1 = "";
12. public static final String Str2 = "";
13. public static final String Str3 = "";
15. public static boolean addRecord(String name, int int1, int int2,//添加记录
16. long long1, String str1, String str2, String str3, boolean b) {
17. boolean success = false;
19. try {
20. RecordStore rs = RecordStore.openRecordStore(name, true);
21. Appointment app = new Appointment(int1, int2, long1, str1, str2,str3, b);
22. //既然str1作为保留字段，我们在这里就要如此操作：例如int1为我们设定的关键字，那么str1 = Integer.toString(int1);
23. byte[] data = app.toBytes();
24. rs.addRecord(data, 0, data.length);
25. rs.closeRecordStore();
26. success = true;
27. } catch (Exception e) {
28. e.printStackTrace();
29. }
31. return success;
32. }
34. public static int getNumOfRecords(String name) {//得到RMS中记录的条数
35. try {
36. RecordStore rs = RecordStore.openRecordStore(name, true);
38. return rs.getNumRecords();
39. } catch (Exception e) {
40. return 0;
41. }
42. }
44. public static Appointment[] getRecords(String name) {//取得RMS中的所有记录
45. Appointment[] result = { };
47. try {
48. RecordStore rs = RecordStore.openRecordStore(name, false);
49. RecordEnumeration re = rs.enumerateRecords(null, null, false);
50. result = new Appointment[rs.getNumRecords()];
52. for (int i = 0; i < result.length; i++) {
53. int j = re.previousRecordId();
54. Appointment app = new Appointment(rs.getRecord(j));
55. result[i] = app;
57. //System.out.println("app["+i+"] "+app.getStr2());
58. }
60. rs.closeRecordStore();
61. } catch (Exception e) {
62. }
64. return result;
65. }
67. public static Appointment getRecord(String name, int j) {//根据记录编号（参数 int j）取得一条记录
68. Appointment result = new Appointment();
70. try {
71. RecordStore rs = RecordStore.openRecordStore(name, false);
72. RecordEnumeration re = rs.enumerateRecords(null, null, false);
73. result = new Appointment(rs.getRecord(j));
74. rs.closeRecordStore();
75. } catch (Exception e) {
76. }
78. return result;
79. }
81. public static int getIndex(String name, String content) {//得到记录号int j，这里需要使用保留字段str1
82. RecordStore rs = null;
83. RecordEnumeration re = null;
85. try {
86. rs = RecordStore.openRecordStore(name, false); //open
87. re = rs.enumerateRecords(null, null, false); //enumeration
89. for (int i = 0; i < RMS.getNumOfRecords(name); i++) {
90. int j = re.nextRecordId();
91. Appointment app = new Appointment(rs.getRecord(j));
93. if (app.getStr1().equals(content)) {
94. return j;
95. }
96. }
97. } catch (Exception e) {
98. }
100. return 1;
101. }
103. public static boolean setRecord(String name, int id, int int1, int int2,//设置记录号为id的记录
104. long long1, String str1, String str2, String str3, boolean b) {
105. boolean success = false;
106. RecordStore rs = null;
107. RecordEnumeration re = null;
109. try {
110. rs = RecordStore.openRecordStore(name, false); //open
111. re = rs.enumerateRecords(null, null, false); //enumeration
113. Appointment app = new Appointment(int1, int2, long1, str1, str2, str3, b);
114. //str1作为保留字段，在这里如此操作：例如若int1为我们设定的关键字，那么str1 = Integer.toString(int1);
116. byte[] data = app.toBytes();
117. rs.setRecord(id, data, 0, data.length);
118. success = true;
119. rs.closeRecordStore();
120. } catch (Exception e) {
121. }
123. return success;
124. }
125. }

 

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

1. protected void startApp() throws MIDletStateChangeException {
2. if (RMS.getNumOfRecords(rsName) = = 0) {//rsName在前面已经声明了。String rsName＝“MyRMS”；
3. for (int i = 0; i <6; i++) {
4. RMS.addRecord(rsName, RMS.Int1, i, RMS.Long1, Integer . toString(i), RMS.Str2, "1234567890123456789",false);
5. }
6. }它就在RMS中增加了6条记录，其中int1，long1，str2，WroteFlag都没有使用，我们只是使用int2，str1（作为保留字段）和str3。
7. }

 

其他的操作也类似，完全可以依靠RMS类实现。
今天就介绍这么多，有不明白的地方可以联系我
MSN：cuilichen@hotmail.com