JAVAME的RMS通用持久化框架 - 千里冰封 - BlogJava

JAVAME的RMS通用持久化框架

在写JAVAME程序的时候，我们经常需要保存一些数据到手机里面，也经常希望能把对象也保存到手机里面，但是JAVAME里面没有反射机制，也没有java.io.Serializable接口，所以没有序列化的机制，要保存对象的话，就得自己动手了。
在JAVAME中，程序的数据保存的地方，无外乎两种，一种是把数据保存在RMS里面，这是所有的JAVAME的手机都支持的，还有一种就是把数据保存在手机的文件系统里面，这个不是所有手机都能支持的，只有支持JSR075的手机，才支持把数据保存在文件系统里面，并且如果你的程序没有经过签名的话，你每次保存或者读取，手机都会弹出恼人的提示，是否允许程序访问文件系统。所在我一般都是把数据存在RMS里面，因为读写RMS是安全的，并且也是不需要手机提示的。因为我们的RMS数据是存在一个特殊的地方。但是JAVAME的RMS功能非常底层，为了保存一些数据，我们必须和byte[]打交道，所以我就产生了，在此之前封装一层自己的程序的想法，这样封装好以后，使用起来就非常方便了。只要实现了相关接口，就可以享受到比较易用的方法了。

此框架总共包括了四个类，分别如下：
Serializable类，它是一个接口，类似于JAVASE里面的Serializable接口，唯一不同的就是，JAVASE里面的接口是一个空接口，只做标记用的，而这里的这个接口是有方法需要实现的。
Lazy类，它也是一个接口，它定义了一些方法，如果你的对象比较大，需要惰性加载的时候，可以实现此接口，并且此接口是Serializable接口的子类，也就是说实现了Lazy接口，你就相当于实现了Serializable接口。
RMSUtil类，此类是一个工具类，用于统一进行RMS的相关操作，也是此框架的核心类。
RecordFetcher类，也是一个接口，它继承了RecordComparator, RecordFilter接口，在取数据的时候，需要用到它。

好了，下面我们就开始看代码吧。

 1 /*
 2  * To change this template, choose Tools | Templates
 3  * and open the template in the editor.
 4  */
 5 package com.hadeslee.mobile.rms;
 6 
 7 import java.io.IOException;
 8 
 9 /**
10  * 一个可自己串行化的类所要实现的接口
11  * @author hadeslee
12  */
13 public interface Serializable {
14 
15     /**
16      * 把自己编码成字节数组的格式
17      * @return 字节数组
18      */
19     public byte[] serialize() throws IOException;
20 
21     /**
22      * 把一个对象用此字节数组进行重装
23      * @param data 字节数组
24      */
25     public void unSerialize(byte[] data) throws IOException;
26 
27     /**
28      * 设置此对象序列化后对应的存储对象的ID
29      * @param id ID
30      */
31     public void setId(int id);
32 
33     /**
34      * 得到此对象序列化后的ID
35      * 此方法唯有在反序列化后的对象上调用才有效
36      * 如果一个对象是没有序列化的,那么它的ID是-1;
37      * @return ID
38      */
39     public int getId();
40 }
41 

 1 /*
 2  * To change this template, choose Tools | Templates
 3  * and open the template in the editor.
 4  */
 5 package com.hadeslee.mobile.rms;
 6 
 7 import java.io.IOException;
 8 
 9 /**
10  * 可以延迟加载的对象必须要实现的接口
11  * @author binfeng.li
12  */
13 public interface Lazy extends Serializable {
14 
15     /**
16      * 实现此接口的类要实现的方法
17      * 可以用于延迟加载某些属性。比如
18      * get("ImgData"),get("fullImage")..等等
19      * 由于J2ME不支持注释也不支持反射，所以只能以
20      * 此种方法来进行模拟了
21      * 此方法是RMSUtil要存对象的时候调用的，这样就可以把
22      * 一个对象的不同部份存到不同的RMS里面去了
23      * @param key 要得到的某性的键
24      * @return 其对应的值
25      * @throws IOException 
26      */
27     public byte[] getAttach(Object key)throws IOException;
28 
29     /**
30      * 当把某个附属的对象保存进去以后，所要调用的
31      * 方法，此方法告诉主体，它的那个附件被保存后
32      * 在RMS里面对应的ID是多少
33      * @param key
34      * @param id
35      */
36     public void savedAttach(Object key, int id);
37 
38     /**
39      * 得到此对象所支持的所有的key的数组
40      * @return KEY的数组，不能为NULL
41      */
42     public Object[] getAttachKeys();
43 
44     /**
45      * 此对象的附属对象所存的RMS的名字
46      * @return RMS的名字
47      */
48     public String getNameOfAttachRMS();
49 }
50 

 1 /*
 2  * To change this template, choose Tools | Templates
 3  * and open the template in the editor.
 4  */
 5 package com.hadeslee.mobile.rms;
 6 
 7 import javax.microedition.rms.RecordComparator;
 8 import javax.microedition.rms.RecordFilter;
 9 
