Android ORM 框架之 ActiveAndroid

女爷i 2022-08-03 03:19 237阅读 0赞

出自：

https://www.zybuluo.com/flyouting/note/6915

# Android ORM 框架之 ActiveAndroid #

最近研究了一下Android中的ORM框架，其一是ActiveAndroid，ActiveAndroid算是一个轻量级的ORM框架，配置，使用还都算是比较简单的。

## 初始化Jar包 ##

1.  [Github地址][Github]，下载源代码
2.  打开CMD，进入源码根目录
3.  执行ant
4.  jar包生成，可以在dist文件夹里找到。

## 工程配置 ##

*  在AndroidManifest.xml中需要添加数据库名和版本号

如果这两个都不写的话，默认会是Application.db，库版本号为1。

*  在Application中初始化   
    可以继承com.activeandroid.app.Application，可以在自己的Application里初始化，看com.activeandroid.app.Application文件就明白了：

public class Application extends android.app.Application { 
       @Override
       public void onCreate() { 
       super.onCreate();
       ActiveAndroid.initialize(this);
       }
       
       @Override
       public void onTerminate() { 
       super.onTerminate();
       ActiveAndroid.dispose();
       }
       }

所以如果不继承只需要在自己的Application 添加ActiveAndroid.initialize(this)和   
ActiveAndroid.dispose()的操作即可。

## 实际应用 ##

### 创建Model类 ###

@Table(name = "Items")
       public class Item extends Model { 
       // 这样可以避免重复
       @Column(name = "remote_id", unique = true, onUniqueConflict = Column.ConflictAction.REPLACE)
       public int remoteId;
       
       @Column(name = "Name")
       public String name;
       
       @Column(name = "Category")
       public Category category;
       
       // 确保每个model类中都有一个默认的构造方法
       public Item(){ 
       super();
       }
       
       public Item(String remoteId, String name, Category category){ 
       super();
       this.remoteId = remoteId;
       this.name = name;
       this.category = category;
       }
       }

这个Item类中包含了一个Category类型的对象

@Table(name = "Categories")
       public class Category extends Model { 
       @Column(name = "remote_id", unique = true, onUniqueConflict = Column.ConflictAction.REPLACE)
       public int remoteId;
       
       @Column(name = "Name")
       public String name;
       
       @Column(name = "Entry")
       public Entry entry;
       
       public Category(){ 
       super();
       }
       
       public void saveEntry() { 
       if (entry != null) { 
       entry.save();
       }
       }
       
       public List<Item> data;
       
       // 使用外键，实现一对多存储
       public List<Item> items() { 
       data = getMany(Item.class, "Category");
       }
       }

这其中又包含了一个Entry对象

@Table(name = "Entrys")
       public class Entry extends Model { 
       @Column(name = "Name")
       public String name;
       
       }

具体的model类其实是根据实际情况来写的，这里只写最简单的。在数据库应用中，我们涉及的无外乎是增删改查，这里以一个简单的例子来研究一下。

实际项目中，我们经常会遇到这样的情况，一个类`Category` 中包含一个`Entry`对象，包含一个`List<Item>`对象，一个String对象。

模拟一下数据：

List<Category> Categorys = new ArrayList<Category>();
       List<Item> Items = new ArrayList<Item>();
       
       for (int i = 0; i < 100; i++) { 
       Category restaurants = new Category();
       restaurants.name = "Category " + i;
       Entry entry = new Entry();
       entry.name = "entry " + i;
       restaurants.entry = entry;
       Categorys.add(restaurants);
       
       for (int j = 0; j < 3; j++) { 
       Item item = new Item();
       item.name = "Item " + i + " from " + "Category " + i;
       item.category = restaurants;
       Items.add(item);
       }
       }

在这个框架中，一个对象中包含一个List对象，其实就是把List对象全部存到另一个表里，通过外键来关联。

### 增 ###

通过事务，批量添加进数据库。

