泡在网上的日子
APP
首页 › 安卓开发 › android开发

Android上令人愉快的持久化

泡在网上的日子 / 文 发表于2016-05-06 17:03 第次阅读 sqlite,SQLDelight

原文出处：Delightful persistence on Android 

在文章开始之前，引用一位我最喜欢的武术大师之一李小龙的一段话：


“在我开始学习武术之时，对我来说一拳就是一拳，一脚就是一脚。在我学习武术之后，一拳不再是一拳，一脚也不再是一脚。现在，当我真正了解了这门艺术之后，便又感觉到一拳仍仅仅是一拳，一脚也仅仅是一脚罢了。”

 

在我使用sqlite数据库的时候，这种情况也差不多发生在我身上，不管是使用比如ORMLite, DBFlow等那样的ORM库，还是使用其他的数据库如Realm，一个数据库，不管它怎么变，也仅仅是一个数据库。

现在GitHub 满是管理sqlite数据库的安卓库 。几乎所有的库都用了ORM技术。但是，跟李小龙一样，我回到了本质，而且没有一个库给了我想要的完全掌控查询和操作的自由。对于很多项目而言数据库只是一个简单的数据库，因此别为了缓存数据或者存储数据模型而用libraries加重你的项目。

但是用普通的SQLiteOpenHelper又有点无聊，所以我继续搜索完美的数据库library，直到我发现了Square的SqlDelight。虽然不能说它完全满足了我的需要，但是至少对我有很大帮助。

声明：写这篇文章的时候，SQLDelight的最新版本是0.3.0 (2016-04-26)。

就如他们在repositories README文件中所说的：

SQLDelight根据SQL CREATE TABLE 语句生成Java model。这些model提供了一个类型安全的API去读写数据库。它帮助你把SQL statement有条理的放在一起，并方便从java获得。

为什么是SQLDelight：

  • 所有的SQL statement都存在.sq文件中。你可以轻易的把数据库的改变更新到CVS中。

  • 可以生成帮助你创建与查询表的 schema models。

  • 可以自由的使用普通SQLite的同时帮助你处理了程式化的代码。

  • 帮助你从Cursor映射到自定义model

  • 支持Cursor 和 ContentValues一样的类型，但是添加了自定义类型甚至ENUM的支持

开始SQLDelight

首先向build.gradle的buildscript方法中添加依赖。最新的版本可以在Square的sonatype找到：

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath 'com.squareup.sqldelight:gradle-plugin:0.2.2'
  }
}

上面的步骤已经足够让你开始使用SQLDelight了，但是Square那帮人还制作了一个支持语法与高亮的IntelliJ插件，推荐安装，它可以帮助你避免一些语法错误。

打开 Android Studio -> Preferences -> Plugins -> 搜索与安装 SQLDelight。

对于这篇文章，我做了一个基本的实现，你可以从 GitHub克隆。

建立 database model


Our basic database model

Tables that we will create ourselves with the help of SQLDelight.

blob.png


sample project中把com.alexsimo.delightfulpersistence作为root package，在src/main的根目录下面你需要创建一个sqlidelight文件夹，并拷贝你的root package 结构。

最终你得到一个如下的目录结构：

├── java
│   └── com
│       └── alexsimo
│           └── delightfulpersistence
│               ├── DelightfulApplication.java
│               └── database
│                   ├── DatabaseManager.java
│                   ├── DelightfulOpenHelper.java
│                   ├── adapter
│                   │   └── DateAdapter.java
│                   └── model
│                       ├── Author.java
│                       └── Book.java
└── sqldelight
    └── com
        └── alexsimo
            └── delightfulpersistence
                └── database
                    └── model
                        ├── Author.sq
                        ├── Book.sq
                        └── BookAuthor.sq

在sqldelight下面的model目录是你存放.sq文件的地方，它包含了app需要的sql语句。

你还能看到其它的文件，我稍后解释。现在我们先关注为model创建.sq文件。为了保持文章的简短，我只贴出创建和查询Author 和 Book 表的SQL语句，完整的语句可以在GitHub repository上找到。

Author:

CREATE TABLE author (
  _id LONG PRIMARY KEY AUTOINCREMENT,
  name STRING NOT NULL,
  birth_year CLASS('java.util.Calendar')
);
select_all:
select *
from author;
select_by_name:
select *
from author
where author.name = ?;

Book:

