ActiveAndroid 管理数据库

转自

ActiveAndroid 管理数据库

虽然android已经提供了管理数据库的工具类，但是对一些同学学习起来还是有些困难的，今天我就介绍一下ActiveAndroid。
ActiveAndroid是一个活性的记录的风格ORM（对象关系映射）。这是什么意思呢？那么，ActiveAndroid允许你保存和检索SQLite数据库记录，而无需编写一个单独的SQL语句。每个数据库记录被包裹整齐地归为一类，如save（）和delete（）的方法。

ActiveAndroid这样做远不止这一点，虽然。访问数据库是一件麻烦事，至少可以说，在Android。 ActiveAndroid照顾所有的设置和凌乱的东西，所有的配置，只需几个简单的步骤。

第一步

配置我们的基本信息：

1 2 3 4 5 6 7 8 9 10

<manifest ...> <application android:name="com.activeandroid.app.Application" ...> ... <meta-data android:name="AA_DB_NAME" android:value="数据库名称.db" /> <meta-data android:name="AA_DB_VERSION" android:value="版本数字" /> </application> </manifest>

如果你需要定义自己的Application你可以：

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

如果你自己的Application已经继承了别的库的类你可以：

1 2 3 4 5 6 7 8 9 10 11 12

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

第二步

配置完成之后我们创建两张表，我们可以这样：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

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

声明表名使用**@Table(name="")**，声明列名使用**@Colnmn(name="")**,这样就ok了。

当我们创建对象需要有参数的构造方法，我们需要下面这样，AciveAndroid 会使用我们的无参的构造方法实例化对象：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

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

我们创建一个**一对多**关系，可以这样：

1 2 3 4 5 6 7 8

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

我们需要借助一个方法：

1 2 3 4 5 6 7 8 9

@Table(name = "Categories") public class Category extends Model { @Column(name = "Name") public String name; public List<Item> items() { return getMany(Item.class, "Category"); } }

第三步

保存数据，我们可以这样：

1 2 3

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

创建一个Item，和Categroy存在依赖关系，多个同样

1 2 3 4

Item item = new Item(); item.category = restaurants; item.name = "Outback Steakhouse"; item.save();

插入多条数据的时候我们可以使用事务，可以这样：

1 2 3 4 5 6 7 8 9 10 11 12

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

删除一条数据，可以这样：

1 2 3 4 5 6 7

//第一种 Item item = Item.load(Item.class, 1); item.delete(); //第二种 Item item = Item.delete(Item.class, 1); //第三种 new Delete().from(Item.class).where("Id = ?", 1).execute();

查询数据
随机查出一项，我们可以这样：

1 2 3

public static Item getRandom() { return new Select().from(Item.class).orderBy("RANDOM()").executeSingle(); }

根据条件查询，但是得到结果随机的一项,我们可以这样：

1 2 3 4 5 6 7

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

下面是我们通常用的一个根据条件查询的：

1 2 3 4 5 6 7

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

第四步

当我们数据库表，字段改变的时候，我们可以这样：
1.先把数据库版本增加1
2.在**/assets/migrations**目录下面增加一个修改过版本的版本号sql例如**AA_DB_VERSION 是 2**，我们的文件名**2.sql**
sql例如：

1	alter table Items add colour(varchar);

库文件下载地址：http://www.eoeandroid.com/forum.php?mod=attachment&aid=ODYyOTd8NDI1Mzk3NjJ8MTM1ODQ0MjA4Mnw2NDU4MjB8MjQ5MjAx

//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

转自

Android ORM 框架之 ActiveAndroid

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

初始化Jar包

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

工程配置

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

 
 
 <meta-data
            android:name="AA_DB_NAME"
            android:value="Pickrand.db" />
 <meta-data
            android:name="AA_DB_VERSION"
            android:value="1" />

如果这两个都不写的话，默认会是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条数据的测试。

//---------------------------------------------------------------------------------

使用内容提供者

使用ActiveAndroid的ContentProvider，必须复写默认的标识列如下所示(默认标识列是ID)。

1 2	@Table(name =  "Items" , id = BaseColumns._ID) public class Item extends Model {...}

接着就可以使用ContentProvider

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

mySpinner.setAdapter( new  SimpleCursorAdapter(getActivity(),          android.R.layout.simple_expandable_list_item_1,          null ,          new  String[] {  "MyProperty"  },          new  int[] { android.R.id.text1 },          0));        getActivity().getSupportLoaderManager().initLoader(0,  null ,  new  LoaderCallbacks<Cursor>() {          @Override          public Loader<Cursor> onCreateLoader(int arg0, Bundle cursor) {              return  new  CursorLoader(getActivity(),                  ContentProvider.createUri(MyEntityClass.class,  null ),                  null ,  null ,  null ,  null              );          }            @Override          public void onLoadFinished(Loader<Cursor> arg0, Cursor cursor) {              ((SimpleCursorAdapter)mySpinner.getAdapter()).swapCursor(cursor);          }            @Override          public void onLoaderReset(Loader<Cursor> arg0) {              ((SimpleCursorAdapter)mySpinner.getAdapter()).swapCursor( null );          }      });

最后别忘了在AndroidManifest.xml中注册provider

1 2 3 4

<application ...>      <provider android:authorities= "com.example"  android:exported= "false"  android:name= "com.activeandroid.content.ContentProvider"  />      ... </application>

JackCho

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中静态的注入两个方法即可。

 

 

二、定义实体类

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

三、插入

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

四、删除

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

五、更新

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

六、查询

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

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

参考

https://github.com/thecodepath/android_guides/wiki/ActiveAndroid-Guide

https://github.com/pardom/ActiveAndroid