Android Realm数据库完美解析

当我们的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文件中添加依赖：

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

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

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

配置完毕。

使用：

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

/**
     * 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>
     *
     */

部分源码分析：

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类的说明翻译：

/**
 * 一个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>
 */

部分源码分析：

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代码：

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:

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,简单封装，把基本的增删改功能提取：

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:

/**
     * 单条保存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代码：

@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();
    }

增删改的代码注意事务，其他的都简单。

sorry，忘记上传demo了。需要demo的请留下qq，发你邮箱吧。