【Android - 框架】之ORMLite的使用

　　Android中有很多操作SQLite數據庫的框架，現在最常見、最常用的是ORMLite和GreenDAO。ORMLite相比與GreenDAO來說是一個輕量級的框架，而且學習成本相對較低。所以這個帖子中先介紹ORMLite，下個帖子再介紹GreenDAO。

　　要使用ORMLite，首先需要導入ORMLite的依賴：在build.gradle中加入以下代碼：

    compile 'com.j256.ormlite:ormlite-android:5.0'
    compile 'com.j256.ormlite:ormlite-core:5.0'

　　ORMLite需要我們自己實現一個類似原生操作SQLite數據庫的DatabaseHelper，但必須繼承自ORMLite為我們提供的OrmLiteSqliteOpenHelper。以下是一個功能比較齊全，性能相對也比較好的實例，這個實例不僅僅起到了創建數據庫和更新數據庫的操作，還對自身對象進行了單例、對DAO進行了統一的管理。代碼如下：

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;

import com.example.itgungnir.testormlite.entity.ArticleBean;
import com.example.itgungnir.testormlite.entity.UserBean;
import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;
import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.support.ConnectionSource;
import com.j256.ormlite.table.TableUtils;

import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

/**
 * 數據庫操作管理工具類
 * <p>
 * 我們需要自定義一個類繼承自ORMlite給我們提供的OrmLiteSqliteOpenHelper，創建一個構造方法，重寫兩個方法onCreate()和onUpgrade()
 * 在onCreate()方法中使用TableUtils類中的createTable()方法初始化數據表
 * 在onUpgrade()方法中我們可以先刪除所有表，然后調用onCreate()方法中的代碼重新創建表
 * <p>
 * 我們需要對這個類進行單例，保證整個APP中只有一個SQLite Connection對象
 * <p>
 * 這個類通過一個Map集合來管理APP中所有的DAO，只有當第一次調用這個DAO類時才會創建這個對象（並存入Map集合中）
 * 其他時候都是直接根據實體類的路徑從Map集合中取出DAO對象直接調用
 */
public class DatabaseHelper extends OrmLiteSqliteOpenHelper {
    // 數據庫名稱
    public static final String DATABASE_NAME = "mydb.db";

    // 本類的單例實例
    private static DatabaseHelper instance;

    // 存儲APP中所有的DAO對象的Map集合
    private Map<String, Dao> daos = new HashMap<>();

    // 獲取本類單例對象的方法
    public static synchronized DatabaseHelper getInstance(Context context) {
        if (instance == null) {
            synchronized (DatabaseHelper.class) {
                if (instance == null) {
                    instance = new DatabaseHelper(context);
                }
            }
        }
        return instance;
    }