ActiveAndroid.beginTransaction();
       try { 
       int len = Categorys.size();
       for (int i = 0; i < len; i++) { 
       Categorys.get(i).saveEntry();
       Categorys.get(i).save();
       }
       len = Items.size();
       for (int i = 0; i < len; i++) { 
       Items.get(i).save();
       }
       ActiveAndroid.setTransactionSuccessful();
       } finally { 
       ActiveAndroid.endTransaction();
       }

这里需要注意的是Item类中包含Category对象，Category类中包含Entry对象。必须先保存Entry对象，Entry对象会得到一个Id，然后才能存储Category对象，否则Category对象中的Entry对象就会为null。这部分逻辑可以查看Model类中save()方法的源码：

else if (ReflectionUtils.isModel(fieldType)) { 
       values.put(fieldName, ((Model) value).getId());
       }

如果Entry对象不先存储，Id是为null的。Entry与Category关联的依赖就是Entry   
的Id。所以执行完`Categorys.get(i).saveEntry()`后才执行`Categorys.get(i).save()`其后才执行Item的存储，这时候Category对象都已经有了Id，Item会自动关联。

### 删 ###

Item item = Item.load(Item.class, 1);
       item.delete();
       // 或者
       new Delete().from(Item.class).where("remote_id = ?", 1).execute();

批量删除就用事务。

### 改 ###

先看下`Model`类源码152行：

if (mId == null) { 
       mId = db.insert(mTableInfo.getTableName(), null, values);
       }else { 
       db.update(mTableInfo.getTableName(), values, idName+"=" + mId, null);
       }

很明显，如果`mId`不存在就会去数据库创建这跳数据，而如果数据存在的话，那就是更新了。所以，更改数据后直接执行`save`方法即可。

### 查 ###

public static List<Item> getAll(Category category，int num) { 
       return new Select()
       .from(Item.class)
       .where("Category = ?", category.getId())
       .orderBy("Name ASC")
       .limit(num)
       .execute();
       }

执行一个`Select`方法，指定表`Item.class`，限定条件`where("Category = ?", category.getId())`，排序为`orderBy("Name ASC")`，取出个数为`limit(num)`   
当然还支持其他非常多的指令

*  offset
 *  as
 *  desc/asc
 *  inner/outer/cross join
 *  group by
 *  having   
    这个就根据自己需求了。

在查询`Category`数据中，因为每个对象中包括了一个`List<Item>`对象，所以，我们需要在查询出`Category`对象后，在把关联的List表查询一遍。

ActiveAndroid.beginTransaction();
       try { 
       List<Category> testCategory = new Select().from(Category.class).limit(20).execute();
       if (testCategory != null) { 
       int len = testCategory.size();
       for (int i = 0; i < len; i++) { 
       testCategory.get(i).items();
       }
       }
       ActiveAndroid.setTransactionSuccessful();
       } finally { 
       ActiveAndroid.endTransaction();
       }

如此执行完，对象中的data就可以直接用了。

## 总结 ##

作为一个轻量级的ORM框架，在快速开发中，应用起来还是很方便的，比ORMLite要简单一些，但某些细节不如ORMLite更强大，不如对象中包含对象时，ORMLite中可以有参数设定自动创建，而不是需要我们手动执行下sava，也许在ActiveAndroid中也可以这样，但目前我没搞明白注解中另几个属性的意思。整体性能经测试（100条Category数据，300条Item数据，100条Entry数据）存储耗时1.1s-1.2s，与ORMLite是持平的，但也许是测试数据太小了，没有说服性，有时间可以进行10w条数据的测试。

2. [Android轻量级ORM框架ActiveAndroid入门教程(转)][Android_ORM_ActiveAndroid]

出自： http://www.cnblogs.com/GarfieldTom/p/3877077.html

# [Android轻量级ORM框架ActiveAndroid入门教程(转)][Android_ORM_ActiveAndroid] #

注：没有找到出处，如有侵犯，请告知

开始ActiveAndroid神奇之旅：  
  
在AndroidManifest.xml中我们需要添加这两个