10 /**
11  * 此类是一个继承了两个接口的接口，并且添加了自己
12  * 的方法，自己的方法是用于通知数量以及开始取的位置
13  * 只是为了方便于传递参数以及以后扩展
14  * @author binfeng.li
15  */
16 public interface RecordFetcher extends RecordComparator, RecordFilter {
17 
18     /**
19      * 从哪个下标开始取
20      * @return 下标
21      */
22     public int getFromIndex();
23 
24     /**
25      * 最多取多少条记录
26      * @return 记录
27      */
28     public int getMaxRecordSize();
29 }
30 

  1 /*
  2  * To change this template, choose Tools | Templates
  3  * and open the template in the editor.
  4  */
  5 package com.hadeslee.mobile.rms;
  6 
  7 import com.hadeslee.mobile.log.LogManager;
  8 import java.util.Enumeration;
  9 import java.util.Hashtable;
 10 import java.util.Vector;
 11 import javax.microedition.rms.RecordEnumeration;
 12 import javax.microedition.rms.RecordStore;
 13 import javax.microedition.rms.RecordStoreException;
 14 
 15 /**
 16  * 一个专门用来操作RMS的工具类，通过这个类
 17  * 可以把RMS封装起来，上层调用就更方便了
 18  * @author binfeng.li
 19  */
 20 public class RMSUtil {
 21 
 22     /**
 23      * 用于缓存生命周期之内的所有的RecordStore的表,当MIDlet要退出的
 24      * 时候，调用此类的关闭方法，使RMS正确地被关闭
 25      */
 26     private static Hashtable rmsCache = new Hashtable();
 27 
 28     private RMSUtil() {
 29     }
 30 
 31     /**
 32      * 插入一个对象到一个RMS的数据库里面，如果此数据库不存在
 33      * 则自动创建一个对于MIDlet私有的数据库。如果存在，则直接
 34      * 插在此数据库的最后面
 35      * @param ser 要插入的数据,必须是实现了Serializable接口的类
 36      * @return 是否插入成功
 37      */
 38     public static boolean insertObject(Serializable ser) {
 39         RecordStore rs = null;
 40         try {
 41             rs = getRecordStore(ser.getClass().getName());
 42             if (ser instanceof Lazy) {
 43                 Lazy lazy = (Lazy) ser;
 44                 insertAttachDatas(lazy);
 45             }
 46             byte[] data = ser.serialize();
 47             int id = rs.addRecord(data, 0, data.length);
 48             ser.setId(id);
 49             return true;
 50         } catch (Exception exe) {
 51             exe.printStackTrace();
 52             LogManager.error("RMSUtil.insertObject(),ser = " + ser + ",exe = " + exe);
 53             return false;
 54         }
 55     }
 56 
 57     /**
 58      * 更新某个对象到RMS里面去,
 59      * @param ser 要更新的对象
 60      * @return 是否成功
 61      */
 62     public static boolean updateObject(Serializable ser) {
 63         RecordStore rs = null;
 64         try {
 65             rs = getRecordStore(ser.getClass().getName());
 66             byte[] data = ser.serialize();
 67             rs.setRecord(ser.getId(), data, 0, data.length);
 68             return true;
 69         } catch (Exception exe) {
 70             exe.printStackTrace();
 71             LogManager.error("RMSUtil.updateObject(),ser = " + ser + ",exe = " + exe);
 72             return false;
 73         }
 74     }
 75 
 76     /**
 77      * 从RMS里面删除某个对象
 78      * @param ser 要删除的对象
 79      * @return 是否成功
 80      */
 81     public static boolean deleteObject(Serializable ser) {
 82         if (ser.getId() == -1) {
 83             return false;
 84         }
 85         RecordStore rs = null;
 86         try {
 87             rs = getRecordStore(ser.getClass().getName());
 88             int id = ser.getId();
 89             rs.deleteRecord(id);
 90             ser.setId(-1);
 91             return true;
 92         } catch (Exception exe) {
 93             exe.printStackTrace();
 94             LogManager.error("RMSUtil.deleteObject(),ser = " + ser + ",exe = " + exe);
 95             return false;
 96         }
 97     }
 98 
 99     /**
100      * 从某个数据库里面读取某个对象
101      * @param id 此对象的ID
102      * @param clz 对应的类
103      * @return 此对象，如果发生任何异常，则返回null
104      */
105     public static Serializable readObject(int id, Class clz) {
106         RecordStore rs = null;
107         try {
108             rs = getRecordStore(clz.getName());
109             byte[] data = rs.getRecord(id);
110             Serializable ser = (Serializable) clz.newInstance();
111             ser.unSerialize(data);
112             ser.setId(id);
113             return ser;
114         } catch (Exception exe) {
115             //如果读取对象失败，则可能是有东西被删了或者版本不一样，此时就应该删掉
116             exe.printStackTrace();
117             LogManager.error("RMSUtil.readObject(),id = " + id + ",Class = " + clz + ",exe= " + exe);
118             if (rs != null) {
119                 try {
120                     rs.deleteRecord(id);
121                 } catch (Exception ex) {
122                     ex.printStackTrace();
123                     LogManager.error("RMSUtil.readObject$rs.deleteRecord(id),id = " + id + ",exe = " + ex);
124                 }
125             }
126             return null;
127         }
128     }
129 
130     /**
131      * 得到某个类存在RMS里面的总数，这样便于分段取
132      * @param cls 类名
133      * @return 有效记录总数
134      */
135     public static int getStoreSize(Class cls) {
136         try {
137             RecordStore rs = getRecordStore(cls.getName());
138             return rs.getNumRecords();
139         } catch (Exception exe) {
140             exe.printStackTrace();
141             LogManager.error("RMSUtil.getStoreSize(),Class = " + cls + ",exe = " + exe);
142             return -1;
143         }
144     }
145 
146     /**
147      * 列出某个类的对象的集合，最多取多少个对象
148      * @param cls 类名
149      * @param from 从第几个开始取
150      * @param maxSize 最多取多少个对象
151      * @return 取到的列表
152      */
153     public static Vector listObjects(Class cls, int from, int maxSize) {
154         System.out.println("class="+cls);
155         if (from < 0 || maxSize < 1) {
156             throw new IllegalArgumentException("from can not less than 0 and maxSize must greater than 0");
157         }
158         Vector v = new Vector();
159         RecordEnumeration ren = null;
160         try {
161             RecordStore rs = getRecordStore(cls.getName());
162             ren = rs.enumerateRecords(null, null, false);
163             fetchRecord(v, cls, ren, from, maxSize);
164         } catch (Exception exe) {
165             LogManager.error("RMSUtil.listObjects(),Class = " + cls + ",from = " + from + ",maxSize = " + maxSize + ",exe = " + exe);
166             exe.printStackTrace();
167         } finally {
168             ren.destroy();
169         }
170         return v;
171     }
172 
173     /**
174      * 用于前面一个方法和后面一个方法的共用方法，
175      * 它用来从特定的记录枚举里面去取特定的记录，
176      * 并放到特定的地方
177      * @param v 要保存的地方
178      * @param cls 要实例化的类
179      * @param ren 记录的枚举
180      * @param from 从哪里开始取
181      * @param maxSize 要取多少条记录
182      * @throws java.lang.Exception 可能会抛出的异常
183      */
184     private static void fetchRecord(Vector v, Class cls, RecordEnumeration ren, int from, int maxSize) throws Exception {
185         int index = 0;
186         int size = 0;
187         while (ren.hasNextElement()) {
188             int id = ren.nextRecordId();
189             if (index >= from) {
190                 if (size < maxSize) {
191                     Serializable ser = readObject(id, cls);
192                     if (ser != null) {
193                         v.addElement(ser);
194                         size++;
195                     }
196                 } else {
197                     break;
198                 }
199             }
200             index++;
201         }
202     }
203 
204     /**
205      * 列出某个类的对象，并用一种过滤以及排序的方法来进行过滤或者排序
206      * @param cls 类名
207      * @param fetcher 取记录的方法
208      * @return 记录列表
209      */
210     public static Vector listObjects(Class cls, RecordFetcher fetcher) {
211         System.out.println("fetcher class="+cls);
212         int from = fetcher.getFromIndex();
213         int maxSize = fetcher.getMaxRecordSize();
214         if (from < 0 || maxSize < 1) {
215             throw new IllegalArgumentException("from can not less than 0 and maxSize must greater than 0");
216         }
217         Vector v = new Vector();
218         RecordEnumeration ren = null;
219         try {
220             RecordStore rs = getRecordStore(cls.getName());
221             ren = rs.enumerateRecords(fetcher, fetcher, false);
222             fetchRecord(v, cls, ren, from, maxSize);
223         } catch (Exception exe) {
224             LogManager.error("RMSUtil.listObjects(),Class = " + cls + ",exe = " + exe);
225             exe.printStackTrace();
226         } finally {
227             ren.destroy();
228         }
229         return v;
230     }
231 
232     /**
233      * 插入某个可延迟加载的对象的所有附件到数据库里面去
234      * 插入完成后，此lazy对象将变得很完整，因为此时它的
235      * 附件对象的ID都已经设置好了
236      * @param lazy 要插入附件的主对象
237      * @return 是否插入成功
238      */
239     private static boolean insertAttachDatas(Lazy lazy) {
240         try {
241             Object[] attachKeys = lazy.getAttachKeys();
242             RecordStore rs = getRecordStore(lazy.getNameOfAttachRMS());
243             for (int i = 0; i < attachKeys.length; i++) {
244                 Object key = attachKeys[i];
245                 byte[] data = lazy.getAttach(key);
246                 int id = rs.addRecord(data, 0, data.length);
247                 lazy.savedAttach(key, id);
248             }
249             return true;
250         } catch (Exception exe) {
251             exe.printStackTrace();
252             LogManager.error("RMSUtil.insertAttachDatas(),Lazy = " + lazy + ",exe = " + exe);
253             return false;
254         }
255     }
256 
257     /**
258      * 得到某个可以延迟加载的对象的某个附件的字节数组内容
259      * TODO 如果能把此方法变成私有，那就更好了
260      * 此方法是专门供lazy对象调用的，这样的话，实体类里面就出现了
261      * 读取数据的方法，但是由于J2ME不支持反射，只能这样实现了
262      * @param lazy 可以延迟加载的对象
263      * @param id 附件的ID
264      * @return 对应的数组
265      */
266     public static byte[] getAttachData(Lazy lazy, int id) {
267         try {
268             return getRecordStore(lazy.getNameOfAttachRMS()).getRecord(id);
269         } catch (Exception exe) {
270             exe.printStackTrace();
271             LogManager.error("RMSUtil.getAttachData(),Lazy = " + lazy + ",id = " + id + ",exe = " + exe);
272             return null;
273         }
274     }
275 
276     /**
277      * 更新某个对象的附件
278      * TODO 如果能把此方法变成私有就更好了
279      * @param lazy 可延迟加载的对象
280      * @param id 附件的ID
281      * @param data 附件的内容
282      * @return 是否成功
283      */
284     public static boolean updateAttachData(Lazy lazy, int id, byte[] data) {
285         try {
286             RecordStore rs = getRecordStore(lazy.getNameOfAttachRMS());
287             rs.setRecord(id, data, 0, data.length);
288             return true;
289         } catch (Exception exe) {
290             exe.printStackTrace();
291             LogManager.error("RMSUtil.updateAttachData(),Lazy = " + lazy + ",exe = " + exe);
292             return false;
293         }
294     }
295 
296     /**
297      * 从附件数据库中删除某个附件
298      * @param lazy 主对象
299      * @param id 附件的ID
300      * @return 是否删除成功
301      */
302     public static boolean deleteAttachData(Lazy lazy, int id) {
303         try {
304             RecordStore rs = getRecordStore(lazy.getNameOfAttachRMS());
305             rs.deleteRecord(id);
306             return true;
307         } catch (Exception exe) {
308             exe.printStackTrace();
309             LogManager.error("RMSUtil.deleteAttachData(),Lazy = " + lazy + ",id = " + id + ",exe = " + exe);
310             return false;
311         }
312     }
313 
314     /**
315      * 关闭所有的RMS
316      */
317     public static void closeAllRMS() {
318         Enumeration en = rmsCache.elements();
319         while (en.hasMoreElements()) {
320             RecordStore rs = (RecordStore) en.nextElement();
321             closeRecordStore(rs);
322         }
323         rmsCache.clear();
324     }
325 
326     public static void deleteRecord(Class cls, int id) {
327         deleteRecord(cls.getName(), id);
328     }
329 
330     /**
331      * 删除某个仓库里面的某条记录
332      * @param rsName 仓库的名字
333      * @param id 记录的ID
334      */
335     public static void deleteRecord(String rsName, int id) {
336         try {
337             RecordStore rs = RecordStore.openRecordStore(rsName, false);
338             if (rs != null) {
339                 rs.deleteRecord(id);
340             }
341             rs.closeRecordStore();
342         } catch (Exception exe) {
343         }
344     }
345 
346     /**
347      * 一个简单的方法用于关闭RecordStore
348      * @param rs 要关闭的RecordStore
349      */
350     private static void closeRecordStore(RecordStore rs) {
351         try {
352             rs.closeRecordStore();
353         } catch (Exception exe) {
354             LogManager.error("RMSUtil.closeRecordStore(),rs = " + rs + ",exe = " + exe);
355             exe.printStackTrace();
356         }
357     }
358 
359     /**
360      * 得到某个RMS的存储数据库,先从缓存里面去找，如果没有找到则生成
361      * 一个并把它放到缓存里面,还有，因为RMS的名字，最长只支持32位
362      * @param name 数据库的名字
363      * @return 找到的RMS数据库
364      */
365     private synchronized static RecordStore getRecordStore(String name) throws RecordStoreException {
366         if (name.length() > 32) {
367             name = name.substring(name.length()-32, name.length());
368         }
369         if (rmsCache.containsKey(name)) {
370             return (RecordStore) rmsCache.get(name);
371         } else {
372             RecordStore rs = RecordStore.openRecordStore(name, true);
373             rmsCache.put(name, rs);
374             return rs;
375         }
376     }
377 }
378 

