Android Realm数据库完美解析

转自   http://blog.csdn.net/fesdgasdgasdg/article/details/51897212
demo http://download.csdn.net/detail/fesdgasdgasdg/9591679
当我们的app有数据需要保存到本地缓存时，可以使用file，sharedpreferences，还有sqlite。
sharedpreferences其实使用xml的方式，以键值对形式存储基本数据类型的数据。对于有复杂筛选查询的
操作，file和sharedpreferences都不能满足了。sqlite可以满足有大量复杂查询要求的缓存数据操作。但是sqlite的使用略复杂，代码量很大，还好网上有很多优秀的orm框架可使用，比喻ORMlite，greenDao等。


ORMlite，greenDao这些框架都是在SQLite的基础上封装的ORM对象关系映射框架，简化了代码操作。
而今天的主角：Realm是一个可以替代SQLite以及ORM Libraries的轻量级数据库。

相比SQLite，Realm更快并且具有很多现代数据库的特性，比如支持JSON，流式api，数据变更通知，以及加密支持，这些都为安卓开发者带来了方便。不多介绍，更详细的介绍参见官网：https://realm.io/

我们重点来说说Reaml的使用，看看到底爽在哪里。

环境配置：

1、在Project的build.gradle文件中添加依赖：

[html] view plain copy

print ?

1. dependencies {  
2.         ...  
3.         classpath "io.realm:realm-gradle-plugin:1.1.0"  
4.         ...  
5.     }  

dependencies {
        ...
        classpath "io.realm:realm-gradle-plugin:1.1.0"
        ...
    }

2、在app module的build.gradle文件的top添加下面代码：

[html] view plain copy

print ?

1. apply plugin: 'com.android.application'  
2. apply plugin: 'realm-android'  
3. ....  

apply plugin: 'com.android.application'
apply plugin: 'realm-android'
....

配置完毕。

使用：

在整个使用的过程中，Realm是主角，我们先来看看Realm类中的一段翻译：

[html] view plain copy

print ?

1. /**  
2.      * Realm类可以对你的持久化对象进行存储和事务管理，可以用来创建RealmObjects实例。领域内的对象可以在任何时间查询和读取。  
3.      * 创建，修改和删除等操作必须被包含在一个完整的事务里面，后面的代码会讲到。  
4.      * 该事务确保多个实例（在多个线程）可以在一个一致的状态和保证事务在ACID前提下，访问相同的对象。  
5.      *  
6.      * 当一个Realm实例操作完成后，切记不要忘记调用close()方法。否则会导致本地资源无法释放，引起OOM。  
7.      *  
8.      * Realm实例不能在不同的线程间访问操作。确切的说，你必须在每个要使用的线程上打开一个实例  
9.      * 每个线程都会使用引用计数来自动缓存Realm实例，所以只要引用计数不达到零，  
10.      *  调用getInstance(RealmConfiguration)方法将会返回缓存的Realm实例，应该算是一个轻量级的操作。  
11.      *  
12.      * 对于UI线程来说，打开和关闭Realm实例，应当放在onCreate/onDestroy或者onStart/onStop方法中  
13.      *  
14.      *  在不同的线程间，Realm实例使用Handler机制来调整他的状态。也就是说，Realm实例在线程中，如果没有Looper，是不能收到更新通知的，  
15.      *  除非手动调用waitForChange()方法  
16.      *  
17.      * 在安卓Activity领域工作的一个标准模式可以在下面看到  
18.      * 在Android Activity中，Realm的标准工作模式如下：  
19.      *  
20.      *  
21.      * public class RealmApplication extends Application {  
22.      *  
23.      *     \@Override  
24.      *     public void onCreate() {  
25.      *         super.onCreate();  
26.      *  
27.      *         // The Realm file will be located in package's "files" directory.  
28.      *         RealmConfiguration realmConfig = new RealmConfiguration.Builder(this).build();  
29.      *         Realm.setDefaultConfiguration(realmConfig);  
30.      *     }  
31.      * }  
32.      *  
33.      * public class RealmActivity extends Activity {  
34.      *  
35.      *   private Realm realm;  
36.      *  
37.      *   \@Override  
38.      *   protected void onCreate(Bundle savedInstanceState) {  
39.      *     super.onCreate(savedInstanceState);  
40.      *     setContentView(R.layout.layout_main);  
41.      *     realm = Realm.getDefaultInstance();  
42.      *   }  
43.      *  
44.      *   \@Override  
45.      *   protected void onDestroy() {  
46.      *     super.onDestroy();  
47.      *     realm.close();  
48.      *   }  
49.      * }  
50.      *  
51.      *  
52.      * Realm支持String和byte字段长度高达16MB  
53.      * 参考连接：  
54.      * <a href="http://en.wikipedia.org/wiki/ACID">ACID</a>  
55.      * <a href="https://github.com/realm/realm-java/tree/master/examples">Examples using Realm</a>  
56.      *  
57.      */  