CREATE TABLE book (
  _id LONG NOT NULL PRIMARY KEY AUTOINCREMENT,
  isbn STRING NOT NULL,
  title STRING NOT NULL,
  release_year CLASS('java.util.Calendar')
);
select_all:
select *
from book;
select_by_title:
select *
from book
where book.title = ?;
select_by_isbn:
select *
from book
where book.isbn = ?;

The good thing about SQLDelight is that you also store your queries on .sq files and will help you replace the bindable parameters as where book.isbn = ?.

创建database model

现在我们可以在我们的数据库中创建我们的表了，只需编译你的工程然后SQLDelight就会生成BookModel和AuthorModel。

如果查看BookModel的内部你可以看到它建立了CREATE TABLE SQL statement，而成员属性则代表表的每一列：

public interface BookModel {
  String TABLE_NAME = "book";
  String _ID = "_id";
  String ISBN = "isbn";
  String TITLE = "title";
  String RELEASE_YEAR = "release_year";
  String CREATE_TABLE = ""
      + "CREATE TABLE book (\n"
      + "  _id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,\n"
      + "  isbn TEXT NOT NULL,\n"
      + "  title TEXT NOT NULL,\n"
      + "  release_year BLOB\n"
      + ")";
 // 下面继续

除了创建表的语句，还生成了我们在.sq文件中存储的查询语句。

