Android Realm詳解

xuw 8年前發布 | 23K 次閱讀 Realm 安卓開發 Android開發移動開發

介紹

Realm 是一個 MVCC （多版本并發控制）數據庫，由Y Combinator公司在2014年7月發布一款支持運行在手機、平板和可穿戴設備上的嵌入式數據庫，目標是取代SQLite。

Realm 本質上是一個嵌入式數據庫，他并不是基于SQLite所構建的。它擁有自己的數據庫存儲引擎，可以高效且快速地完成數據庫的構建操作。和SQLite不同，它允許你在持久層直接和數據對象工作。在它之上是一個函數式風格的查詢api，眾多的努力讓它比傳統的SQLite 操作更快。

優勢

如果在在使用它時候，連它的優勢在哪都不知道的話就有點說不過去了。

易用
Ream 不是在SQLite基礎上的ORM，它有自己的數據查詢引擎。并且十分容易使用。
快速
由于它是完全重新開始開發的數據庫實現，所以它比任何的ORM速度都快很多，甚至比SLite速度都要快。
跨平臺
Realm 支持 iOS & OS X (Objective?C & Swift) & Android。我們可以在這些平臺上共享Realm數據庫文件，并且上層邏輯可以不用任何改動的情況下實現移植。
高級
Ream支持加密，格式化查詢，易于移植，支持JSON，流式api，數據變更通知等高級特性
可視化
Realm 還提供了一個輕量級的數據庫查看工具，在Mac Appstore 可以下載“Realm Browser”這個工具，開發者可以查看數據庫當中的內容，執行簡單的插入和刪除數據的操作。（windows上還不清楚）

條件

目前不支持 Android 以外的 Java
Android Studio >= 1.5.1
較新的Android SDK版本
JDK version >=7.
支持API 9(Android 2.3)以及之后的版本

使用

不介紹了，看代碼了。

加入依賴
在 project 的 build
中加入依賴
```
buildscript {
  repositories {
      jcenter()
  }
  dependencies {
      classpath "io.realm:realm-gradle-plugin:2.2.1"
  }
}
```
project/build
在 module
中加入
```
apply plugin: 'realm-android'
```
module/build

Realm從v1.0.0后，不支持Ecilpse，我們推薦使用Android Studio

創建model

創建一個 User 類，需要繼承 RealmObject 。支持public, protected和 private的類以及方法

public class User extends RealmObject {
    private String name;
    private int age;

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

}</code></pre> 
  
除直接繼承于 RealmObject 來聲明 Realm 數據模型之外，還可以通過實現 RealmModel 接口并添加 @RealmClass 修飾符來聲明。 
  @RealmClass
public class User implements RealmModel {
    ...
} 
   
   支持的屬性
 boolean , byte , short , int , long , float , double , String , Date 和， byte[] , RealmObject , RealmList<? extends RealmObject>
 還支持 Boolean , Byte , Short , Integer , Long , Float 和 Double
 Tip ：整數類型 short 、 int 和 long 都被映射到 Realm 內的相同類型（實際上為 long ） 
   @PrimaryKey ——表示該字段是主鍵
 使用過數據庫的同學應該看出來了， PrimaryKey 就是主鍵。使用 @PrimaryKey 來標注，字段類型必須是字符串（ String ）或整數（ byte ， short ， int 或 long ）以及它們的包裝類型（ Byte , Short , Integer , 或 Long ）。不可以存在多個主鍵，使用字符串字段作為主鍵意味著字段被索引（注釋 @PrimaryKey 隱式地設置注釋 @Index ）。 @PrimaryKey
private String id;
  
   @Required ——表示該字段非空
 在某些情況下，有一些屬性是不能為 null 的。使用 @Required 可用于用于強行要求其屬性不能為空，只能用于 Boolean , Byte , Short , Integer , Long , Float , Double , String , byte[] 和 Date 。在其它類型屬性上使用 @Required 修飾會導致編譯失敗。
 Tip ：基本數據類型不需要使用注解 @Required ，因為他們本身就不可為空。 @Required
private String name;
  
   @Ignore ——表示忽略該字段
 被添加 @Ignore 標簽后，存儲數據時會忽略該字段。 @Ignore