/**
     * Realm类可以对你的持久化对象进行存储和事务管理，可以用来创建RealmObjects实例。领域内的对象可以在任何时间查询和读取。
     * 创建，修改和删除等操作必须被包含在一个完整的事务里面，后面的代码会讲到。
     * 该事务确保多个实例（在多个线程）可以在一个一致的状态和保证事务在ACID前提下，访问相同的对象。
     *
     * 当一个Realm实例操作完成后，切记不要忘记调用close()方法。否则会导致本地资源无法释放，引起OOM。
     *
     * Realm实例不能在不同的线程间访问操作。确切的说，你必须在每个要使用的线程上打开一个实例
     * 每个线程都会使用引用计数来自动缓存Realm实例，所以只要引用计数不达到零，
     *  调用getInstance(RealmConfiguration)方法将会返回缓存的Realm实例，应该算是一个轻量级的操作。
     *
     * 对于UI线程来说，打开和关闭Realm实例，应当放在onCreate/onDestroy或者onStart/onStop方法中
     *
     *  在不同的线程间，Realm实例使用Handler机制来调整他的状态。也就是说，Realm实例在线程中，如果没有Looper，是不能收到更新通知的，
     *  除非手动调用waitForChange()方法
     *
     * 在安卓Activity领域工作的一个标准模式可以在下面看到
     * 在Android Activity中，Realm的标准工作模式如下：
     *
     *
     * public class RealmApplication extends Application {
     *
     *     \@Override
     *     public void onCreate() {
     *         super.onCreate();
     *
     *         // The Realm file will be located in package's "files" directory.
     *         RealmConfiguration realmConfig = new RealmConfiguration.Builder(this).build();
     *         Realm.setDefaultConfiguration(realmConfig);
     *     }
     * }
     *
     * public class RealmActivity extends Activity {
     *
     *   private Realm realm;
     *
     *   \@Override
     *   protected void onCreate(Bundle savedInstanceState) {
     *     super.onCreate(savedInstanceState);
     *     setContentView(R.layout.layout_main);
     *     realm = Realm.getDefaultInstance();
     *   }
     *
     *   \@Override
     *   protected void onDestroy() {
     *     super.onDestroy();
     *     realm.close();
     *   }
     * }
     *
     *
     * Realm支持String和byte字段长度高达16MB
     * 参考连接：
     * <a href="http://en.wikipedia.org/wiki/ACID">ACID</a>
     * <a href="https://github.com/realm/realm-java/tree/master/examples">Examples using Realm</a>
     *
     */

部分源码分析：

[html] view plain copy

print ?

1. public final class Realm extends BaseRealm {  
2. //默认的文件名，是啥？  
3. public static final String DEFAULT_REALM_NAME = RealmConfiguration.DEFAULT_REALM_NAME;  
4.   
5.   
6. //怎么这么熟悉呢？是RxJava？  
7. @Override  
8.     @OptionalAPI(dependencies = {"rx.Observable"})  
9.     public Observable<Realm> asObservable() {  
10.         return configuration.getRxFactory().from(this);  
11.     }  
12.   
13. //下面这些方法，应该都能顾名思义吧  
14.   
15. public <E extends RealmModel> void createAllFromJson(Class<E> clazz, JSONArray json) {  
16. }  
17.   
18.   
19.     public <E extends RealmModel> void createOrUpdateAllFromJson(Class<E> clazz, JSONArray json) {  
20. }  
21.   
22.   
23.     public <E extends RealmModel> E createOrUpdateObjectFromJson(Class<E> clazz, JSONObject json) {  
24. }  
25.   
26.   
27.     public <E extends RealmModel> E createObject(Class<E> clazz) {  
28. }  
29.   
30.   
31.     public <E extends RealmModel> E copyToRealmOrUpdate(E object) {  
32. }  
33.   
34.   
35.     public void executeTransaction(Transaction transaction) {  
36. }  
37.   
38.   
39.     public void delete(Class<? extends RealmModel> clazz) {  
40. }  
41. }  