*  AA\_DB\_NAME (数据库名称，这个name不能改，但是是可选的，如果不写的话 是默认的"Application.db"这个值）
 *  AA\_DB\_VERSION (数据库版本号，同样是可选的 – 默认为1)

这个<application>是必须指定的，但你也可以使用自己的Application,继承自com.activeandroid.app.Application

public class MyApplication extends com.activeandroid.app.Application { ...

如果你不想或者不能继承com.activeandroid.app.Application的话，那么就这样

public class MyApplication extends SomeLibraryApplication {
        @Override
        public void onCreate() {
            super.onCreate();
            ActiveAndroid.initialize(this);
        }
        @Override
        public void onTerminate() {
            super.onTerminate();
            ActiveAndroid.dispose();
        }
    }

ActiveAndroid.initialize(this)；做初始化工作，ActiveAndroid.dispose();做清理工作  
  
  
创建数据库模型  
我们使用@Table(name = "Items")来表示表，使用@Column(name = "Name")来表示列，ActiveAndroid会使用自增长的ID作为主键，然后按照注解描述，将类对应映射为数据库表。

@Table(name = "Categories")
    public class Category extends Model { 
        @Column(name = "Name")
        public String name;
    }
    
    @Table(name = "Items")
    public class Item extends Model {
        @Column(name = "Name")
        public String name;
    
        @Column(name = "Category")
        public Category category;
    }

依赖关系的数据库表  
假如Item和Category是多对一的关系，那么我们可以这样子创建他们的类

@Table(name = "Items")
    public class Item extends Model {
        @Column(name = "Name")
        public String name;
        @Column(name = "Category")
        public Category category;
    }

@Table(name = "Categories")
    public class Category extends Model {
        @Column(name = "Name")
        public String name;
        //方法可选，对外键创建没有影响
        public List<Item> items() {
            return getMany(Item.class, "Category");
        }

初始化工作做好，让我们看一下如何保存和更新数据到数据库  
单个插入  
保存Category对象

Category restaurants = new Category();
    restaurants.name = "Restaurants";
    restaurants.save();

批量插入  
如果你要批量插入数据，最好使用事务(transaction)。

ActiveAndroid.beginTransaction();
    try {
            for (int i = 0; i < 100; i++) {
                Item item = new Item();
                item.name = "Example " + i;
                item.save();
            }
            ActiveAndroid.setTransactionSuccessful();
    }
    finally {
            ActiveAndroid.endTransaction();
    }

使用事务的话只用了 40ms，不然的话需要4秒。  
  
  
删除记录  
我们有三种方式删除一条记录

Item item = Item.load(Item.class, 1);
    item.delete();

Item.delete(Item.class, 1);

new Delete().from(Item.class).where("Id = ?", 1).execute();

好吧！是不是感觉so easy!  
  
  
查询数据库  
作者将查询做的非常像SQLite的原生查询语句，几乎涵盖了所有的指令 com.activeandroid.query包下有以下类

*  Delete
 *  From
 *  Join
 *  Select
 *  Set
 *  Update

看实际例子

public static Item getRandom(Category category) {
        return new Select()
            .from(Item.class)
            .where("Category = ?", category.getId())
            .orderBy("RANDOM()")
            .executeSingle();
    }

对应的sqlite查询语句就是 select \* from Item where Category = ? order by RANDOM()  
  
那么下面代码对应的sqlite查询语句作用是什么，尝试去告诉我吧？

public static List<Item> getAll(Category category) {
        return new Select()
            .from(Item.class)
            .where("Category = ?", category.getId())
            .orderBy("Name ASC")
            .execute();
    }

当然还支持其他非常多的指令，你可以从github上面的测试用例去了解~  
  
  
最后，咱们来尝试升级数据库  
很多情况下，我们需要在原来数据库的基础上增加字段，而又顾忌用户原来保存的数据，不想删除原来的数据表再重新建表，因此我们需要这样做：  
  
1、首先，你需要更改AndroidManifest.xml中数据库版本号AA\_DB\_VERSION（必须比上一版本号大的正整数）  
  
2、其次，你需要在assest目录里面创建sql文件，目录结构（/migrations/升级后的版本号.sql），文件里面你需要写上你变动数据库的sql语句（一行一句sql语句），比如我们想在Category表里增加Count字段来统计数量，我们需要这样写：

ALTER TABLE Category ADD COLUMN Count INTEGER;

3、最后，你需要在Category对象里面添加的对应字段（如果有增加字段的话，添加规则参考上面创建数据库模型

还有园子里的一篇文章：

http://www.cnblogs.com/jack-1900/p/3876728.html

# [ORM轻量级框架---ActiveAndroid][ORM_---ActiveAndroid] #

ORM即Object-Relational Mapping，对象关系映射。简单理解就是把我们Java的对象与数据库里面的记录进行映射，可以把实体对象持久化到数据库中，也能把查询到的记录映射成Java对象。ORM让我们彻底解放，一点也不需要再去编写冗长晦涩的Sql语句，一切都是通过框架去做，不得不说是程序员的一大福音。

ORM框架实现的原理其实也很简单，就是利用Java的反射机制把对象和数据库记录映射关联起来。比如存储的时候，是把对象的属性取出来作为记录的属性值进行插入；而查询的时候则是把查询条件自动构建成一条Sql语句，把查询到的结果集转成对象列表。J2EE有ibatis，Hibernate框架，我们Android也有GreenDAO，ormlite，xUtils，AFinal等。它们的实现原理都一样，不同的也只是细节方面的处理。如果兴趣的同学，推荐阅读下ActiveAndroid的源码。Reading the fucking code!

以前写过介绍xUtils的系列文章，其中的FinalDb模块就是一个ORM框架，也是我工作中常用的。今天我们介绍的ActiveAndroid的API也是相当的简单友好，而且功能一样的强大。ActiveAndroid简洁的API给人一种用起来很舒服的感觉，今天主要是介绍下关于CRUD的简单使用。

一、初始化

有两种方式，一种是配置AndroidManifest的application的name属性，同时在meta-data标签中可选的配置db的name和version；二是在自己的Application类中继承ActiveAndroid的Application；前两种方式入侵性太强，还有一种只需在自定义的Application中静态的注入两个方法即可。

![0][]

![0 1][]

![0 2][]

二、定义实体类

实体类需继承Model，可自定义表名和属性对应的字段名

![0 3][]

三、插入

可以实现单条数据插入，也可以批量插入，同时也支持事务。

![0 4][]

四、删除

支持基于引用的单条记录删除，也支持根据条件进行批量删除。

![0 5][]

五、更新

自Model中继承来的save方法，不仅可以进行insert、还可以update；同时也能基于条件进行批量的更新。

![0 6][]

六、查询

ActiveAndroid的查询API基本与sql语句的关键字一致，比较友好。这点和xUtils是一样的

![0 7][]

写在最后：ORM框架使用起来确实是很方便的，给我们编码提高了效率，但是也有着致命弊端。前面我们也介绍了ORM的实现的原理是Java的反射机制，反射有个缺点，就是会造成效率不高、耗时较长的现象。当有数据批量操作的时候，会把耗时加长好几倍。所以当遇到业务中有很多的记录要处理的时候，就不推荐大家使用框架了，还是老老实实的写比较靠谱。今天干货分享到此为止，希望可以帮助到大家。

[Github]: https://github.com/pardom/ActiveAndroid
[Android_ORM_ActiveAndroid]: http://www.cnblogs.com/GarfieldTom/p/3877077.html
[ORM_---ActiveAndroid]: http://www.cnblogs.com/jack-1900/p/3876728.html
[0]: /images/20220731/d3431efb3a7d44639a32a0b49ea1ce66.png
[0 1]: /images/20220731/c1d0870973b94cb78794b85affd819d7.png
[0 2]: /images/20220731/2b66302acdff4fb8a1fdd6992949bb68.png
[0 3]: /images/20220731/2473c47f82b3494b837c2cba80a92ed7.png
[0 4]: /images/20220731/7039935fad764c18ac6199f40d6d18b3.png
[0 5]: /images/20220731/1a6f2288299e42ac9c91db3e9ba7270f.png
[0 6]: /images/20220731/ce6b4244d4ff48d6b15046922156370a.png
[0 7]: /images/20220731/03a25fe8d8034ad7aed8bc805e7d09ff.png