两个小时精通Android开发之数据持久存储篇

xiaofei006

笔者在前面的两篇文章《
两个小时精通Android开发之界面篇
》、《
两个小时精通Android开发之按键映射篇
》分别讲了无缝移植J2ME程序到Android平台上对界面和用户按键交互所做的适配接口，原则上利用这些接口原有的J2ME程序基本不用做任何的修改就可以运行在Android平台上，所以精通J2ME也就等于精通了Android。

笔者这篇文章里要讲述的是J2ME平台和Android平台另外一个重要的不同点，那就是数据持久存储系统。

J2ME平台里采用RMS系统进行数据的持久存储，而Android平台则提供了丰富的接口进行数据的持久存储，但任何持久存储的本质无非就是数据串行化后被保存到磁盘空间上，仔细研究J2ME平台RMS系统的实现源码可以看到，J2ME是通过一个叫做RecordStoreFile的类进行数据持久化存储的，而这个RecordStoreFile类的实现如下：

public class RecordStoreFile {
   private static SecurityToken classSecurityToken;
    private static final String dbExtension = ".db";
    private RandomAccessStream recordStream;
    private String myStoragePath;

    public static void initSecurityToken(SecurityToken token) {
    if (classSecurityToken != null) {
        return;
    }
    classSecurityToken = token;
    }

    public RecordStoreFile(String uidPath)
    throws IOException
    {
    RandomAccessStream newStream;
    myStoragePath = uidPath;

    newStream = new RandomAccessStream(classSecurityToken);
    newStream.connect(myStoragePath, Connector.READ_WRITE);
    recordStream = newStream;
    }

    public static String getUniqueIdPath(String fileName) {
    return getStoragePath(fileName);
    }
   
    public static String getUniqueIdPath(String vendorName, String suiteName,
                     String fileName) {
    return getStoragePath(vendorName, suiteName, fileName);
    }

    public static boolean exists(String uidPath) {
    File file;
    file = new File(classSecurityToken);
    return file.exists(uidPath);
    }

   
    public static boolean deleteFile(String uidPath)
    {
    File file;
    file = new File(classSecurityToken);
    try {
        file.delete(uidPath);
        return true;
    } catch (IOException ioe) {
        return false;
    }
    }
   
    public void seek(int pos) throws IOException
    {
    recordStream.setPosition(pos);
    }

    public void write(byte[] buf) throws IOException
    {
    write(buf, 0, buf.length);
    }
  
    public void write(byte[] buf, int offset, int numBytes) throws IOException
    {
    recordStream.writeBytes(buf, offset, numBytes);
    }
   
    public int read(byte[] buf) throws IOException
    {
    return read(buf, 0, buf.length);
    }

    public int read(byte[] buf, int offset, int numBytes) throws IOException
    {
    return recordStream.readBytes(buf, offset, numBytes);
    }
  
    public void close() throws IOException
    {
    // close recordStream if it exists
    if (recordStream != null) {
        recordStream.disconnect();
        recordStream = null;
    }
    }

    public void truncate(int size) throws IOException
    {
    if (recordStream != null) {   
        recordStream.truncate(size);
    }   
    }

    public static String[] listRecordStores() {
        return listRecordStoresForSuite(new File(classSecurityToken),
            getStoragePath(null), false);
    }

    private static String[] listRecordStoresForSuite(File storage,
                                                     String suiteStorageRoot,
                                                     boolean rawNames) {
    Vector files;
    Vector names;
    String file;
    String asciiName;
   
    files = storage.filenamesThatStartWith(suiteStorageRoot);
    names = new Vector();
   
    // work through list of strings from the directory
    for (int i = 0; i
        file = (String)files.elementAt(i);
        if (file.endsWith(dbExtension)) {
                if (rawNames) {
                    names.addElement(file);
                } else {
                    asciiName = file.substring(suiteStorageRoot.length(),
                       file.length() - 3);
                    names.addElement(File.asciiFilenameToUnicode(asciiName));
                }
        }
    }

    if (names.size() == 0) {
        return null;
    }
   
    String[] rv = new String[names.size()];
    names.copyInto(rv);
    return rv;
    }
   
    public static void removeRecordStoresForSuite(SecurityToken token,
            String suiteStorageRoot) {

        File storage;
    String[] filenames;
   
    storage = new File(token);
        filenames = listRecordStoresForSuite(storage, suiteStorageRoot, true);
        if (filenames == null) {
            return;
        }

        for (int i = 0; i
            try {
                storage.delete(filenames);
            } catch (IOException ioe) {
                // move on to the next suite
            }
        }
    }
   
    public static boolean suiteHasRmsData(String suiteStorageRoot) {
    File storage = new File(classSecurityToken);
    Vector files = storage.filenamesThatStartWith(suiteStorageRoot);

    for (int i = 0; i
        String file = (String)files.elementAt(i);
        if (file.endsWith(dbExtension)) {
                return true;
            }
        }

        return false;
    }

