2. 程式人生 > >資料庫框架GreenDao——比Realm好一點

資料庫框架GreenDao——比Realm好一點

阿新 • • 發佈：2019-02-20

說實話android的資料庫確實比較難用，尤其是資料量較大的時候。使用的SQL語句可能就比較多了。再加上佔位符，體積龐大。於是realm,greendao這些自動建立資料庫的就出現了。

Realm

realm優點：比SQLite更簡潔，更省空間，可以只儲存在記憶體，應用關閉自動清理，自帶加密功能。呼叫方法易讀，易用。

缺點：
1.資料必須與資料庫同步，第一次set之後，更新必須資料庫的資料也要更新，簡直有點霸王條款的意思？我每個物件都要寫兩次，一個對應資料庫，一個對應其他的，這不太科學。
2.不能繼承RealmObject以外的類【給的RealmModel實現方式是假的，繼承就bug】。

資料庫初始化

Realm.init(this);
        RealmConfiguration config = new RealmConfiguration.Builder()
                .name(Config.dbName)
                .schemaVersion(Config.dbVersion)
                //.isMemory()//記憶體快取用
                .encryptionKey(Config.dbKey.getBytes())//加密字串長度64即byte128
                .migration
 
(DBUtil.getIntance())//升級資料庫處理類（實現RealmMigration介面）
                .build();
        Realm.setDefaultConfiguration(config);

資料庫升級(需要實現RealmMigration )

public class DBUtil implements RealmMigration {
    private static  DBUtil sIntance;
    public DBUtil() {
    }

    /**
     * 雙檢索單例
     * @return
 

     */
    public  static  DBUtil getIntance(){
        if (sIntance == null) {
            synchronized (DBUtil.class) {
                if (sIntance == null) {
                    sIntance = new DBUtil();
                }
            }
        }



        return  sIntance;
    }

    /**
     * 獲取realm物件
     * @return
     */
    public Realm getRealm(){
        Realm realm =getDefaultInstance();
        return  realm;
    }

    /**
     * 版本升級處理
     * @param realm
     * @param oldVersion
     * @param newVersion
     */
    @Override
    public void migrate(DynamicRealm realm, long oldVersion, long newVersion) {
        RealmSchema schema = realm.getSchema();
        switch ((int)oldVersion){
//            case 0:{
//                RealmObjectSchema personSchema = schema.get("User");//獲取表
////                //新增@Required的id
//                personSchema
//                        .addField("outerId", String.class)//新增欄位
//                        .transform(new RealmObjectSchema.Function() {
//                            @Override
//                            public void apply(DynamicRealmObject obj) {
//                                obj.set("outerId", "1");//為id設定預設值
//                            }
//                        });
////                        .removeField("age");//移除age屬性
//                //注意version不要break,因為前面的版本都要升級
//            }
        }

    }
}

realm bean初始化

public class User extends RealmObject {
    private String id;
    private String name;

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public NormalUser toNormalUser(){
        NormalUser user = new NormalUser();
        user.setId(id);
        user.setName(name);
        return user;
    }

}

dao層（手寫）

public class UserDao implements BaseDao<User> {
    private UserDao(){
    }

    private Realm realm;
    private Realm getRealm(){
        if(realm == null)
            realm = DBUtil.getIntance().getRealm();
        return realm;
    }

    private static UserDao dao;
    public static UserDao getInstance(){
        if(dao == null)
            dao = new UserDao();
        return dao;
    }

    @Override
    public void insert(final User user) throws Exception {
        getRealm().executeTransaction(new Realm.Transaction() {
            @Override
            public void execute(Realm realm) {
                User u = realm.createObject(User.class);
                u.setId(user.getId());
                u.setName(user.getName());
            }
        });
    }

    @Override
    public List<User> find() throws Exception {

        List<User> mlist = null;
        mlist =  getRealm().where(User.class).findAllSorted("id", Sort.ASCENDING);
        return mlist;
    }

    @Override
    public void update(final User user) throws Exception {
        getRealm().executeTransaction(new Realm.Transaction() {
            @Override
            public void execute(Realm realm) {
                User u=realm.where(User.class).equalTo("id",user.getId()).findFirst();
                u.setName(user.getName());
            }

        });
    }


    @Override
    public void delete(final String id) throws Exception {
        getRealm().executeTransaction(new Realm.Transaction() {
            @Override
            public void execute(Realm realm) {
                RealmResults<User> result = realm.where(User.class).equalTo("id", id).findAll();
                if(result!=null)
                    result.deleteAllFromRealm();
            }
        });

    }