    // 私有的構造方法
    private DatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, 1);
    }

    // 根據傳入的DAO的路徑獲取到這個DAO的單例對象（要么從daos這個Map中獲取，要么新創建一個並存入daos）
    public synchronized Dao getDao(Class clazz) throws SQLException {
        Dao dao = null;
        String className = clazz.getSimpleName();
        if (daos.containsKey(className)) {
            dao = daos.get(className);
        }
        if (dao == null) {
            dao = super.getDao(clazz);
            daos.put(className, dao);
        }
        return dao;
    }

    @Override // 創建數據庫時調用的方法
    public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
        try {
            TableUtils.createTable(connectionSource, UserBean.class);
            TableUtils.createTable(connectionSource, ArticleBean.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override // 數據庫版本更新時調用的方法
    public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
        try {
            TableUtils.dropTable(connectionSource, UserBean.class, true);
            TableUtils.dropTable(connectionSource, ArticleBean.class, true);
            onCreate(database, connectionSource);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 釋放資源
    @Override
    public void close() {
        super.close();
        for (String key : daos.keySet()) {
            Dao dao = daos.get(key);
            dao = null;
        }
    }
}

　　在這個帖子中，我們通過這樣一個例子來了解ORMLite：數據庫中有兩個表，一個是user表，其中存儲用戶的信息；另一個是article表，存儲文章信息，一個用戶可以關良多篇文章，一篇文章只能關聯一個用戶。

　　有了上面的需求，下面我們來寫兩個實體類：

　　UserBean類中的代碼如下：

import com.j256.ormlite.dao.ForeignCollection;
import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.field.ForeignCollectionField;
import com.j256.ormlite.table.DatabaseTable;

import java.util.Date;

/**
 * UserBean實體類，存儲數據庫中user表中的數據
 * <p>
 * 注解：
 * DatabaseTable：通過其中的tableName屬性指定數據庫名稱
 * DatabaseField：代表數據表中的一個字段
 * ForeignCollectionField：一對多關聯，表示一個UserBean關聯着多個ArticleBean（必須使用ForeignCollection集合）
 * <p>
 * 屬性：
 * id：當前字段是不是id字段（一個實體類中只能設置一個id字段）
 * columnName：表示當前屬性在表中代表哪個字段
 * generatedId：設置屬性值在數據表中的數據是否自增
 * useGetSet：是否使用Getter/Setter方法來訪問這個字段
 * canBeNull：字段是否可以為空，默認值是true
 * unique：是否唯一
 * defaultValue：設置這個字段的默認值
 */
@DatabaseTable(tableName = "user") // 指定數據表的名稱
public class UserBean {
    // 定義字段在數據庫中的字段名
    public static final String COLUMNNAME_ID = "id";
    public static final String COLUMNNAME_NAME = "name";
    public static final String COLUMNNAME_SEX = "sex";
    public static final String COLUMNNAME_BIRTHDAY = "birthday";
    public static final String COLUMNNAME_ADDRESS = "address";

    @DatabaseField(generatedId = true, columnName = COLUMNNAME_ID, useGetSet = true)
    private int id;
    @DatabaseField(columnName = COLUMNNAME_NAME, useGetSet = true, canBeNull = false, unique = true)
    private String name;
    @DatabaseField(columnName = COLUMNNAME_SEX, useGetSet = true, defaultValue = "1")
    private char sex;
    @DatabaseField(columnName = COLUMNNAME_BIRTHDAY, useGetSet = true)
    private Date birthday;
    @DatabaseField(columnName = COLUMNNAME_ADDRESS, useGetSet = true)
    private String address;
    @ForeignCollectionField(eager = true)
    private ForeignCollection<ArticleBean> articles;

    public UserBean() {
    }

    public UserBean(String name, char sex, Date birthday, String address) {
        this.name = name;
        this.sex = sex;
        this.birthday = birthday;
        this.address = address;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public ForeignCollection<ArticleBean> getArticles() {
        return articles;
    }

    public void setArticles(ForeignCollection<ArticleBean> articles) {
        this.articles = articles;
    }

    @Override
    public String toString() {
        return "UserBean{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex=" + sex +
                ", birthday=" + birthday +
                ", address='" + address + '\'' +
                ", articles=" + articles +
                '}';
    }
}

　　ArticleBean類中的代碼如下：

import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.table.DatabaseTable;

/**
 * ArticleBean實體類，存儲article數據表中的數據
 * 數據庫中的article表和user表是關聯的，因此我們需要在article表中配置外鍵
 * <p>
 * foreignColumnName：外鍵約束指向的類中的屬性名
 * foreign：當前字段是否是外鍵
 * foreignAutoRefresh：如果這個屬性設置為true，在關聯查詢的時候就不需要再調用refresh()方法了
 */
@DatabaseTable(tableName = "article")
public class ArticleBean {
    // article表中各個字段的名稱
    public static final String COLUMNNAME_ID = "id";
    public static final String COLUMNNAME_TITLE = "title";
    public static final String COLUMNNAME_CONTENT = "content";
    public static final String COLUMNNAME_USER = "user_id";

    @DatabaseField(generatedId = true, columnName = COLUMNNAME_ID, useGetSet = true)
    private int id;
    @DatabaseField(columnName = COLUMNNAME_TITLE, useGetSet = true, canBeNull = false, unique = true)
    private String title;
    @DatabaseField(columnName = COLUMNNAME_CONTENT, useGetSet = true)
    private String content;
    @DatabaseField(columnName = COLUMNNAME_USER, foreign = true, foreignAutoRefresh = true, foreignAutoCreate = true,
            foreignColumnName = UserBean.COLUMNNAME_ID)
    private UserBean user_id;

    public ArticleBean() {
    }

    public ArticleBean(String title, String content, UserBean user) {
        this.title = title;
        this.content = content;
        this.user_id = user;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public UserBean getUser() {
        return user_id;
    }

    public void setUser(UserBean user) {
        this.user_id = user;
    }

    @Override
    public String toString() {
        return "ArticleBean{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                ", user=" + user_id +
                '}';
    }
}

　　從兩個實體類中的代碼來看，ORMLite和JavaWeb框架中的Hibernate相似，都是使用注解的方式來標注數據庫中的表、字段、關聯關系的，這也是ORMLite的工作原理：ORMLite是基於反射機制工作的，然而這也成為了ORMLite的一個非常致命的缺點，性能不好。因此，如果是對想能要求不高的項目，我們可以考慮使用ORMLite，而如果項目對性能要求較高，我們可以考慮使用GreenDAO。

　　至於各個標簽、各個屬性的用途，將在本貼的最后貼出。

　　現在讓我們再來看ORMLite中的另一個比較重要的東西——DAO。DAO是用來將操作某張表的方法（增、刪、改、查）封裝起來的工具類。下面來看代碼：

　　UserDao類中的代碼：

import android.content.Context;

import com.example.itgungnir.testormlite.db.DatabaseHelper;
import com.example.itgungnir.testormlite.entity.UserBean;
import com.j256.ormlite.dao.Dao;

import java.sql.SQLException;
import java.util.List;

/**
 * 操作User數據表的Dao類，封裝這操作User表的所有操作
 * 通過DatabaseHelper類中的方法獲取ORMLite內置的DAO類進行數據庫中數據的操作
 * <p>
 * 調用dao的create()方法向表中添加數據
 * 調用dao的delete()方法刪除表中的數據
 * 調用dao的update()方法修改表中的數據
 * 調用dao的queryForAll()方法查詢表中的所有數據
 */
public class UserDao {
    private Context context;
    // ORMLite提供的DAO類對象，第一個泛型是要操作的數據表映射成的實體類；第二個泛型是這個實體類中ID的數據類型
    private Dao<UserBean, Integer> dao;

    public UserDao(Context context) {
        this.context = context;
        try {
            this.dao = DatabaseHelper.getInstance(context).getDao(UserBean.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 向user表中添加一條數據
    public void insert(UserBean data) {
        try {
            dao.create(data);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 刪除user表中的一條數據
    public void delete(UserBean data) {
        try {
            dao.delete(data);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 修改user表中的一條數據
    public void update(UserBean data) {
        try {
            dao.update(data);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 查詢user表中的所有數據
    public List<UserBean> selectAll() {
        List<UserBean> users = null;
        try {
            users = dao.queryForAll();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return users;
    }

    // 根據ID取出用戶信息
    public UserBean queryById(int id) {
        UserBean user = null;
        try {
            user = dao.queryForId(id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return user;
    }
}

　　ArticleDao類中的代碼：

import android.content.Context;

import com.example.itgungnir.testormlite.db.DatabaseHelper;
import com.example.itgungnir.testormlite.entity.ArticleBean;
import com.j256.ormlite.dao.Dao;

import java.sql.SQLException;
import java.util.List;

/**
 * 操作article表的DAO類
 */
public class ArticleDao {
    private Context context;
    // ORMLite提供的DAO類對象，第一個泛型是要操作的數據表映射成的實體類；第二個泛型是這個實體類中ID的數據類型
    private Dao<ArticleBean, Integer> dao;

    public ArticleDao(Context context) {
        this.context = context;
        try {
            this.dao = DatabaseHelper.getInstance(context).getDao(ArticleBean.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 添加數據
    public void insert(ArticleBean data) {
        try {
            dao.create(data);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 刪除數據
    public void delete(ArticleBean data) {
        try {
            dao.delete(data);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 修改數據
    public void update(ArticleBean data) {
        try {
            dao.update(data);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 通過ID查詢一條數據
    public ArticleBean queryById(int id) {
        ArticleBean article = null;
        try {
            article = dao.queryForId(id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return article;
    }

    // 通過條件查詢文章集合（通過用戶ID查找）
    public List<ArticleBean> queryByUserId(int user_id) {
        try {
            return dao.queryBuilder().where().eq(ArticleBean.COLUMNNAME_USER, user_id).query();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }
}

　　最后就是測試代碼了。我們直接在MainActivity中寫代碼，然后運行看結果。在MainActivity中，我們首先創建兩張表並向表中添加數據，然后從數據表中分別取出數據，展示到TextView中。代碼如下：

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;

import com.example.itgungnir.testormlite.dao.ArticleDao;
import com.example.itgungnir.testormlite.dao.UserDao;
import com.example.itgungnir.testormlite.entity.ArticleBean;
import com.example.itgungnir.testormlite.entity.UserBean;
import com.j256.ormlite.dao.ForeignCollection;

import java.util.Date;
import java.util.Iterator;

public class MainActivity extends AppCompatActivity {
    private TextView tv;

    private StringBuffer contentBuffer;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = (TextView) findViewById(R.id.tv);
        contentBuffer = new StringBuffer();
        initData();
        initView();
    }

    // 初始化數據
    private void initData() {
        // 添加用戶數據
        UserBean userData = new UserBean("張三", '1', new Date(), "北京");
        new UserDao(MainActivity.this).insert(userData);
        // 添加文章數據
        ArticleBean articleData = new ArticleBean("標題", "內容內容內容內容內容內容", userData);
        new ArticleDao(MainActivity.this).insert(articleData);
    }

    // 初始化視圖
    private void initView() {
        // 從數據庫中根據ID取出文章信息
        ArticleBean articleBean = new ArticleDao(MainActivity.this).queryById(1);
        contentBuffer.append(articleBean.toString());
        // 根據取出的用戶id查詢用戶信息
        UserBean userBean = new UserDao(MainActivity.this).queryById(articleBean.getUser().getId());
        contentBuffer.append("\n\n" + userBean.toString());
        // 從用戶信息中取出關聯的文章列表信息
        ForeignCollection<ArticleBean> articles = userBean.getArticles();
        Iterator<ArticleBean> iterator = articles.iterator();
        contentBuffer.append("\n\n");
        while (iterator.hasNext()) {
            ArticleBean article = iterator.next();
            contentBuffer.append(article.toString() + "\n");
        }
        // 設置TextView的文本
        tv.setText(contentBuffer.toString());
    }
}

　　運行結果如下圖所示：

　　最后，貼出ORMLite中常用標簽和各個屬性代表的意義：

　　常見標簽：

 DatabaseTable：通過其中的tableName屬性指定數據庫名稱
 DatabaseField：代表數據表中的一個字段
 ForeignCollectionField：一對多關聯，表示一個UserBean關聯着多個ArticleBean（必須使用ForeignCollection集合）

　　常見屬性：

id：當前字段是不是id字段（一個實體類中只能設置一個id字段）
columnName：表示當前屬性在表中代表哪個字段
generatedId：設置屬性值在數據表中的數據是否自增
useGetSet：是否使用Getter/Setter方法來訪問這個字段
canBeNull：字段是否可以為空，默認值是true
unique：是否唯一
defaultValue：設置這個字段的默認值
foreignColumnName：外鍵約束指向的類中的屬性名
foreign：當前字段是否是外鍵
foreignAutoRefresh：如果這個屬性設置為true，在關聯查詢的時候就不需要再調用refresh()方法了

　　以上就是對ORMLite框架的基本使用了，希望對大家有幫助~~~~