private String name;
  
   @Index ——添加搜索索引
 為字段添加搜索索引，這樣會使得插入的速度變慢，數據量也變得更大。不過在查詢速度將變得更快，建議只在優化讀取性能的特定情況時添加索引。支持索引： String ， byte ， short ， int ， long ， boolean 和 Date 字段。
 ``` 
   
  注意：如果你創建后又修改了Model，那么就相當于你修改了表結構，那么就需要升級數據庫。升級方式后面會提到 
  初始化 
  使用默認配置 
  Realm.init(this);
        Realm mRealm = Realm.getDefaultInstance(); 
  這時候會創建一個叫做 default.realm 的Realm文件，一般來說，這個文件位于/data/data/包名/files/。通過 realm.getPath() 來獲得該Realm的絕對路徑。 
  注意：模擬器上運行時， Realm.getDefaultInstance() 拋出異常，真機上沒問題（不止何故） 
  當然，我們還可以使用 RealmConfiguration 來配置Realm 
  RealmConfiguration config = new RealmConfiguration.Builder() 
            .name("myrealm.realm") //文件名
            .schemaVersion(0) 
            .build();
Realm realm = Realm.getInstance(config); 
  創建非持久化的Realm，也就是保持在內存中，應用關閉后就清除了。 
  RealmConfiguration myConfig = new RealmConfiguration.Builder(context) 
            .name("myrealm.realm")
            .inMemory() .build(); 
  RealmConfiguration 支持的方法： 
   
   Builder.name : 指定數據庫的名稱。如不指定默認名為default。 
   Builder.schemaVersion : 指定數據庫的版本號。 
   Builder.encryptionKey : 指定數據庫的密鑰。 
   Builder.migration : 指定遷移操作的遷移類。 
   Builder.deleteRealmIfMigrationNeeded : 聲明版本沖突時自動刪除原數據庫。 
   Builder.inMemory : 聲明數據庫只在內存中持久化。 
   build : 完成配置構建。 
   
  關閉Realm 
  記得使用完后，在 onDestroy 中關閉Realm 
  @Override 
protected void onDestroy() { 
    super.onDestroy();
    // Close the Realm instance. 
    realm.close(); 
} 
  增 
  寫入操作需要在事務中進行，可以使用 executeTransaction 方法來開啟事務。 
   
   使用 executeTransaction 方法插入數據 mRealm.executeTransaction(new Realm.Transaction() {
         @Override
         public void execute(Realm realm) {
             User user = realm.createObject(User.class);
             user.setName("Gavin");
             user.setAge(23);
         }
     });
 在 execute 方法中執行插入操作 注意：如果在UI線程中插入過多的數據，可能會導致主線程擁塞。
  
   
   
    使用 copyToRealmOrUpdate 或 copyToRealm 方法插入數據
 當Model中存在 主鍵 的時候，推薦使用 copyToRealmOrUpdate 方法插入數據。如果對象存在，就更新該對象；反之，它會創建一個新的對象。若該Model沒有主鍵，使用 copyToRealm 方法，否則將拋出異常。
 final User user = new User();
      user.setName("Jack");
      user.setId("2");
      mRealm.executeTransaction(new Realm.Transaction() {
          @Override
          public void execute(Realm realm) {
              realm.copyToRealmOrUpdate(user);
          }
      });
  
   
   
   如果你用的是這樣的 modle public class User2 extends RealmObject {
   public String name;
   public int age;
}
 就這樣寫 mRealm.executeTransaction(new Realm.Transaction() {
         @Override
         public void execute(Realm realm) {
             User2 user = realm.createObject(User2.class);
             user.name = "Micheal";
             user.age = 30;
         }
     });
  
    如果User還用其他屬性是，比如養了只 Dog ：
 public class Dog extends RealmObject {
   private String name;
   private int age;
   //getters and setters
}
 對應的User屬性中加入 Dog 類
 public class User extends RealmObject {
   private String name;
   private int age;
   private Dog dog;
   //getters and setters
}
 如果你養了不止一只，你養了二哈、阿拉撕家...那你就要用到 RealmList 了。在 User 中加入該屬性
 private RealmList<Dog> dogs;
 插入數據
 @Override
 public void execute(Realm realm) {
     User user = realm.createObject(User.class);
     user.setName("Gain");
     user.setAge(23);

 Dog dog1 = realm.createObject(Dog.class);
 dog1.setAge(1);
 dog1.setName("二哈");
 user.getDogs().add(dog1);

 Dog dog2 = realm.createObject(Dog.class);
 dog2.setAge(2);
 dog2.setName("阿拉撕家");
 user.getDogs().add(dog2);

}
});</code></pre> </li> 
   
 上面都是用可 executeTransaction 方法插入數據，還有另一種方法可以用于插入數據—— beginTransaction 和 commitTransaction
 mRealm.beginTransaction();//開啟事務
User user = mRealm.createObject(User.class);
user.setName("Gavin");
user.setId("3");
mRealm.commitTransaction();//提交事務
 在插入前，先調用 beginTransaction() ，完成后調用 commitTransaction() 即可。
 注意：在UI和后臺線程同時開啟創建write的事務，可能會導致ANR錯誤。為了避免該問題，可以使用 executeTransactionAsync 來實現。
  
    使用 executeTransactionAsync
 該方法會開啟一個子線程來執行事務，并且在執行完成后進行結果通知。
 RealmAsyncTask transaction = mRealm.executeTransactionAsync(new Realm.Transaction() {
 @Override
 public void execute(Realm realm) {
     User user = realm.createObject(User.class);
     user.setName("Eric");
     user.setId("4");
   }
});
 還可以加入監聽
 RealmAsyncTask transaction =  mRealm.executeTransactionAsync(new Realm.Transaction() {
 @Override
 public void execute(Realm realm) {
     User user = realm.createObject(User.class);
     user.setName("Eric");
     user.setId("4");
   }
}, new Realm.Transaction.OnSuccess() {
 @Override
 public void onSuccess() {
     //成功回調
   }
}, new Realm.Transaction.OnError() {
 @Override
 public void onError(Throwable error) {
     //失敗回調
   }
});
 注意：如果當 Acitivity 或 Fragment 被銷毀時，在 OnSuccess 或 OnError 中執行UI操作，將導致程序奔潰 。用 RealmAsyncTask .cancel(); 可以取消事務
 在 onStop 中調用，避免crash
 public void onStop () {
 if (transaction != null && !transaction.isCancelled()) {
     transaction.cancel();
   }
}
  
  </ul> 
   
    JSON
 Realm還是個很nice的功能就是將Json字符串轉化為對象，厲害了我的Realm
 （直接借用官方的例子）
 // 一個city model
public class City extends RealmObject {
  private String city;
  private int id;
  // getters and setters left out ...
}
// 使用Json字符串插入數據
realm.executeTransaction(new Realm.Transaction() {
  @Override
  public void execute(Realm realm) {
      realm.createObjectFromJson(City.class, "{ city: \"Copenhagen\", id: 1 }");
  }
});
// 使用InputStream插入數據
realm.executeTransaction(new Realm.Transaction() {
  @Override
  public void execute(Realm realm) {
      try {
          InputStream is = new FileInputStream(new File("path_to_file"));
          realm.createAllFromJson(City.class, is);
      } catch (IOException e) {
          throw new RuntimeException();
      }
  }
});
 Realm 解析 JSON 時遵循如下規則： 
     
     使用包含空值（null）的 JSON 創建對象： 
     對于非必須（可為空值的屬性），設置其值為 null； 
     對于必須（不可為空值的屬性），拋出異常； 
     使用包含空值（null）的 JSON 更新對象： 
     對于非必須（可為空值的屬性），設置其值為 null； 
     對于必須（不可為空值的屬性），拋出異常； 
     使用不包含對應屬性的 JSON： * 該屬性保持不變 
     </li> 
  </ul> 
  查 
  查找操作就比插入方便多了，并不需在事務中操作，直接查詢即可。 
   
    findAll ——查詢
 例：查詢所有的 User RealmResults<User> userList = mRealm.where(User.class).findAll();
 這里使用 RealmResults 來接受查詢到的結果，突然出現的 RealmResults 可能會讓人懵逼。看看他的源碼，發現 RealmResults 繼承了 AbstractList ，而 AbstractList 又實現了 List 接口。好吧，原來實現了我們熟悉的 List 接口。
 public final class RealmResults<E extends RealmModel> extends AbstractList<E>
 public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>
  RealmResults源碼
 注意： RealmResults 雖然實現了 List 接口，不過有很多方法是不能用的。比如 add 、 addAll 、 remove 、 clear 等，調用后會直接拋異常。不過也不用當心誤用這些方法，因為它們都被標記為 @Deprecated 了。
  
   
   
    findAllAsync ——異步查詢
 當數據量較大，可能會引起ANR的時候，就可以使用 findAllAsync RealmResults<User> userList = mRealm.where(User.class)
              .equalTo("name", "Gavin")
              .findAllAsync();
 值得注意的是，這里并不會馬上查到數據，是有一定延時的。也就是說，你馬上使用 userList 的時候，里面是沒有數據的。可以注冊 RealmChangeListener 監聽器，或者使用 isLoaded() 方法，判斷是否查詢完成
 if (result.isLoaded()) {
   // 完成查詢
}
  
   
   
   findFirst ——查詢第一條數據
 例：查詢 User 表中的第一條數據 User user2 = mRealm.where(User.class).findFirst();
  
   equalTo ——根據條件查詢
 例：得到 name 為 Gavin 的用戶列表。 RealmResults<User> userList = mRealm.where(User.class)
         .equalTo("name", "Gavin").findAll();
 如果 User 中還有 Dog 屬性，希望根據 Dog 的條件來獲取用戶：
 例：查詢 dogs.name 為二哈的 User RealmResults<User> userList = mRealm.where(User.class)
          .equalTo("dogs.name", "二哈").findAll();
 得到有養有 dogs.name 為"二哈"的用戶列表（這里的 dogs 是 User 表中的屬性名） 
   equalTo ——多條件查詢
 當然，我們還經常要用到多條件的查詢的功能。
 例：找到用戶名為“Gavin”，且 dogs.name 為“二哈”的 User RealmResults<User> userList = mRealm.where(User.class)
         .equalTo("name", "Gavin").findAll();
RealmResults<User> userList = user5.where()
         .equalTo("dogs.name", "二哈").findAll();
 上面先找到 name 為“Gavin”的 User 列表，然后再得到的結果中查詢 dogs.name 為“二哈”
 覺得這樣寫太麻煩？我也是這樣想的，所以還可以這樣寫 RealmResults<User> userList = mRealm.where(User.class)
         .equalTo("name", "Gavin")
         .equalTo("dogs.name", "二哈")
         .findAll();
 是不是很清爽~~~ 
   更多查詢條件
 上面就展示了 equalTo 的用法。當然，查詢還有更多的用法，我就不一一示例了。已知的方法如下：
 sum() ：對指定字段求和。
 average() ：對指定字段求平均值。
 min() : 對指定字段求最小值。
 max() : 對指定字段求最大值。count : 求結果集的記錄數量。
 findAll() : 返回結果集所有字段，返回值為RealmResults隊列
 findAllSorted() : 排序返回結果集所有字段，返回值為RealmResults隊列
 between() , greaterThan() , lessThan() , greaterThanOrEqualTo() & lessThanOrEqualTo()
 equalTo() & notEqualTo()
 contains() , beginsWith() & endsWith()
 isNull() & isNotNull()
 isEmpty() & isNotEmpty() 
   
   
    RealmQuery 以及 or 的使用
 在使用 where() 方法時，能得到一個 RealmQuery 對象，使用方法如下：
 例：查詢 name 為“Gavin”和“Eric”的用戶
 RealmQuery<User> query = mRealm.where(User.class);
query.equalTo("name", "Gavin");
query.or().equalTo("name", "Eric");
RealmResults<User> userList = query.findAll();
 這種情況下就要用到or()方法
 這么一大串，你又覺得麻煩了？沒事，繼續簡化。
 RealmResults<User> userList = mRealm.where(User.class)
          .equalTo("name", "Gavin")
          .or().equalTo("name", "Eric")
          .findAll();
 Tip：查詢的時候你不用當心得到的 RealmResults 為 null 。如果查詢的結果為空，那么 RealmResults 的 size 為0
  
    排序
 查詢結束后，還可以進行排序，就像這樣：
 RealmResults<User> userList = mRealm.where(User.class) .findAll();
result = result.sort("age"); //根據age，正序排列
result = result.sort("age", Sort.DESCENDING);//逆序排列
  
    聚合
 RealmResult 自帶一些聚合方法：
 RealmResults<User> results = realm.where(User.class).findAll();
long   sum     = results.sum("age").longValue();
long   min     = results.min("age").longValue();
long   max     = results.max("age").longValue();
double average = results.average("age");
long   matches = results.size();
  
   
  改 
  mRealm.executeTransaction(new Realm.Transaction() {
    @Override
    public void execute(Realm realm) {
        //先查找后得到User對象
        User user = mRealm.where(User.class).findFirst();
        user.setAge(26);
    }
}); 
  修改也是需要在事務中操作。 
  使用查詢語句得到數據，然后將內容改了即可。 
  刪 
   
   使用 deleteFromRealm() //先查找到數據
final RealmResults<User> userList = mRealm.where(User.class).findAll();
mRealm.executeTransaction(new Realm.Transaction() {
  @Override
  public void execute(Realm realm) {
      userList.get(0).deleteFromRealm();
  }
});
  
   使用 deleteFromRealm(int index) mRealm.executeTransaction(new Realm.Transaction() {
  @Override
  public void execute(Realm realm) {
      userList.deleteFromRealm(0);
  }
});
  
   更多方法： userList.deleteFirstFromRealm(); //刪除user表的第一條數據
userList.deleteLastFromRealm();//刪除user表的最后一條數據
results.deleteAllFromRealm();//刪除user表的全部數據
  
   
  版本升級 
  當數據結構發生變化是，需要升級數據庫。對于Realm來說，數據庫升級就是遷移操作，把原來的數據庫遷移到新結構的數據庫。（體驗：略麻煩） 
   
   例1： User 類發生變化，移除 age ，新增個 @Required 的 id 字段。
 User 版本：version 0 String name;
int    age;
 User 版本：version 1 @Required
String    id;
String name;
 創建遷移類 CustomMigration ，需要實現 RealmMigration 接口。執行版本升級時的處理： /**

升級數據庫
*/
class CustomMigration implements RealmMigration {
 @Override
 public void migrate(DynamicRealm realm, long oldVersion, long newVersion) {

 RealmSchema schema = realm.getSchema();
 if (oldVersion == 0 && newVersion == 1) {
     RealmObjectSchema personSchema = schema.get("User");
     //新增@Required的id
     personSchema
             .addField("id", String.class, FieldAttribute.REQUIRED)
             .transform(new RealmObjectSchema.Function() {
                 @Override
                 public void apply(DynamicReal

mObject obj) {

                     obj.set("id", "1");//為id設置值
                 }
             })
             .removeField("age");//移除age屬性
     oldVersion++;
 }

}
}</code></pre> 使用 Builder.migration 升級數據庫，將版本號改為1（原版本號：0）。當Realm發現新舊版本號不一致時，會自動使用該遷移類完成遷移操作。 
RealmConfiguration config = new RealmConfiguration.Builder()

 .name("myrealm.realm") //文件名
 .schemaVersion(1) 
 .migration(new CustomMigration())//升級數據庫
 .build();</code></pre> </li> 

 例2：加入 Dog 類， User 中加入 Dog 集合。
 User 版本：version 1
 @Required
String    id;
String name;
 User 版本：version 2
 @Required
private String id;
private String name;
private RealmList<Dog> dogs;
 Dog 類
 public class Dog extends RealmObject {
 private String name;
 private int age;
}
 在遷移類 CustomMigration 中，繼續添加處理方法。
 if (oldVersion == 1 && newVersion == 2) {

     //創建Dog表
     RealmObjectSchema dogSchema = schema.create("Dog");
     dogSchema.addField("name", String.class);
     dogSchema.addField("age", int.class);

     //User中添加dogs屬性
     schema.get("User")
             .addRealmListField("dogs", dogSchema)
             .transform(new RealmObjectSchema.Function() {
                 @Override
                 public void apply(DynamicRealmObject obj) {
                     //為已存在的數據設置dogs數據
                     DynamicRealmObject dog = realm.createObject("Dog");
                     dog.set("name", "二哈");
                     dog.set("age", 2);
                     obj.getList("dogs").add(dog);
                 }
             });
     oldVersion++;
 }</code></pre> </li> 

更多用法—— RealmObjectSchema
 例：取消id必填： personSchema.setNullable("id", true):
 例：移除id字段 personSchema.removeField("id");
 例：重命名 personSchema..renameField("id", "userId");
  
更多用法—— DynamicRealmObject
 例：獲取id String id = obj.getString("id");
 例：為字段設置值 obj.setString("name", "Gavin");
obj.setInt("id", 1);
obj.setLong("id", 1);
 疑問：我在debug時發現這樣的數據，如圖：
  userList
 什么，dogs、id、name的值怎么都是null？這~~
 開始我還以為升級時數據丟失，不過在圖中userList第0條數據的右邊看到了我的數據，于是我展開了里面的內容，如圖：
  展開后的userListg
 好吧，他并不是我想象中的那種存法，我已經不知道他內部是怎么實現的了。（還望大神賜教）
  
</ul> 
加密

（官方原文） 
Realm 文件可以通過傳遞一個512位（64字節）的密鑰參數給 Realm.getInstance().encryptionKey() 來加密存儲在磁盤上。 
byte[] key = new byte[64];
new SecureRandom().nextBytes(key);
RealmConfiguration config = new RealmConfiguration.Builder()
.encryptionKey(key)
.build();
Realm realm = Realm.getInstance(config); 
保證了所有永久性存儲在磁盤上的數據都是通過標準 AES-256 加密的。每次創建新的 Realm 實例的時候，都需要提供相同的密鑰。 
適配器（Adapter） 
（官方原文） 
Realm提供了一些抽象的工具類來方便地將 OrderedRealmCollection 
（ RealmResults 和 RealmList 都實現了這個借口）展示到UI控件上。 
 
RealmBaseAdapter 可以與 ListView 配合使用。 
RealmRecyclerViewAdapter 可以與 RecyclerView 配合使用。 
 
你需要在 app 的 build.gradle 中添加額外的依賴以使用這些適配器。 
dependencies {
compile 'io.realm:android-adapters:1.4.0'
} 
Intents 
（官方原文） 
你不可以直接通過 intent 傳遞 RealmObject ，建議你只傳遞 RealmObject 的標識符。舉個常用例子，假如你的對象擁有一個主鍵，請通過 intent 的 bundle 來傳遞這個主鍵的值。 
// Assuming we had a person class with a @PrimaryKey on the 'id' field ...
Intent intent = new Intent(getActivity(), ReceivingService.class);
intent.putExtra("person_id", person.getId());
getActivity().startService(intent); 
在接受方（ Activity 、 Service 、 IntentService 、 BroadcastReceiver 及其它）從 bundle 中解析出這個主鍵然后打開 Realm 查詢得到這個 RealmObject 。 
// in onCreate(), onHandleIntent(), etc.
String personId = intent.getStringExtra("person_id");
Realm realm = Realm.getDefaultInstance();
Person person = realm.where(Person.class).equalTo("id", personId).findFirst();// do something with the person ...
realm.close(); 
RxJava 
對于這么火的RxJava，Realm又怎么會放過他。 
Realm 包含了對 RxJava 的原生支持。如下類可以被暴露為一個 Observable ： Realm , RealmResults , RealmObject , DynamicRealm 和 DynamicRealmObject 。 
（直接用一個官方的例子） 
Realm realm = Realm.getDefaultInstance();
GitHubService api = retrofit.create(GitHubService.class);
realm.where(Person.class).isNotNull("username").findAllAsync().asObservable()
.filter(persons.isLoaded)
.flatMap(persons -> Observable.from(persons))
.flatMap(person -> api.user(person.getGithubUserName())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(user -> showUser(user)); 
這里使用 asObservable 輕松轉換成RxJava中的 Observable ，使用 .filter(persons.isLoaded) 來判斷是否已查詢完成。到這里，熟悉RxJava的同學應該已經看明白了~~。可能還有人會一臉懵逼， -> ? 這是什么鬼？哈哈，這叫Lambda，有時間可以去看看。 
終于寫完了~~~沒想到內容居然這么多，說好的易用呢？ 
參考資料 
官方文檔 
GitHub 
Realm for Android快速入門教程 
Android開發筆記（八十五）手機數據庫Realm 
在Android加入和使用Realm 
Android 進階之第三方庫的介紹 Realm [一] 基礎用法 
  
  
來自：http://www.jianshu.com/p/37af717761cc


                    
                         本文由用戶 xuw 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。
                         轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。
                         本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！
                         本文地址：http://www.baiduhome.net/lib/view/open1481511217179.html
                         Realm 安卓開發 Android開發 移動開發

Android Realm詳解

介紹

優勢

條件

使用

創建model

初始化

關閉Realm

增

查

改

刪

版本升級

加密

適配器（Adapter）

Intents

RxJava

參考資料

相關經驗

相關資訊

相關文檔

目錄