  String SELECT_ALL = ""
      + "select *\n"
      + "from book";
  String SELECT_BY_TITLE = ""
      + "select *\n"
      + "from book\n"
      + "where book.title = ?";
  String SELECT_BY_ISBN = ""
      + "select *\n"
      + "from book\n"
      + "where book.isbn = ?";

注：其实它还生成了更多的东西，下面列出了一些。

有了这些SQL语句，我们可以轻易的创建表了，继承SQLiteOpenHelper：

public class DelightfulOpenHelper extends SQLiteOpenHelper {
  public static final String DB_NAME = "delightful.db";
  public static final int DB_VERSION = 1;
  private static DelightfulOpenHelper instance;
  public static DelightfulOpenHelper getInstance(Context context) {
    if (null == instance) {
      instance = new DelightfulOpenHelper(context);
    }
    return instance;
  }
  private DelightfulOpenHelper(Context context) {
    super(context, DB_NAME, null, DB_VERSION);
  }
  @Override
  public void onCreate(SQLiteDatabase db) {
    db.execSQL(BookModel.CREATE_TABLE);
    db.execSQL(AuthorModel.CREATE_TABLE);
    db.execSQL(BookAuthorModel.CREATE_TABLE);
    populate(db);
  }
  private void populate(SQLiteDatabase db) {
    AuthorPopulator.populate(db);
    BookPopulator.populate(db);
  }
}

如果你使用Android官网上所说的SQLiteOpenHelper的基本实现，你可能会遇到一些并发的问题，就如Dmytro的博文中说明的，如果你是一个西班牙读者，看这篇文章.。

为了处理上面提到的问题，我创建了一个SQLiteHelper的wrapper：

DatabaseManager.java:

public class DatabaseManager {
  private static AtomicInteger openCount = new AtomicInteger();
  private static DatabaseManager instance;
  private static DelightfulOpenHelper openHelper;
  private static SQLiteDatabase database;
  public static synchronized DatabaseManager getInstance() {
    if (null == instance) {
      throw new IllegalStateException(DatabaseManager.class.getSimpleName()
          + " is not initialized, call initialize(..) method first.");
    }
    return instance;
  }
  public static synchronized void initialize(DelightfulOpenHelper helper) {
    if (null == instance) {
      instance = new DatabaseManager();
    }
    openHelper = helper;
  }
  public synchronized SQLiteDatabase openDatabase() {
    if (openCount.incrementAndGet() == 1) {
      database = openHelper.getWritableDatabase();
    }
    return database;
  }
  public synchronized void closeDatabase() {
    if (openCount.decrementAndGet() == 0) {
      database.close();
    }
  }
}

上面的这个类，我在Application类中实例化它，或者使用Dagger。

使用一个非常简单的android connected test（需要设备或者模拟器），我们就能检测表是否成功创建：

public class DatabaseShould extends CustomRunner {
  @Override
  @Before
  public void setUp() throws Exception {
    super.setUp();
    DbCommon.deleteDatabase(context);
  }
  @Test
  public void be_able_to_open_writable_database() throws Exception {
    SQLiteDatabase db = givenWritableDatabase();
    assertTrue(db.isOpen());
    assertTrue(!db.isReadOnly());
  }
  @Test
  public void have_created_tables() throws Exception {
    SQLiteDatabase db = givenWritableDatabase();
    HashSet<String> tables = givenAllTables();
    Cursor cursor = db.rawQuery("SELECT name FROM sqlite_master WHERE type='table'", null);
    cursor.moveToFirst();
    do {
      String table = cursor.getString(0);
      tables.remove(table);
    } while (cursor.moveToNext());
    cursor.close();
    assertTrue(tables.isEmpty());
  }
  private SQLiteDatabase givenWritableDatabase() {
    return DbCommon.givenWritableDatabase(context);
  }
  private HashSet<String> givenAllTables() {
    HashSet<String> tables = new HashSet<>();
    tables.add(BookModel.TABLE_NAME);
    tables.add(AuthorModel.TABLE_NAME);
    tables.add(BookAuthorModel.TABLE_NAME);
    return tables;
  }
}

同样你还可以像上面那样测试表的列的创建过程，这不是很好的范例，我很高兴你能提出一些改进：

public class AuthorTableShould extends CustomRunner {
  @Before
  public void setUp() throws Exception {
    super.setUp();
    DbCommon.deleteDatabase(context);
  }
  @Test
  public void have_created_all_columns() throws Exception {
    HashSet<String> columns = givenAuthorColumns();
    SQLiteDatabase db = givenWritableDatabase();
    Cursor cursor = db.rawQuery("PRAGMA table_info(" + AuthorModel.TABLE_NAME + ")", null);
    cursor.moveToFirst();
    int columnNameIndex = cursor.getColumnIndex("name");
    do {
      String columnName = cursor.getString(columnNameIndex);
      columns.remove(columnName);
    } while (cursor.moveToNext());
    assertTrue(columns.isEmpty());
    cursor.close();
    db.close();
  }
  private SQLiteDatabase givenWritableDatabase() {
    return DbCommon.givenWritableDatabase(context);
  }
  private HashSet<String> givenAuthorColumns() {
    HashSet<String> columns = new HashSet<>();
    columns.add(AuthorModel._ID);
    columns.add(AuthorModel.NAME);
    columns.add(AuthorModel.BIRTH_YEAR);
    return columns;
  }
}

使用SQLDelight插入数据

记住在.sq文件的CREATE TABLE定义中，我们使用了一个自定类型，java.util.Calendar。因为它不是一个原生的SQLite类型，我们必须为它创建一个adapter。

那么我们就来创建它，在我的sample project里，我把它叫做DateAdapter：

public class DateAdapter implements ColumnAdapter<Calendar> {
  @Override
  public Calendar map(Cursor cursor, int columnIndex) {
    Calendar calendar = Calendar.getInstance();
    calendar.setTimeInMillis(cursor.getLong(columnIndex));
    return calendar;
  }
  @Override
  public void marshal(ContentValues values, String key, Calendar value) {
    values.put(key, value.getTimeInMillis());
  }
}

这本该就完成了，但是我们还必须告诉SQLDelight如何使用它，所以找到并实现SQLDelight生成的BookModel和AuthorModel，重写里面的Author 和 Book Marshall类并传递这个calendar adapter。

@AutoValue public abstract class Author implements AuthorModel {
  private final static DateAdapter DATE_ADAPTER = new DateAdapter();
  public final static Mapper<Author> MAPPER =
      new Mapper<>((Mapper.Creator<Author>) AutoValue_Author::new, DATE_ADAPTER);
  public static final class Marshal extends AuthorMarshal<Marshal> {
    public Marshal() {
      super(DATE_ADAPTER);
    }
  }
}

我们暂时跳过MAPPER 变量，在讲到从表请求数据的时候将解释。注意这里的final类Marshal，就是在这里告诉SQLDelight，对于java.util.Calendar类型它应该使用你的adapter。在sample中我使用了谷歌的 @AutoValue 和 RetroLambda来避免一些重复的代码。

对于插入数据，我创建了一个叫做BookPopullator或者AuthorPopullator的类：

public class AuthorPopullator {
  public static void populate(SQLiteDatabase db) {
    db.insert(AuthorModel.TABLE_NAME, null, new Author.Marshal().name("J. K. Rowling")
        .birth_year(new GregorianCalendar(1965, 7, 31))
        .asContentValues());
    db.insert(AuthorModel.TABLE_NAME, null, new Author.Marshal().name("Bella Forests")
        .birth_year(new GregorianCalendar(197, 17, 31))
        .asContentValues());
    db.insert(AuthorModel.TABLE_NAME, null, new Author.Marshal().name("Norah Roberts")
        .birth_year(new GregorianCalendar(1950, 10, 10))
        .asContentValues());
    db.insert(AuthorModel.TABLE_NAME, null, new Author.Marshal().name("David Baldacci")
        .birth_year(new GregorianCalendar(1960, 8, 5))
        .asContentValues());
    db.insert(AuthorModel.TABLE_NAME, null, new Author.Marshal().name("Jeff Wheeler")
        .birth_year(new GregorianCalendar(1955, 13, 31))
        .asContentValues());
  }
}

可以看到，SQLDelight为我们提供了一个非常流畅的builder，代码更干净了。

删除数据遵循相同的程序，你在.sq文件中定义sql删除语句然后使用SQLiteDatabase对象执行它。


使用SQLDelight查询数据

为了演示如何使用SQLDelight查询数据，我像上面那样使用tests：

@Test
public void be_able_to_return_cursor_with_all_default_authors() throws Exception {
    SQLiteDatabase db = givenWritableDatabase();
    Cursor cursor = db.rawQuery(AuthorModel.SELECT_ALL, new String[0]);
    int AUTHOR_COUNT = 5;
    assertTrue(cursor.getCount() == AUTHOR_COUNT);
  }
  @Test
  public void map_cursor_with_domain_model() throws Exception {
    SQLiteDatabase db = givenWritableDatabase();
    Cursor cursor = db.rawQuery(AuthorModel.SELECT_ALL, new String[0]);
    cursor.moveToFirst();
    Author author = Author.MAPPER.map(cursor);
    assertNotNull(author);
  }

仔细看看Author.MAPPER.map(cursor)。对的！它能把cursor映射到model类中。对我来说这是非常棒的功能，因为它让我少些了很多程式化的代码，也更不易出错。

使用SQLDelight迁移

实际上，处理迁移并没有一个官方的方法，但是你可以查看一个 open issue来了解怎么回事。

在我的sample project中，我使用了一个比较不规范的方式把迁移语句存放到.sq文件中。

我把迁移文件存放在跟model创建与查询文件相同的目录中：

└── sqldelight
    └── com
        └── alexsimo
            └── delightfulpersistence
                └── database
                    └── model
                        ├── Author.sq
                        ├── Book.sq
                        ├── BookAuthor.sq
                        ├── Migration_v1.sq
                        └── Migration_v2.sq

如果你看一看 Migration_v1.sq 的内部，可以看到SQLDelight IntelliJ 插件与compiler要求你使用一个CREATE TABLE statement来开始一个.sq文件，因此我只是用并不会创建的dummy添加了一个CREATE TABLE语句：

CREATE TABLE dummy(_id LONG NOT NULL PRIMARY KEY AUTOINCREMENT);
migrate_author:
ALTER TABLE author
ADD COLUMN country STRING NOT NULL;

然后在我们的自定义SQLiteOpenHelper类的onUpgrade()方法中我们就可以使用迁移语句了：

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    if (oldVersion < 2) {
      db.execSQL(Migration_v1Model.MIGRATE_AUTHOR);
    }
    if (oldVersion < 3) {
      db.execSQL(Migration_v2Model.MIGRATE_BOOK);
    }
  }

这并不是最干净的迁移方法，但是我相信Square的同学会在未来的SQLDelight版本中找到一个更好的方法。

收藏 赞 (4) 踩 (0)
相关文章
上一篇：Dagger2深入理解
最近，看到一些小伙伴想要入门Dagger2，加之最近刚经历了Dagger2的水深火热，在这里针对Dagger2中不同的注解方式，会生成怎样的代码，结合其生成的不同代码，来帮助大家做一些深入的理解。 概念 首先，Dagger2是一个DI的解决方案，跟之前接触过的Spring相比
下一篇：Android 快速学习库
Android 快速学习库，主要想实现一条属于自己的开发框架。包括网络访问，数据，UI等,将该项目分为四个模块，UI界面、网络、进阶、综合。
推荐文章
赞助商

Copyright 2011 - 2016 jcodecraeer.com All Rights Reversed.

蜀ICP备12021840号-1

本站文章用于学习交流

  • 网站地图