public final class Realm extends BaseRealm {
//默认的文件名，是啥？
public static final String DEFAULT_REALM_NAME = RealmConfiguration.DEFAULT_REALM_NAME;


//怎么这么熟悉呢？是RxJava？
@Override
    @OptionalAPI(dependencies = {"rx.Observable"})
    public Observable<Realm> asObservable() {
        return configuration.getRxFactory().from(this);
    }

//下面这些方法，应该都能顾名思义吧

public <E extends RealmModel> void createAllFromJson(Class<E> clazz, JSONArray json) {
}


    public <E extends RealmModel> void createOrUpdateAllFromJson(Class<E> clazz, JSONArray json) {
}


    public <E extends RealmModel> E createOrUpdateObjectFromJson(Class<E> clazz, JSONObject json) {
}


    public <E extends RealmModel> E createObject(Class<E> clazz) {
}


    public <E extends RealmModel> E copyToRealmOrUpdate(E object) {
}


    public void executeTransaction(Transaction transaction) {
}


    public void delete(Class<? extends RealmModel> clazz) {
}
}

RealmConfiguration类的说明翻译：

[html] view plain copy

print ?

1. /**  
2.  * 一个RealmConfiguration对象，可用来设置特定的Realm实例  
3.  * RealmConfiguration实例只能通过io.realm.RealmConfiguration.Builder类的build()方法来创建  
4.  * 想使用默认的RealmConfiguration实例，请使用io.realm.Realm#getDefaultInstance()方法。  
5.  * 如果想使用自己配置RealmConfiguration实例的Realm实例，需要调用Realm#setDefaultConfiguration(RealmConfiguration)  
6.  *   
7.  * <p>  
8.  * 可以用下面代码创建一个最简单配置的实例:  
9.  * RealmConfiguration config = new RealmConfiguration.Builder(getContext()).build())  
10.  * 这样创建的实例，具有一下属性：  
11.  *   
12.  * <ul>  
13.  * <li>Realm的默认文件名是"default.realm"</li>  
14.  * <li>"default.realm"文件保存在"Context.getFilesDir()"目录中</li>  
15.  * <li>它的schema版本号设置为0</li>  
16.  * </ul>  
17.  */  

/**
 * 一个RealmConfiguration对象，可用来设置特定的Realm实例
 * RealmConfiguration实例只能通过io.realm.RealmConfiguration.Builder类的build()方法来创建
 * 想使用默认的RealmConfiguration实例，请使用io.realm.Realm#getDefaultInstance()方法。
 * 如果想使用自己配置RealmConfiguration实例的Realm实例，需要调用Realm#setDefaultConfiguration(RealmConfiguration)
 * 
 * <p>
 * 可以用下面代码创建一个最简单配置的实例:
 * RealmConfiguration config = new RealmConfiguration.Builder(getContext()).build())
 * 这样创建的实例，具有一下属性：
 * 
 * <ul>
 * <li>Realm的默认文件名是"default.realm"</li>
 * <li>"default.realm"文件保存在"Context.getFilesDir()"目录中</li>
 * <li>它的schema版本号设置为0</li>
 * </ul>
 */

 
部分源码分析：

[html] view plain copy

print ?

