框架】之ORMLite的使用

阿新 • • 發佈：2018-12-17

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框架的基本使用了，希望對大家有幫助~~~~

框架】之ORMLite的使用

框架】之ORMLite的使用

【SSH框架】之Struts2系列（一）

【SSH框架】之Hibernate系列一

【SSH框架】之Spring系列（一）

【剖析 | SOFARPC 框架】之SOFARPC 單機故障剔除剖析

【剖析 | SOFARPC 框架】之SOFARPC 同步非同步實現剖析

【Laravel 框架】之目錄結構

框架】之可懸浮列表StickyHeadersRecyclerView

框架】之Retrofit+RxJava的使用

框架】之XBanner的使用

【集合框架】之深入分析HashMap

轉：【Java並發編程】之十九：並發新特性—Executor框架與線程池（含代碼）

“一切都是消息”--MSF（消息服務框架）之【請求-響應】模式

【ci框架基礎】之部署百度編輯器

【集合框架】JDK1.8源碼分析之HashMap（一）轉載

【SSH框架】系列之 Spring 整合 Hibernate 框架

反向教學系列之——Django入門（一）【不需知道web框架】

【我們一起寫框架】MVVM的WPF框架之綁定（二）

【剖析 | SOFARPC 框架】系列之SOFARPC序列化比較

【機器學習+sklearn框架】（一）線性模型之Linear Regression

框架】之ORMLite的使用

相關推薦