    public static int spaceAvailable()
    {
    return new File(classSecurityToken).getBytesAvailableForFiles();
    }

    private static String getStoragePath(String name)
    {
    String str;
    MIDletSuite mSuite;
    StringBuffer path;
   
    mSuite = Scheduler.getScheduler().getMIDletSuite();
   
    str = mSuite.getStorageRoot();
    if (name != null) {
        path = new StringBuffer(str);
        // convert the unicode filename into a system acceptable string
        path.append(File.unicodeToAsciiFilename(name));
        path.append(dbExtension);
        str = path.toString();
    }
    return str;
    }
    private static String getStoragePath(String vendor, String suite,
                     String name) {
    String str = File.getStorageRoot();
    StringBuffer path = new StringBuffer(str);
    if (vendor != null && suite != null) {
        path.append(File.unicodeToAsciiFilename(vendor));
        path.append('_');
        path.append(File.unicodeToAsciiFilename(suite));
        path.append('_');
    }
    if (name != null) {
        path.append(File.unicodeToAsciiFilename(name));
        path.append(dbExtension);
        str = path.toString();
    }
    return str;
    }
}

可见，RMS系统也是通过IO把数据串行化后存储应用程序的空间内的，绝大多数的J2ME程序都需要利用RMS来进行数据的持久存储的，比如游戏积分、系统设置等。那么为了无缝移植J2ME到Android平台，笔者自己写了一个简易的RMS系统，能满足绝大多数应用程序的需要。

Android下对文件的操作和J2ME基本一样，但是需要绑定一个Context上下文，以把文件保存到当前应用程序的目录下，这个目录在打开DDMS窗口后可以看到，具体位置是data/data/PACKAGE_NAME/files下面。

利用文件操作可以进行数据的读写，笔者封装的接口如下：

    public static boolean deleteFile(String fileName){      
        File file = new File(fileName);      
        if(file.isFile() && file.exists()){      
            file.delete();      
            System.out.println("删除单个文件"+fileName+"成功！");      
            return true;      
        }else{      
            System.out.println("删除单个文件"+fileName+"失败！");      
            return false;      
        }      
    }      

     public String read(String file) {
         String data = "";
         try {
              FileInputStream stream = System.getSystemHandler().getContext().openFileInput(file);
              StringBuffer sb = new StringBuffer();
              int c;
              while ((c = stream.read()) != -1) {
                   sb.append((char) c);
              }
              stream.close();
              data = sb.toString();

         } catch (FileNotFoundException e) {
              e.printStackTrace();
         } catch (IOException e) {
              e.printStackTrace();
         }
         return data;
     }

     public void write(String file, byte[] msg) {
         try {
              FileOutputStream stream = System.getSystemHandler().getContext().openFileOutput(file,Context.MODE_WORLD_WRITEABLE);
              stream.write(msg);
              stream.flush();
              stream.close();
         } catch (FileNotFoundException e) {
              e.printStackTrace();
         } catch (IOException e) {
              e.printStackTrace();
         }
     }

有了基本的读写数据操作，就可以封装RMS中常见的key-value的保存和读取了，代码实现如下：

public boolean put(String key, byte[] value) {
         boolean bSaveOk = false;
         byte[] data = null;
         if (value == null) {
              throw new NullPointerException();
         }
         ByteArrayOutputStream bout = null;
         DataOutputStream dout = null;
         try {
              bout = new ByteArrayOutputStream();
              dout = new DataOutputStream(bout);
              dout.writeUTF(key);
              dout.writeInt(value.length);
              dout.write(value, 0, value.length);
              data = bout.toByteArray();

              write(dbName,data);         
              bSaveOk = true;
         } catch (Exception e) {
              bSaveOk = false;
              e.printStackTrace();
         }
         
         return bSaveOk;
     }

     public byte[] getByteArray(String key) {
         ByteArrayInputStream bin = null;
         DataInputStream din = null;
         byte[] data = null;        
         try {
                   String valueKey = read(dbName);
                   din = new DataInputStream(new ByteArrayInputStream(valueKey.getBytes()));

                   while(din.available() > 0)
                   {
                       String getKey = din.readUTF();
                       int getLength = din.readInt();
     
                       data = new byte[getLength];
                       int bytesRead = 0;
                       while (bytesRead
                            int count = din.read(data, bytesRead, data.length
                                     - bytesRead);
                            if (count == -1)
                                 break;
                            bytesRead += count;
                       }
                       
                       if(getKey.equals(key))
                            break;
                   }
                                 
                   din.close();
                   din = null;
         } catch (Exception e) {
              e.printStackTrace();
              data = null;
         }
         return data;
     }
}
               
               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u2/88379/showart_2151738.html