1. public final class RealmConfiguration {  
2. //默认文件名  
3. public static final String DEFAULT_REALM_NAME = "default.realm";  
4.   
5. //Rx工厂  
6. private final RxObservableFactory rxObservableFactory;  
7.   
8. //弱引用  
9. private final WeakReference<Context> contextWeakRef;  
10.   
11. /**  
12.      *   
13.      * 从Asset目录中返回Realm文件名，还可以保存在Asset中？  
14.      * @return input stream to the asset file.  
15.      * @throws IOException if copying the file fails.  
16.      */  
17.     InputStream getAssetFile() throws IOException {  
18.         Context context = contextWeakRef.get();  
19.         if (context != null) {  
20.             return context.getAssets().open(assetFilePath);  
21.         } else {  
22.         }  
23.     }  
24.   
25. /**  
26.          * 使用app自己内置硬盘目录来存储Realm file。不需要任何扩展访问权限。  
27.          * 默认目录为：/data/data/<packagename>/files，这个路径能否修改取决于供应商的具体实现  
28.          *   
29.          * @param 参数context请使用application的context.  
30.          */  
31.         public Builder(Context context) {  
32.             if (context == null) {  
33.                 throw new IllegalArgumentException("A non-null Context must be provided");  
34.             }  
35.             RealmCore.loadLibrary(context);  
36.             initializeBuilder(context.getFilesDir());  
37.         }  
38. ｝  

public final class RealmConfiguration {
//默认文件名
public static final String DEFAULT_REALM_NAME = "default.realm";

//Rx工厂
private final RxObservableFactory rxObservableFactory;

//弱引用
private final WeakReference<Context> contextWeakRef;

/**
     * 
     * 从Asset目录中返回Realm文件名，还可以保存在Asset中？
     * @return input stream to the asset file.
     * @throws IOException if copying the file fails.
     */
    InputStream getAssetFile() throws IOException {
        Context context = contextWeakRef.get();
        if (context != null) {
            return context.getAssets().open(assetFilePath);
        } else {
        }
    }

/**
         * 使用app自己内置硬盘目录来存储Realm file。不需要任何扩展访问权限。
         * 默认目录为：/data/data/<packagename>/files，这个路径能否修改取决于供应商的具体实现
         * 
         * @param 参数context请使用application的context.
         */
        public Builder(Context context) {
            if (context == null) {
                throw new IllegalArgumentException("A non-null Context must be provided");
            }
            RealmCore.loadLibrary(context);
            initializeBuilder(context.getFilesDir());
        }
｝

通过上面的翻译说明和源码分析，应该几乎明白了Realm的原理和基本使用了吧。总结下面几点：
1、Realm保存的结果其实是在一个文件里面，默认的文件名是"default.realm"，在"Context.getFilesDir()"目录中，即：/data/data/<packagename>/files/default.realm。意思是，当你在应用管理里面给当前app"清除数据"，realm数据库的数据会丢失。故我们需要把默认的数据文件放到asset目录中，当数据库初始化时再copy到"Context.getFilesDir()"下。
2、在创建RealmConfiguration对象时，可以通过.assetFile(this,"realm file path in assets")方法指定初始化的数据库文件。Realm会把制定路径下的xxx.realm文件copy到Context.getFilesDir()目录中，以替换默认创建的空数据库文件。
3、可以设置默认文件名，通过RealmConfiguration类进行配置。路径似乎改不了，需要看具体设备供应商的实现。
4、Realm的实例需要在每次的具体操作中获取，可以看成是一个数据操作的sessin，用完后必须close关闭。
打开和关闭Realm实例，应当放在onCreate/onDestroy或者onStart/onStop方法中。
5、Realm中似乎有RxJava的影子，支持链式异步任务？
6、Realm中有个各种增删改差的方法，还可以根据JSON的数据实例化一个RealmObject子类java bean。
7、重点：切记，Realm数据库的主键字段不是自动增长的，需要自己设置，做添加的时候如果不给id字段值，默认会为0。后面再添加会报错，说id为0的数据已经存在。尤其是批量添加的时候要注意，当心出现只添加了一条记录的悲剧。
8、数据自动更新。mRealm.addChangeListener(this);//当数据库的数据有变化时，系统回调此方法。


经过上面的分析和总结，其实已经很明了了。为了那些伸手主义者，还是简单撸些代码吧。还有些需要注意的地方，在代码中讲解。




application代码：

[html] view plain copy

print ?

1. public class MyApplication extends Application {  
2.     private String realmName = "dk.realm";  
3.   
4.   
5.     @Override  
6.     public void onCreate() {  
7.         super.onCreate();  
8.   
9.   
10.         RealmConfiguration realmConfig = new RealmConfiguration.Builder(this)  
11.                 .name(realmName)  
12.                 //.assetFile(this,"realm file path in assets，will copy this file to Context.getFilesDir() replace an empty realm file")  
13.                 .build();  
14.         Realm.setDefaultConfiguration(realmConfig);  
15.     }  
16. }  

public class MyApplication extends Application {
    private String realmName = "dk.realm";


    @Override
    public void onCreate() {
        super.onCreate();


        RealmConfiguration realmConfig = new RealmConfiguration.Builder(this)
                .name(realmName)
                //.assetFile(this,"realm file path in assets，will copy this file to Context.getFilesDir() replace an empty realm file")
                .build();
        Realm.setDefaultConfiguration(realmConfig);
    }
}

java Bean:

[html] view plain copy

print ?

1. public class TestUser extends RealmObject {  
2.   
3.   
4.     @PrimaryKey  
5.     private int userId;//id,主键  
6.     @Required  
7.     private String userName;//用户姓名,必填字段  
8.     private String userPwd;//密码  
9.     private int userAge;//年龄  
10.     private String userAddress;//住址  
11.     private String userWork;//工作  
12.     private String userSex;//性别  
13.   
14.   
15.     //private RealmList<E> list;  集合  
16. //...  
17. }  

public class TestUser extends RealmObject {


    @PrimaryKey
    private int userId;//id,主键
    @Required
    private String userName;//用户姓名,必填字段
    private String userPwd;//密码
    private int userAge;//年龄
    private String userAddress;//住址
    private String userWork;//工作
    private String userSex;//性别


    //private RealmList<E> list;  集合
//...
}

BaseDao,简单封装，把基本的增删改功能提取：

[html] view plain copy

print ?

1. public class BaseDao {  
2.     private Realm realm;  
3.   
4.   
5.     public BaseDao(Realm realm) {  
6.         this.realm = realm;  
7.     }  
8.   
9.   
10.     /**  
11.      * 添加(性能优于下面的saveOrUpdate（）方法)  
12.      *  
13.      * @param object  
14.      * @return 保存或者修改是否成功  
15.      */  
16.     public boolean insert(RealmObject object) {  
17.         try {  
18.             realm.beginTransaction();  
19.             realm.insert(object);  
20.             realm.commitTransaction();  
21.             return true;  
22.         } catch (Exception e) {  
23.             e.printStackTrace();  
24.             realm.cancelTransaction();  
25.             return false;  
26.         }  
27.     }  
28. /**  
29.      * 添加(性能优于下面的saveOrUpdateBatch（）方法)  
30.      *  
31.      * @param list  
32.      * @return 批量保存是否成功  
33.      */  
34.     public boolean insert(List<? extends RealmObject> list) {  
35.         try {  
36.             realm.beginTransaction();  
37.             realm.insert(list);  
38.             realm.commitTransaction();  
39.             return true;  
40.         } catch (Exception e) {  
41.             e.printStackTrace();  
42.             realm.cancelTransaction();  
43.             return false;  
44.         }  
45.     }  
46. //...  
47. }  

public class BaseDao {
    private Realm realm;


    public BaseDao(Realm realm) {
        this.realm = realm;
    }


    /**
     * 添加(性能优于下面的saveOrUpdate（）方法)
     *
     * @param object
     * @return 保存或者修改是否成功
     */
    public boolean insert(RealmObject object) {
        try {
            realm.beginTransaction();
            realm.insert(object);
            realm.commitTransaction();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            realm.cancelTransaction();
            return false;
        }
    }
/**
     * 添加(性能优于下面的saveOrUpdateBatch（）方法)
     *
     * @param list
     * @return 批量保存是否成功
     */
    public boolean insert(List<? extends RealmObject> list) {
        try {
            realm.beginTransaction();
            realm.insert(list);
            realm.commitTransaction();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            realm.cancelTransaction();
            return false;
        }
    }
//...
}

UserDao extends BaseDao:

[html] view plain copy

print ?

1. /**  
2.      * 单条保存demo  
3.      */  
4.     public boolean addOneTest() {  
5.         boolean bl = false;  
6.         try{  
7.             realm.beginTransaction();  
8.             //在数据库中创建一个对象，主键默认值为0  
9.             TestUser user = realm.createObject(TestUser.class);//(类，主键)  
10.   
11.   
12.             //更新数据库各自段的值  
13.             user.setUserName("admin");  
14.             //主键字段的值由0更新为55。而不是直接创建了一个id为55的对象  
15.             user.setUserId(55);  
16.             //...  
17.             realm.commitTransaction();  
18.             bl = true;  
19.         }catch (Exception e){  
20.             e.printStackTrace();  
21.             realm.cancelTransaction();  
22.         }  
23.   
24.   
25.         /*try{  
26.             realm.beginTransaction();  
27.             TestUser user2 = new TestUser("hibrid", "120250", 26, "赣州", "贼", "男");  
28.             //不给id，会被默认为0  
29.             //user2.setUserId(102);  
30.             TestUser userWithId = realm.copyToRealm(user2);  
31.             realm.commitTransaction();  
32.             bl = true;  
33.         }catch (Exception e){  
34.             e.printStackTrace();  
35.             realm.cancelTransaction();  
36.         }*/  
37.         return bl;  
38.     }  
39.   
40. //init data  
41.     public boolean init() {  
42.         /**  
43.          * 此处要注意，方法最后调用的是添加或者修改的方法。  
44.          * 如果list的数据都不给id，则第一条记录添加成功后的id为0，后面的都在此基础上修改。  
45.          * 最后的效果是，数据库只有一条记录，id为0，其他字段被更新为了最后一个对象的数据  
46.          */  
47.         List<TestUser> list = new ArrayList<>();  
48.         list.add(new TestUser(0,"android", "123123", 20, "河南常德", "传菜员", "女"));  
49.         list.add(new TestUser(1,"angel", "13588889988", 21, "云南西双版纳", "飞行员", "男"));  
50.         list.add(new TestUser(2,"adidass", "110119", 28, "云南德克萨斯州", "海员", "男"));  
51.         list.add(new TestUser(3,"hijack", "250250", 39, "加州电厂", "厨师", "女"));  
52.         list.add(new TestUser(4,"hibrid", "120250", 26, "赣州", "贼", "男"));  
53.         list.add(new TestUser(5,"admin", "123456", 20, "湖北汉城", "程序员", "女"));  
54.         return saveOrUpdateBatch(list);  
55.     }  
56.   
57. /**  
58.      * 条件查询  
59.      *  
60.      * @return 返回结果集合  
61.      */  
62.     public RealmResults<TestUser> findByAnyParams(HashMap<Object, Object> params) {  
63.         //realm.where(TestUser.class)  
64.         //可跟查询条件  
65.         //.or()                      或者  
66.         //.beginsWith()              以xxx开头  
67.         //.endsWith()                以xxx结尾  
68.         //.greaterThan()             大于  
69.         //.greaterThanOrEqualTo()    大于或等于  
70.         //.lessThan()                小于  
71.         //.lessThanOrEqualTo()       小于或等于  
72.         //.equalTo()                 等于  
73.         //.notEqualTo()              不等于  
74.         //.findAll()                 查询所有  
75.         //.average()                 平均值  
76.         //.beginGroup()              开始分组  
77.         //.endGroup()                结束分组  
78.         //.between()                 在a和b之间  
79.         //.contains()                包含xxx  
80.         //.count()                   统计数量  
81.         //.distinct()                去除重复  
82.         //.findFirst()               返回结果集的第一行记录  
83.         //.isNotEmpty()              非空串  
84.         //.isEmpty()                 为空串  
85.         //.isNotNull()               非空对象  
86.         //.isNull()                  为空对象  
87.         //.max()                     最大值  
88.         //.maximumDate()             最大日期  
89.         //.min()                     最小值  
90.         //.minimumDate()             最小日期  
91.         //.sum()                     求和  
92.         return realm.where(TestUser.class).findAll();  
93.     }  

/**
     * 单条保存demo
     */
    public boolean addOneTest() {
        boolean bl = false;
        try{
            realm.beginTransaction();
            //在数据库中创建一个对象，主键默认值为0
            TestUser user = realm.createObject(TestUser.class);//(类，主键)


            //更新数据库各自段的值
            user.setUserName("admin");
            //主键字段的值由0更新为55。而不是直接创建了一个id为55的对象
            user.setUserId(55);
            //...
            realm.commitTransaction();
            bl = true;
        }catch (Exception e){
            e.printStackTrace();
            realm.cancelTransaction();
        }


        /*try{
            realm.beginTransaction();
            TestUser user2 = new TestUser("hibrid", "120250", 26, "赣州", "贼", "男");
            //不给id，会被默认为0
            //user2.setUserId(102);
            TestUser userWithId = realm.copyToRealm(user2);
            realm.commitTransaction();
            bl = true;
        }catch (Exception e){
            e.printStackTrace();
            realm.cancelTransaction();
        }*/
        return bl;
    }

//init data
    public boolean init() {
        /**
         * 此处要注意，方法最后调用的是添加或者修改的方法。
         * 如果list的数据都不给id，则第一条记录添加成功后的id为0，后面的都在此基础上修改。
         * 最后的效果是，数据库只有一条记录，id为0，其他字段被更新为了最后一个对象的数据
         */
        List<TestUser> list = new ArrayList<>();
        list.add(new TestUser(0,"android", "123123", 20, "河南常德", "传菜员", "女"));
        list.add(new TestUser(1,"angel", "13588889988", 21, "云南西双版纳", "飞行员", "男"));
        list.add(new TestUser(2,"adidass", "110119", 28, "云南德克萨斯州", "海员", "男"));
        list.add(new TestUser(3,"hijack", "250250", 39, "加州电厂", "厨师", "女"));
        list.add(new TestUser(4,"hibrid", "120250", 26, "赣州", "贼", "男"));
        list.add(new TestUser(5,"admin", "123456", 20, "湖北汉城", "程序员", "女"));
        return saveOrUpdateBatch(list);
    }

/**
     * 条件查询
     *
     * @return 返回结果集合
     */
    public RealmResults<TestUser> findByAnyParams(HashMap<Object, Object> params) {
        //realm.where(TestUser.class)
        //可跟查询条件
        //.or()                      或者
        //.beginsWith()              以xxx开头
        //.endsWith()                以xxx结尾
        //.greaterThan()             大于
        //.greaterThanOrEqualTo()    大于或等于
        //.lessThan()                小于
        //.lessThanOrEqualTo()       小于或等于
        //.equalTo()                 等于
        //.notEqualTo()              不等于
        //.findAll()                 查询所有
        //.average()                 平均值
        //.beginGroup()              开始分组
        //.endGroup()                结束分组
        //.between()                 在a和b之间
        //.contains()                包含xxx
        //.count()                   统计数量
        //.distinct()                去除重复
        //.findFirst()               返回结果集的第一行记录
        //.isNotEmpty()              非空串
        //.isEmpty()                 为空串
        //.isNotNull()               非空对象
        //.isNull()                  为空对象
        //.max()                     最大值
        //.maximumDate()             最大日期
        //.min()                     最小值
        //.minimumDate()             最小日期
        //.sum()                     求和
        return realm.where(TestUser.class).findAll();
    }

MainActivity代码：

[html] view plain copy

print ?

1. @Override  
2.     protected void onCreate(Bundle savedInstanceState) {  
3.         super.onCreate(savedInstanceState);  
4.         setContentView(R.layout.activity_main);  
5.   
6.         mRealm = Realm.getDefaultInstance();  
7.         userDao = new UserDao(mRealm);  
8.   
9.   
10.         //...  
11.   
12.   
13.         /**  
14.          * 数据库数据更新监听  
15.          */  
16.         mRealm.addChangeListener(this);  
17.     }  
18.   
19. //...  
20.   
21.   
22. @Override  
23.     public void onChange(Realm element) {  
24.         findAll();  
25.     }  
26.   
27. @Override  
28.     protected void onDestroy() {  
29.         userDao = null;  
30.         mRealm.close();  
31.         super.onDestroy();  
32.     }  

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mRealm = Realm.getDefaultInstance();
        userDao = new UserDao(mRealm);


        //...


        /**
         * 数据库数据更新监听
         */
        mRealm.addChangeListener(this);
    }

//...


@Override
    public void onChange(Realm element) {
        findAll();
    }

@Override
    protected void onDestroy() {
        userDao = null;
        mRealm.close();
        super.onDestroy();
    }