首页 / ANDROID / Android Realm数据库完美解析

Android Realm数据库完美解析

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Android Realm数据库完美解析，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含13780字，纯文字阅读大概需要20分钟。

内容图文

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

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



2、在app module的build.gradle文件的top添加下面代码：
  1. apply plugin: 'com.android.application'
  2. apply plugin: 'realm-android'
  3. ....


配置完毕。

使用：

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

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



部分源码分析：

  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. }




RealmConfiguration类的说明翻译：
  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.  */


?
部分源码分析：
  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. ｝




通过上面的翻译说明和源码分析，应该几乎明白了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代码：
  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. }




java Bean:
  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. }




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




UserDao extends BaseDao:
  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.     }







MainActivity代码：
  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.     }




增删改的代码注意事务，其他的都简单。
sorry，忘记上传demo了。需要demo的请留下qq，发你邮箱吧。



转自: https://blog.csdn.net/fesdgasdgasdg/article/details/51897212

内容总结

以上是互联网集市为您收集整理的Android Realm数据库完美解析全部内容，希望文章能够帮你解决Android Realm数据库完美解析所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/899353.html

来源：【匿名】