    @Override
    public void close() {
        getRealm().close();
    }

    //分頁查詢
    public static <E extends RealmModel> List<E> getLimitList(RealmResults<E> data, int offset, int limit) {
        List<E> obtainList = new ArrayList();
        Realm realm = Realm.getDefaultInstance();
        if (data.size() == 0 ){
            return obtainList;
        }
        for (int i = offset; i < offset + limit; i++) {
            if (i >= data.size()) {
                break;
            }
            E temp = realm.copyFromRealm(data.get(i));
            obtainList.add(temp);
        }
        realm.close();
        return obtainList;
    }
}

realm插入：

try {
                    dao.insert(user);
                    dao.insert(user2);
                    dao.insert(user3);
                    List<User> users = dao.find();
                    for (int i = 0; i < users.size(); i++) {
                        Toast.makeText(this, "插入資料" + users.get(i), Toast.LENGTH_LONG).show();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }

realm刪除：

try {
                    List<User> users = dao.find();
                    if (users != null && users.size() > 0) {
                        User user = users.get(0);
                        String id = user.getId();
                        dao.delete(id);
                        Toast.makeText(this, "刪除資料", Toast.LENGTH_LONG).show();
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }

realm更新

List<User> users = null;
                try {
                    users = dao.find();
                    if (users != null && users.size() > 0) {
                        NormalUser user = users.get(0).toNormalUser();
                        user.setName("userChange");
                        dao.update(user.toDBUser());
                        Toast.makeText(this,"更新資料"+user, Toast.LENGTH_LONG).show();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }

realm查詢

try {
                    List<User> users = dao.find();
                    for(User user:users){
                        Toast.makeText(this,user.toString(), Toast.LENGTH_LONG).show();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }

GreenDao

greenDao優點：可和Sqlcipher連用【一直要用sqlcipher，感激】，entity的get,set和構造器自動生成，封裝了dao方法。
缺點：
1.不能繼承！【確切說是不能繼承欄位，繼承欄位不會成為表字段，如果有抽象方法還是可以繼承的】
2.沒有主鍵的時候刪除和更新失敗，不過還好也可以用SQL代替，勉強忍受。必須sql這點太奇怪了，sqlite本身都沒這樣要求啊。對於短的sql語句，操作不方便，還不如直接sql。
3.我用了3+的版本，驚訝的是居然不能升級。。。只能建立臨時表，好無奈，身為資料庫居然不能升級（升級後資料被刪除），只能臨時表拷貝。不過這方法不容易出現數據庫升級失敗的奇怪問題，或許可以沿用。

為什麼都不能繼承欄位呢？完全不懂啊。。。同事用的greendao介紹給我，看到他用的抽象父類抽象公共get，set方法感覺好無奈。。。不然就只能做個介面卡了，一樣的麻煩。實在不行就只能自己想辦法寫一個封裝了，自己寫的只能簡化sql呼叫過程，其他的應該做不到。。。有空再解決吧。

資料庫初始化

ublic class DBManager {
    private static final String PWD = "123";

    private static DaoSession encryptedSession;
    private static final String DB_NAME = "my.db";
    public static DaoSession getSession(){
        if(encryptedSession == null){
            DBHelper dbHelper = new DBHelper(CacheForAndorid.getSuperContext(),DB_NAME,null);
            encryptedSession = new DaoMaster(dbHelper.getEncryptedWritableDb(PWD)).newSession();
        }
        return encryptedSession;
    }

    private static DBUserDao userDao;
    public static DBUserDao getMyDBDao(){
        if(userDao == null){
            userDao = getSession().getDBUserDao();
        }
        return userDao;
    }

    private static DBUserNoKeyDao noKeyDao;
    public static DBUserNoKeyDao getNoKeyDao(){
        if(noKeyDao == null){
            noKeyDao = getSession().getDBUserNoKeyDao();
        }
        return noKeyDao;
    }
}

資料庫更新

public class MigrationHelper {

    private static final String CONVERSION_CLASS_NOT_FOUND_EXCEPTION = "MIGRATION HELPER - CLASS DOESN'T MATCH WITH THE CURRENT PARAMETERS";
    private static MigrationHelper instance;

    public static MigrationHelper getInstance() {
        if (instance == null) {
            instance = new MigrationHelper();
        }
        return instance;
    }

    public void migrate(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {

        generateTempTables(db, daoClasses);
        DaoMaster.dropAllTables(db, true);
        DaoMaster.createAllTables(db, false);
        restoreData(db, daoClasses);
    }

    /**
     * 生成臨時列表
     *
     * @param db
     * @param daoClasses
     */
    private void generateTempTables(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        for (int i = 0; i < daoClasses.length; i++) {
            DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);

            String divider = "";
            String tableName = daoConfig.tablename;
            String tempTableName = daoConfig.tablename.concat("_TEMP");
            ArrayList<String> properties = new ArrayList<>();

            StringBuilder createTableStringBuilder = new StringBuilder();

            createTableStringBuilder.append("CREATE TABLE ").append(tempTableName).append(" (");

            for (int j = 0; j < daoConfig.properties.length; j++) {
                String columnName = daoConfig.properties[j].columnName;

                if (getColumns(db, tableName).contains(columnName)) {
                    properties.add(columnName);

                    String type = null;

                    try {
                        type = getTypeByClass(daoConfig.properties[j].type);
                    } catch (Exception exception) {
                        exception.printStackTrace();
                    }

                    createTableStringBuilder.append(divider).append(columnName).append(" ").append(type);

                    if (daoConfig.properties[j].primaryKey) {
                        createTableStringBuilder.append(" PRIMARY KEY");
                    }

                    divider = ",";
                }
            }
            createTableStringBuilder.append(");");

            db.execSQL(createTableStringBuilder.toString());

            StringBuilder insertTableStringBuilder = new StringBuilder();

            insertTableStringBuilder.append("INSERT INTO ").append(tempTableName).append(" (");
            insertTableStringBuilder.append(TextUtils.join(",", properties));
            insertTableStringBuilder.append(") SELECT ");
            insertTableStringBuilder.append(TextUtils.join(",", properties));
            insertTableStringBuilder.append(" FROM ").append(tableName).append(";");

            db.execSQL(insertTableStringBuilder.toString());

        }
    }

    /**
     * 儲存新的資料庫表 以及資料
     *
     * @param db
     * @param daoClasses
     */
    private void restoreData(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        for (int i = 0; i < daoClasses.length; i++) {
            DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
            String tableName = daoConfig.tablename;
            String tempTableName = daoConfig.tablename.concat("_TEMP");
            ArrayList<String> properties = new ArrayList();

            for (int j = 0; j < daoConfig.properties.length; j++) {
                String columnName = daoConfig.properties[j].columnName;

                if (getColumns(db, tempTableName).contains(columnName)) {
                    properties.add(columnName);
                }
            }

            StringBuilder insertTableStringBuilder = new StringBuilder();

            insertTableStringBuilder.append("INSERT INTO ").append(tableName).append(" (");
            insertTableStringBuilder.append(TextUtils.join(",", properties));
            insertTableStringBuilder.append(") SELECT ");
            insertTableStringBuilder.append(TextUtils.join(",", properties));
            insertTableStringBuilder.append(" FROM ").append(tempTableName).append(";");

            StringBuilder dropTableStringBuilder = new StringBuilder();
            dropTableStringBuilder.append("DROP TABLE ").append(tempTableName);
            db.execSQL(insertTableStringBuilder.toString());
            db.execSQL(dropTableStringBuilder.toString());
        }
    }

    private String getTypeByClass(Class<?> type) throws Exception {
        if (type.equals(String.class)) {
            return "TEXT";
        }
        if (type.equals(Long.class) || type.equals(Integer.class) || type.equals(long.class)) {
            return "INTEGER";
        }
        if (type.equals(Boolean.class)) {
            return "BOOLEAN";
        }

        Exception exception = new Exception(CONVERSION_CLASS_NOT_FOUND_EXCEPTION.concat(" - Class: ").concat(type.toString()));
        exception.printStackTrace();
        throw exception;
    }

    private List<String> getColumns(Database db, String tableName) {
        List<String> columns = new ArrayList<>();
        Cursor cursor = null;
        try {
            cursor = db.rawQuery("SELECT * FROM " + tableName + " limit 1", null);
            if (cursor != null) {
                columns = new ArrayList<>(Arrays.asList(cursor.getColumnNames()));
            }
        } catch (Exception e) {
            Log.v(tableName, e.getMessage(), e);
            e.printStackTrace();
        } finally {
            if (cursor != null)
                cursor.close();
        }
        return columns;
    }
}
public class DBHelper extends DaoMaster.OpenHelper {

    public DBHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
        super(context, name, factory);
    }

    /**
     * 資料庫升級
     * @param db
     * @param oldVersion
     * @param newVersion
     */
    @Override
    public void onUpgrade(Database db, int oldVersion, int newVersion) {
        //操作資料庫的更新 有幾個表升級都可以傳入到下面
        MigrationHelper.getInstance().migrate(db,DBUserDao.class);
    }

}

bean

有主鍵

@Entity
public class DBUser {
    @Id(autoincrement = true)
    private Long id;
    private String name;
}

無主鍵

@Entity
public class DBUserNoKey {
    private String name;
    private String password;
}

新增資料（dao層不用寫，點選build自動生成）

有無主鍵相同

DBManager.getMyDBDao().insert(user);
        ToastUtil.shorts("儲存成功");

刪除

有主鍵

DBManager.getMyDBDao().delete(user);

無主鍵（必須sql，否則失敗）

DBManager.getSession().getDatabase().execSQL("delete from DBUSER_NO_KEY where name='"+userName+"'");

修改

有主鍵

DBManager.getMyDBDao().update(oldUser);

無主鍵（一樣必須SQL,不sql就bug）

DBManager.getSession().getDatabase()
                    .execSQL("update DBUSER_NO_KEY set password=? where name=?"
                            ,new Object[]{newUser.getPassword(),newUser.getName()});

查詢

有無主鍵相同

Query<DBUserNoKey> query= DBManager.getNoKeyDao().queryBuilder().build();
        List<DBUserNoKey> dbUsers = query.list();
        for(DBUserNoKey dbUser:dbUsers){
            ToastUtil.longs("id="+dbUser.getName()+"\nname="+dbUser.getPassword());
        }

補充，greendao的版本配置在app的build.gradle裡面
greendao {
schemaVersion 3//此處為版本號
daoPackage ‘生成dao等資料庫檔案包名’
targetGenDir ‘src/main/java’
}

相關推薦

資料庫框架GreenDao——比Realm好一點

說實話android的資料庫確實比較難用，尤其是資料量較大的時候。使用的SQL語句可能就比較多了。再加上佔位符，體積龐大。於是realm,greendao這些自動建立資料庫的就出現了。 Realm realm優點：比SQLite更簡潔，更省空間，可以只儲

Android資料庫框架GreenDao&Realm實戰分析

Android開發的童鞋應該都知道，使用官方的SQLite資料庫，可以滿足我們大部分增刪改查的需求，然而隨著Android技術的逐步成長，你會慢慢發現SQLite越來越不能滿足我們的需求。總結為以下主要幾點： 1、創表，增刪改查需要些大量程式碼，開發效率極低

一個mybatis開發框架，比JPA好用比MyBatis generator好用

count object 配置數據庫連接 用例 簡化 git wire down -s fastmybatis fastmybatis是一個mybatis開發框架，目的為簡化mybatis的開發，讓開發更高效。 零配置快速上手 無需編寫xml文件即可完成CRUD操作 支持

Android 資料庫框架GreenDao與LitePal

更多幹貨 分散式實戰（乾貨） spring cloud 實戰（乾貨） mybatis 實戰（乾貨） spring boot 實戰（乾貨） React 入門實戰（乾貨） 構建中小型網際網路企業架構（乾貨） python 學習持

Android 資料庫框架 —— GreenDao

package cn.hlq.greendaostudy.entity; import org.greenrobot.greendao.annotation.Entity; import org.greenrobot.greendao.annotation.Id; import org.greenrobot

Android 中資料庫框架GreenDao與LitePal對比、整合、使用詳解,greendao與原生SQLite效能對比

2.LitePal框架詳解。【操作非常簡單，適合於資料庫操作較少的專案】 3.greendao重要的3個類【GreenDaoManager管理類   MigrationHelper資料庫升級合併類  MyOpenHelper資料庫升級操作類】【greendao快取問題】

Android資料庫框架greenDao學習筆記 2

引言 上篇部落格中介紹了greenDao的整合方式，這篇部落格，我們介紹如何使用greenDao建立我們需要的資料表。補一張圖（來自官網），來理解greenDao，大家意會吧。 註解 先上一張圖，來對greenDao的註解有一個直觀的認識： Schema 通過在Gr

Swift資料庫框架Realm的使用

GitHub地址：https://github.com/realm/realm-cocoa 不同於SQLite和CoreData，Realm跨平臺簡單易用，並可以監聽資料庫的變化。 1.使用CocoaPods匯入Realm pod 'RealmSwift', '3.11.0'

greenDao 資料庫框架簡單使用和Fresco 簡單載入圖片

首先 在專案下 -----------在repositories的括號里加入倉庫---- mavenCentral() ------------- 在dependencies的括號里加入外掛--------- classpath ‘org.greenrobot:

GreenDao資料庫框架的簡單使用

Greendao簡介 Greendao是一款用於資料庫建立與管理的框架，由於原生SQLite語言比較複雜繁瑣，使得不少程式 員不得不去學習SQLite原生語言，但是學習成本高，效率低下，所以不少公司致力於開發一款簡單的資料庫管理框架，較為著名的就有Greendao和ORMLite，但是就資料

Android 資料庫ORM框架——GreenDao

最近在對開發專案的效能進行優化。由於專案裡涉及了大量的快取處理和資料庫運用，需要對資料庫進行頻繁的讀寫、查詢等操作。因此首先想到了對整個專案的資料庫框架進行優化。 原先使用android本身內建的sqllite，也就是用的最基本的SQLiteOpenHelper方法，這種方法對自己來說比較方便易懂。但是

GreenDao資料庫框架 最精簡使用教程 並對其進行簡單封裝

GreenDao框架的使用步驟:(android studio) 1.首先在project的build.gradle下進行新增如下依賴: dependencies { classpath 'org.greenrobot:greendao-grad

Android資料庫框架一、GreenDao

簡述:greenDAO 是一個將物件對映到 SQLite 資料庫中的輕量且快速的 ORM 解決方案。 其優點還包括以下幾點: 1.存取速度快;  2.支援資料庫加密;  3.輕量級;  4.啟用實體;  5.支援快取;  6.程式碼自動生成; 7.greenDAO 支援 pr

Android開源：資料庫ORM框架GreenDao學習（三）封裝工具類使用

部落格轉載地址：http://www.it165.net/pro/html/201401/9026.html         上一篇中講解了基本的增刪改查，本篇繼續講解 QureyBuilder 使用，及工具類封裝使用   一、使用QureyBuilder實現表的增刪改查

Android開發——資料庫框架Suger遇到的大坑（依據列名查詢不到資料解決辦法）

Android開發——資料庫框架Suger遇到的大坑（依據列名查詢不到資料解決辦法） JavaBean命名出現大寫，資料無法正常儲存（用的是Suger第二種操作方式，第一種沒有測試） 習慣中對Bean中變數的命名會出現大寫字母，但使用Suger操作這樣的資料會出現問題，比如我這樣命名

Android開發——資料庫框架Suger遇到的大坑（Gson和Suger的複用Bean請見“大坑三”）

Android開發——資料庫框架Suger遇到的大坑（Gson和Suger的複用Bean請見“大坑三”） 大坑一 自己寫了一個Demo按照官網以及GitHub上Suger的使用步驟完整走下來，Demo閃退，以插入資料為例 User user = new User("liao",

Android ORM框架GreenDao入門學習

最近想了解一下關於Android ORM的東西，在網上一搜，框架還真不少，很多人都說GreenDao效能不錯，這週末就好好搞了下。 現在Goodle推出了Android studio這款開發利器，是用Gradle構建，感覺還不錯。以下專案都是用Android studio 0.8.14開發。

Android 資料庫框架litepal的使用

來源：郭霖大神http://blog.csdn.net/guolin_blog/article/details/38461239 要想熟練地操作任何一個數據庫，最最基本的要求就是要懂SQL語言，這也是每個程式設計師都應該掌握的技能。雖說SQL博大精深，要想精通確實很難，但最基本的一

AI框架大比拼，你喜歡哪一個？

轉載自https://baijiahao.baidu.com/s?id=1589649119274801302&wfr=spider&for=pc 人工智慧（AI）已經存在很長時間了。然而，由於這一領域的巨大進步，近年來它已成為一個流行語。人工智慧曾經被稱為一個完整的書呆子和天才

RxCache 整合 Android 的持久層框架 greenDAO、Room

一. 背景 RxCache 是一個支援 Java 和 Android 的 Local Cache 。 之前的文章給 Java 和 Android 構建一個簡單的響應式Local Cache曾詳細介紹過它。 RxCache 包含了兩級快取： Memory 和 Persistence 。