相信看完代码以后，大家应该知道如何使用它吧。如果有需要持久化的类，那么就需要实现Serializable接口，然后只要调用RMSUtil.insertObject()就可以了，同理，查找也是一样的，你可以查找同一个类的一系列对象，也可以自己定义记录查询器，在里面设置查询条件。
目前JAVAME的持久化框架，也有用其它的方法实现的，比如动态插入代码的方法，也就是你在写好了JAVAME的代码以后，在编译的过程中，它自动帮你加上相应的方法，我看了一个他们的源码，其实也就是它们自己帮你实现了一个相当于Serializable接口，我觉得这样不好的地方在于，它会为你的类添加方法，万一你的类里面原来就有那个方法的时候，那就会出现不可意料的情况了，还有，我觉得自己的数据还是自己一个一个把它写出来，这样心里更踏实一些。我一直都认为，封装得有一个度，不能过度的封装，过度封装表面上看是编码更方便了，但是写的时候，自己心里也更没底了，因为你不知道别人的代码都做了一些什么。因为别人的代码做的事情太多了。呵呵，纯属个人意见。
大家如果有什么自己的看法，欢迎留言。
还有，此代码用到了我的另外一个通用框架，那就是LOG框架，所以如果直接下载的话，可能会编译不过了，只要注释掉LogManager的调用就可以了。LOG框架的说明点击这里，这个LOG框架现在正在改动中，以使它更好用，更没有侵入性。

Netbeans项目工程打包下载，请点击这里。此工程中还有LOG框架在里面。