數據庫GreenDao.jpg

之前在開發過程中，數據庫基本上會使用Litepal或者SQlite自己寫，最近換新環境，公司原先使用的數據庫就是GreenDao，在各種情況的作用下，準備了解下GreenDao，順便寫一篇文章記錄下GreenDao的基本使用！

Android開發者聚集地

本文主要從如下幾個方面進行講解

存儲的數據庫結構

GreenDao的優缺點

GreenDao的使用配置

使用GreenDao實現數據的增刪改查

GreenDao的注解使用

GreenDao的關系處理

GreenDao的升級

GreenDao數據庫加密

項目地址AserbaosAndroid

總結

參考博客
簡書暫時不支持目錄，如果想看該文章帶目錄版本，請點擊跳轉該文章的CSDN地址

咱們先看一波最終的效果圖：文章最后有項目地址;

greendao

1. 存儲的數據庫結構

學習數據庫之前，我們先得設計自己的數據庫，不多廢話，下面是我此次學習的數據庫結構，后面所有的數據請參考這個圖進行學習：

GreenDao關系圖.jpg

2. GreenDao的介紹

簡單的GreenDao的介紹，閑麻煩的可以直接跳到GreenDao使用開始看。

什么是GreenDao？

GreenDAO是一個開源的Android ORM(“對象/關系映射”)，通過ORM（稱為“對象/關系映射”），在我們數據庫開發過程中節省了開發時間！

GreenDao的原理.png

GreenDao的官方文檔

GreenDao：適用于您的SQLite數據庫的Android ORM

GreenDao的github地址

GreenDao的Google討論區

GreenDao 加密SQLCipher for Android官方說明地址

GreenDao使用文檔

GreenDao的作用？

通過GreenDao，我們可以更快速的操作數據庫，我們可以使用簡單的面相對象的API來存儲，更新，刪除和查詢Java對象。

GreenDao的優缺點？

高性能，下面是官方給出的關于GreenDao，OrmLite和ActiveAndroid三種ORM解決方案的數據統計圖：

GreenDao性能對比圖.png

易于使用的強大API，涵蓋關系和連接；

最小的內存消耗;

小庫大小（<100KB）以保持較低的構建時間并避免65k方法限制;

數據庫加密：greenDAO支持SQLCipher，以確保用戶的數據安全;

3. GreenDao的使用

GreenDao的核心類有三個：分別是DaoMaster,DaoSession,XXXDao，這三個類都會自動創建，無需自己編寫創建！

• DaoMaster:：DaoMaster保存數據庫對象（SQLiteDatabase）并管理特定模式的DAO類（而不是對象）。它有靜態方法來創建表或刪除它們。它的內部類OpenHelper和DevOpenHelper是SQLiteOpenHelper實現，它們在SQLite數據庫中創建模式。
• DaoSession：管理特定模式的所有可用DAO對象，您可以使用其中一個getter方法獲取該對象。DaoSession還提供了一些通用的持久性方法，如實體的插入，加載，更新，刷新和刪除。
• XXXDao：數據訪問對象（DAO）持久存在并查詢實體。對于每個實體，greenDAO生成DAO。它具有比DaoSession更多的持久性方法，例如：count，loadAll和insertInTx。

• Entities ：可持久化對象。通常, 實體對象代表一個數據庫行使用標準 Java 屬性(如一個POJO 或 JavaBean )。

  
  GreenDao核心.png

1. 導入Gradle插件和Dao代碼生成

要在Android項目中使用GreenDao，您需要添加GreenDao Gradle插件并添加GreenDao庫：

導入插件

// 在 Project的build.gradle 文件中添加: buildscript {repositories {jcenter()mavenCentral() // add repository}dependencies {classpath 'com.android.tools.build:gradle:3.1.2'classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' // add plugin } }

配置相關依賴

// 在 Moudle:app的 build.gradle 文件中添加: apply plugin: 'com.android.application' apply plugin: 'org.greenrobot.greendao' // apply plugin dependencies { implementation 'org.greenrobot:greendao:3.2.2' // add library }

配置數據庫相關信息

greendao {schemaVersion 1 //數據庫版本號daoPackage 'com.aserbao.aserbaosandroid.functions.database.greenDao.db' // 設置DaoMaster、DaoSession、Dao 包名 targetGenDir 'src/main/java'//設置DaoMaster、DaoSession、Dao目錄 generateTests false //設置為true以自動生成單元測試。 targetGenDirTests 'src/main/java' //應存儲生成的單元測試的基本目錄。默認為 src / androidTest / java。 }

配置完成，在Android Studio中使用Build> Make Project，重寫build項目，GreenDao集成完成！

2. 創建存儲對象實體類

使用GreenDao存儲數據只需要在存儲數據類前面聲明@Entity注解就讓GreenDao為其生成必要的代碼：

@Entity public class Student {@Id(autoincrement = true) Long id; @Unique int studentNo;//學號 int age; //年齡 String telPhone;//手機號 String sex; //性別 String name;//姓名 String address;//家庭住址 String schoolName;//學校名字 String grade;//幾年級 ……getter and setter and constructor method…… }

3. GreenDao初始化

我們可以在Application中維持一個全局的會話。我們在Applicaiton進行數據庫的初始化操作：

/*** 初始化GreenDao,直接在Application中進行初始化操作*/private void initGreenDao() { DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "aserbao.db"); SQLiteDatabase db = helper.getWritableDatabase(); DaoMaster daoMaster = new DaoMaster(db); daoSession = daoMaster.newSession(); } private DaoSession daoSession; public DaoSession getDaoSession() { return daoSession; }

初始化完成之后重新rebuild一下項目會發現在設置的targetGenDir的目錄生成三個類文件，這個是GreenDao自動生成的！說明數據庫已經連接好了，咱們接下來只需要進行數據庫的增刪改查操作就行了。Let's Go!

4. 使用GreenDao實現增刪改查

1. 增

insert() 插入數據

@Overridepublic void insertData(Thing s) { DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession(); for (int i = 0; i < 1000; i++) { Student student = new Student(); student.setStudentNo(i); int age = mRandom.nextInt(10) + 10; student.setAge(age); student.setTelPhone(RandomValue.getTel()); String chineseName = RandomValue.getChineseName(); student.setName(chineseName); if (i % 2 == 0) { student.setSex("男"); } else { student.setSex("女"); } student.setAddress(RandomValue.getRoad()); student.setGrade(String.valueOf(age % 10) + "年紀"); student.setSchoolName(RandomValue.getSchoolName()); daoSession.insert(student); } }

insertOrReplace()數據存在則替換，數據不存在則插入

@Overridepublic void insertData(Thing s) { DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession(); for (int i = 0; i < 1000; i++) { Student student = new Student(); student.setStudentNo(i); int age = mRandom.nextInt(10) + 10; student.setAge(age); student.setTelPhone(RandomValue.getTel()); String chineseName = RandomValue.getChineseName(); student.setName(chineseName); if (i % 2 == 0) { student.setSex("男"); } else { student.setSex("女"); } student.setAddress(RandomValue.getRoad()); student.setGrade(String.valueOf(age % 10) + "年紀"); student.setSchoolName(RandomValue.getSchoolName()); daoSession.insertOrReplace(student);//插入或替換 } }

2. 刪

刪除有兩種方式：delete()和deleteAll()；分別表示刪除單個和刪除所有。

@Overridepublic void deleteData(Student s) { DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession(); daoSession.delete(s); } @Overridepublic void deleteAll() { DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession(); daoSession.deleteAll(Student.class); }

3. 改

通過update來進行修改：

@Overridepublic void updataData(Student s) { DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession(); daoSession.update(s); }

4. 查

查詢的方法有：

• loadAll()：查詢所有數據。
• queryRaw()：根據條件查詢。
• queryBuilder() : 方便查詢的創建，后面詳細講解。

public List queryAll(){List<Student> students = daoSession.loadAll(Student.class);return students; } @Overridepublic void queryData(String s) { List<Student> students = daoSession.queryRaw(Student.class, " where id = ?", s); mDataBaseAdapter.addNewStudentData(students); }

4. QueryBuilder的使用

編寫SQL可能很困難并且容易出現錯誤，這些錯誤僅在運行時才會被注意到。該QueryBuilder的類可以讓你建立你的實體，而不SQL自定義查詢，并有助于在編譯時已檢測錯誤。

我們先講下QueryBuilder的常見方法：

• where(WhereCondition cond, WhereCondition... condMore): 查詢條件，參數為查詢的條件！
• or(WhereCondition cond1, WhereCondition cond2, WhereCondition... condMore): 嵌套條件或者，用法同or。
• and(WhereCondition cond1, WhereCondition cond2, WhereCondition... condMore): 嵌套條件且，用法同and。
• join(Property sourceProperty, Class<J> destinationEntityClass):多表查詢，后面會講。
  輸出結果有四種方式，選擇其中一種最適合的即可，list()返回值是List,而其他三種返回值均實現Closeable,需要注意的不使用數據時游標的關閉操作：
• list （）所有實體都加載到內存中。結果通常是一個沒有魔法的 ArrayList。最容易使用。
• listLazy （）實體按需加載到內存中。首次訪問列表中的元素后，將加載并緩存該元素以供將來使用。必須關閉。
• listLazyUncached （）實體的“虛擬”列表：對列表元素的任何訪問都會導致從數據庫加載其數據。必須關閉。
• listIterator （）讓我們通過按需加載數據（懶惰）來迭代結果。數據未緩存。必須關閉。

GreenDao中SQL語句的縮寫，我們也了解下，源碼在Property中,使用的時候可以自己點進去查詢即可：

• eq()："equal ('=?')" 等于；
• notEq() ："not equal ('<>?')" 不等于；
• like()：" LIKE ?" 值等于；
• between()：" BETWEEN ? AND ?" 取中間范圍；
• in()：" IN (" in命令;
• notIn()：" NOT IN (" not in 命令;
• gt()：">?" 大于;
• lt()："<? " 小于;
• ge()：">=?" 大于等于;
• le()："<=? " 小于等于;
• isNull()：" IS NULL" 為空;
• isNotNull()：" IS NOT NULL" 不為空;

1. 使用QueryBuilder進行查詢操作

1. 簡單條件查詢

查詢當前Student表的所有的數據：

public List queryAllList(){DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();QueryBuilder<Student> qb = daoSession.queryBuilder(Student.class);List<Student> list = qb.list(); // 查出所有的數據 return list; }

查詢Name為“一”的所有Student:

public List queryListByMessage(String name){DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();QueryBuilder<Student> qb = daoSession.queryBuilder(Student.class);QueryBuilder<Student> studentQueryBuilder = qb.where(StudentDao.Properties.Name.eq("一")).orderAsc(StudentDao.Properties.Name);List<Student> studentList = studentQueryBuilder.list(); //查出當前對應的數據 return list; }

2. 原始查詢

通過原始的SQL查詢語句進行查詢！其實上面有提到QueryBuilder的目的就是方便快捷的編寫SQL查詢語句，避免我們自己在編寫過程中出錯！簡單介紹下通過QueryBuilder編寫數據庫，方式方法如下 ：

public List queryListBySqL(){ // 查詢ID大于5的所有學生DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();Query<Student> query = daoSession.queryBuilder(Student.class).where(new WhereCondition.StringCondition("_ID IN " + "(SELECT _ID FROM STUDENT WHERE _ID > 5)") ).build(); List<Student> list = query.list(); return list; }

3. 嵌套條件查詢

查詢Id大于5小于10，且Name值為"一"的數據：

public List queryList(){DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();QueryBuilder<Student> qb = daoSession.queryBuilder(Student.class);qb = daoSession.queryBuilder(Student.class);List<Student> list2 = qb.where(StudentDao.Properties.Name.eq("一"), qb.and(StudentDao.Properties.Id.gt(5), StudentDao.Properties.Id.le(50))).list(); return list2; }

取10條Id大于1的數據，且偏移2條

public List queryListByOther(){DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();QueryBuilder<Student> qb = daoSession.queryBuilder(Student.class);//搜索條件為Id值大于1，即結果為[2,3,4,5,6,7,8,9,10,11];// offset(2)表示往后偏移2個，結果為[4,5,6,7,8,9,10,11,12,13]; List<Student> list = qb.where(StudentDao.Properties.Id.gt(1)).limit(10).offset(2).list(); return list; }

4. 多次執行查找

使用QueryBuilder構建查詢后，可以重用 Query對象以便稍后執行查詢。這比始終創建新的Query對象更有效。如果查詢參數沒有更改，您可以再次調用list / unique方法。可以通過setParameter方法來修改條件參數值：

public List queryListByMoreTime(){DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();QueryBuilder<Student> qb = daoSession.queryBuilder(Student.class);//搜索條件為Id值大于1，即結果為[2,3,4,5,6,7,8,9,10,11];// offset(2)表示往后偏移2個，結果為[4,5,6,7,8,9,10,11,12,13]; Query<Student> query = qb.where(StudentDao.Properties.Id.gt(1)).limit(10).offset(2).build(); List<Student> list = query.list(); //通過SetParameter來修改上面的查詢條件，比如我們將上面條件修改取10條Id值大于5，往后偏移兩位的數據，方法如下！ query.setParameter(0,5); List<Student> list1 = query.list(); return list1; }

5. 在多個線程中使用QueryBuilder

如果在多個線程中使用查詢，則必須調用 forCurrentThread （）以獲取當前線程的Query實例。Query的對象實例綁定到構建查詢的擁有線程。

這使您可以安全地在Query對象上設置參數，而其他線程不會干擾。如果其他線程嘗試在查詢上設置參數或執行綁定到另一個線程的查詢，則會拋出異常。像這樣，您不需要同步語句。實際上，您應該避免鎖定，因為如果并發事務使用相同的Query對象，這可能會導致死鎖。

每次調用forCurrentThread （）時， 參數都會在使用其構建器構建查詢時設置為初始參數。

2. 使用QueryBuilder進行批量刪除操作

使用QueryBuilder進行批量刪除操作，不會刪除單個實體，但會刪除符合某些條件的所有實體。要執行批量刪除，請創建QueryBuilder，調用其 buildDelete （）方法，然后執行返回的 DeleteQuery。

例子：刪除數據庫中id大于5的所有其他數據

public boolean deleteItem(){ DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession(); QueryBuilder<Student> where = daoSession.queryBuilder(Student.class).where(StudentDao.Properties.Id.gt(5)); DeleteQuery<Student> deleteQuery = where.buildDelete(); deleteQuery.executeDeleteWithoutDetachingEntities(); return false; }

5. 注解講解

從GreenDao 3 使用注解來定義模型和實體，前面也講過，通過注解的使用可以快速構建數據庫表，包括設置主鍵，自增，值是否唯一等等等……

下面我們來看下注解的簡單使用：

@Entity public class Student {@Id(autoincrement = true) Long id; @Unique int studentNo;//學號 int age; //年齡 String telPhone;//手機號 String sex; //性別 String name;//姓名 String address;//家庭住址 String schoolName;//學校名字 String grade;//幾年級 ……getter and setter and constructor method…… }

1. @Entity注解

@Entity是GreenDao必不可少的注解，只有在實體類中使用了@Entity注解GreenDao才會創建對應的表。當然我們也可以使用@Entity配置一些細節：

• schema：如果你有多個架構，你可以告訴GreenDao當前屬于哪個架構。
• active：標記一個實體處于活躍狀態，活動實體有更新、刪除和刷新方法。
• nameInDb：在數據中使用的別名，默認使用的是實體的類名。
• indexes：標記如果DAO應該創建數據庫表(默認為true)，如果您有多個實體映射到一個表，或者表的創建是在greenDAO之外進行的，那么將其設置為false。
• createInDb：標記創建數據庫表。
• generateGettersSetters：如果缺少，是否應生成屬性的getter和setter方法。

@Entity(schema = "myschema",active = true,nameInDb = "AWESOME_USERS", indexes = { @Index(value = "message DESC", unique = true) }, createInDb = false, generateConstructors = true, generateGettersSetters = true ) public class Student{ …… }

2. 基礎屬性注解（@Id，@Property，@NotNull，@Transient）

@Id
@Id注解選擇 long / Long屬性作為實體ID。在數據庫方面，它是主鍵。參數autoincrement = true 表示自增，id不給賦值或者為賦值為null即可（這里需要注意，如果要實現自增，id必須是Long,為long不行！)。

@Entity public class Student { @Id(autoincrement = true) Long id; …… }

@Property
允許您定義屬性映射到的非默認列名。如果不存在，GreenDAO將以SQL-ish方式使用字段名稱（大寫，下劃線而不是camel情況，例如 name將成為 NAME）。注意：您當前只能使用內聯常量來指定列名。

@Entity public class Student {@Id(autoincrement = true)Long id;@Property (nameInDb="name") //設置了，數據庫中的表格屬性名為"name",如果不設置，數據庫中表格屬性名為"NAME" String name; …… }

@NotNull ：設置數據庫表當前列不能為空 。

@Transient ：添加次標記之后不會生成數據庫表的列。標記要從持久性中排除的屬性。將它們用于臨時狀態等。或者，您也可以使用Java中的transient關鍵字。

3. 索引注解

• @Index：使用@Index作為一個屬性來創建一個索引，通過name設置索引別名，也可以通過unique給索引添加約束。
• @Unique：向索引添加UNIQUE約束，強制所有值都是唯一的。

@Entity public class Student { @Id(autoincrement = true) Long id; @Property(nameInDb="name") @Index(unique = true) String name; …… }

注意： 上面這種情況，約定name為唯一值，向數據庫中通過insert方法繼續添加已存在的name數據，會拋異常：

10-08 20:59:46.274 31939-31939/com.example.aserbao.aserbaosandroid E/AndroidRuntime: FATAL EXCEPTION: main Process: com.example.aserbao.aserbaosandroid, PID: 31939 android.database.sqlite.SQLiteConstraintException: UNIQUE constraint failed: STUDENT.name (Sqlite code 2067), (OS error - 2:No such file or directory) ……

若使用insertOrReplace()方法添加數據，當前數據庫中不會有重復的數據，但是重復的這條數據的id會被修改！若項目中有用到id字段進行排序的話，這一點需要特別注意。

4. 關系注解

關系型注解GreenDao中主要就兩個：

• @ToOne：定義與另一個實體（一個實體對象）的關系
• @ToMany：定義與多個實體對象的關系
  至于如何使用，我們馬上就講。

6. 一對一，一對多，多對多關系表的創建

平常項目中，我們經常會使用到多表關聯，如文章開頭所說的數據庫表結構設置的那樣！接下來我們來講如何通過GreenDao實現多表關聯。

1. 一對一

一個學生對應一個身份證號:
做法：

我們在Student中設置一個注解@ToOne(joinProperty = "name")

在創建Student的時候，將對應的數據傳遞給IdCard;
代碼部分：

學生Student代碼：

@Entity public class Student { @Id(autoincrement = true) Long id; @Unique int studentNo;//學號 int age; //年齡 String telPhone;//手機號 String sex; //性別 String name;//姓名 String address;//家庭住址 String schoolName;//學校名字 String grade;//幾年級 @ToOne(joinProperty = "name") IdCard student; ……getter and setter …… }

身份證IdCard代碼：

@Entity public class IdCard { @Id String userName;//用戶名 @Unique String idNo;//身份證號 ……getter and setter …… }

insert一組數據：

public void addStudent(){ DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession(); Student student = new Student(); student.setStudentNo(i); int age = mRandom.nextInt(10) + 10; student.setAge(age); student.setTelPhone(RandomValue.getTel()); String chineseName = RandomValue.getChineseName(); student.setName(chineseName); if (i % 2 == 0) { student.setSex("男"); } else { student.setSex("女"); } student.setAddress(RandomValue.getRoad()); student.setGrade(String.valueOf(age % 10) + "年紀"); student.setSchoolName(RandomValue.getSchoolName()); daoSession.insert(student); //插入對應的IdCard數據 IdCard idCard = new IdCard(); idCard.setUserName(userName); idCard.setIdNo(RandomValue.getRandomID()); daoSession.insert(idCard); }

ok,數據可以了！現在數據庫表插入完成了。

2. 一對多

一個人擁有多個信用卡
做法：

在我們在Student中設置@ToMany(referencedJoinProperty = "id");

我們在CreditCard中設置編寫對應的id主鍵；

Student的代碼：

@Entity public class Student { @Id(autoincrement = true) Long id; @Unique int studentNo;//學號 int age; //年齡 String telPhone;//手機號 String sex; //性別 String name;//姓名 String address;//家庭住址 String schoolName;//學校名字 String grade;//幾年級 @ToMany(referencedJoinProperty = "id") // 這個id是對應在CreditCard中的id List<CreditCard> creditCardsList; ……getter and setter …… }

CreditCard的代碼：

@Entity public class CreditCard { @Id Long id; Long userId; String userName;//持有者名字 String cardNum;//卡號 String whichBank;//哪個銀行的 int cardType;//卡等級，分類 0 ~ 5 ……getter and setter …… }

添加數據代碼：

public void addStudent(){ DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession(); Student student = new Student(); student.setStudentNo(i); int age = mRandom.nextInt(10) + 10; student.setAge(age); student.setTelPhone(RandomValue.getTel()); String chineseName = RandomValue.getChineseName(); student.setName(chineseName); if (i % 2 == 0) { student.setSex("男"); } else { student.setSex("女"); } student.setAddress(RandomValue.getRoad()); student.setGrade(String.valueOf(age % 10) + "年紀"); student.setSchoolName(RandomValue.getSchoolName()); daoSession.insert(student); //插入對應的CreditCard數據 for (int j = 0; j < random.nextInt(5) + 1 ; j++) { CreditCard creditCard = new CreditCard(); creditCard.setUserId(id); creditCard.setUserName(userName); creditCard.setCardNum(String.valueOf(random.nextInt(899999999) + 100000000) + String.valueOf(random.nextInt(899999999) + 100000000)); creditCard.setWhichBank(RandomValue.getBankName()); creditCard.setCardType(random.nextInt(10)); daoSession.insert(creditCard); } }

3. 多對多

一個學生有多個老師，老師有多個學生。
做法：

我們需要創建一個學生老師管理器(StudentAndTeacherBean)，用來對應學生和老師的ID;

我們需要在學生對象中，添加注解：

@ToMany
@JoinEntity(entity = StudentAndTeacherBean.class,sourceProperty = "studentId",targetProperty = "teacherId")
List<Teacher> teacherList;

我們需要在老師對象中，添加注解：@ToMany

@JoinEntity(entity = StudentAndTeacherBean.class,sourceProperty = "teacherId",targetProperty = "studentId") List<Student> studentList;

StudentAndTeacherBean代碼：

@Entity public class StudentAndTeacherBean { @Id(autoincrement = true) Long id; Long studentId;//學生ID Long teacherId;//老師ID ……getter and setter …… }

Student 代碼：

@Entity public class Student { @Id(autoincrement = true) Long id; @Unique int studentNo;//學號 int age; //年齡 String telPhone;//手機號 String sex; //性別 String name;//姓名 String address;//家庭住址 String schoolName;//學校名字 String grade;//幾年級 @ToMany @JoinEntity(entity = StudentAndTeacherBean.class,sourceProperty = "studentId",targetProperty = "teacherId") List<Teacher> teacherList; ……getter and setter …… }

Teacher代碼：

@Entity public class Teacher { @Id(autoincrement = true) Long id; @Unique int teacherNo;//職工號 int age; //年齡 String sex; //性別 String telPhone; String name;//姓名 String schoolName;//學校名字 String subject;//科目 @ToMany @JoinEntity(entity = StudentAndTeacherBean.class,sourceProperty = "teacherId",targetProperty = "studentId") List<Student> studentList; ……getter and setter …… }

數據添加：

public void addData(){ Student student = new Student(); student.setStudentNo(i); int age = mRandom.nextInt(10) + 10; student.setAge(age); student.setTelPhone(RandomValue.getTel()); String chineseName = RandomValue.getChineseName(); student.setName(chineseName); if (i % 2 == 0) { student.setSex("男"); } else { student.setSex("女"); } student.setAddress(RandomValue.getRoad()); student.setGrade(String.valueOf(age % 10) + "年紀"); student.setSchoolName(RandomValue.getSchoolName()); daoSession.insert(student); Collections.shuffle(teacherList); for (int j = 0; j < mRandom.nextInt(8) + 1; j++) { if(j < teacherList.size()){ Teacher teacher = teacherList.get(j); StudentAndTeacherBean teacherBean = new StudentAndTeacherBean(student.getId(), teacher.getId()); daoSession.insert(teacherBean); } } }

好了，成功;

7. 數據庫的升級

GreenDao的OpenHelper下有個 onUpgrade(Database db, int oldVersion, int newVersion)方法，當設置的數據庫版本改變時，在數據庫初始化的時候就會回調到這個方法，我們可以通過繼承OpenHelper重寫onUpgrade方法來實現數據庫更新操作：

GreenDao的升級思路：

創建臨時表TMP_,復制原來的數據庫到臨時表中；

刪除之前的原表；

創建新表；

將臨時表中的數據復制到新表中，最后將TMP_表刪除掉；

ok,思路就是這樣， 總共兩個類： 一個MyDaoMaster(OpenHelper繼承類)，一個MigrationHelper(數據庫操作類) 下面是代碼編寫：

修改Application中的DaoMaster的創建：

MyDaoMaster helper = new MyDaoMaster(this, "aserbaos.db"); // DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "aserbao.db"); SQLiteDatabase db = helper.getWritableDatabase(); DaoMaster daoMaster = new DaoMaster(db); daoSession = daoMaster.newSession();

MyDaoMaster代碼:

public class MyDaoMaster extends OpenHelper { private static final String TAG = "MyDaoMaster"; public MyDaoMaster(Context context, String name) { super(context, name); } public MyDaoMaster(Context context, String name, SQLiteDatabase.CursorFactory factory) { super(context, name, factory); } @Override public void onUpgrade(Database db, int oldVersion, int newVersion) { super.onUpgrade(db, oldVersion, newVersion); MigrationHelper.migrate(db, new MigrationHelper.ReCreateAllTableListener() { @Override public void onCreateAllTables(Database db, boolean ifNotExists) { DaoMaster.createAllTables(db, ifNotExists); } @Override public void onDropAllTables(Database db, boolean ifExists) { DaoMaster.dropAllTables(db, ifExists); } },ThingDao.class); Log.e(TAG, "onUpgrade: " + oldVersion + " newVersion = " + newVersion); } }

MigrationHelper 代碼：

public final class MigrationHelper { public static boolean DEBUG = false; private static String TAG = "MigrationHelper"; private static final String SQLITE_MASTER = "sqlite_master"; private static final String SQLITE_TEMP_MASTER = "sqlite_temp_master"; private static WeakReference<ReCreateAllTableListener> weakListener; public interface ReCreateAllTableListener{ void onCreateAllTables(Database db, boolean ifNotExists); void onDropAllTables(Database db, boolean ifExists); } public static void migrate(SQLiteDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) { printLog("【The Old Database Version】" + db.getVersion()); Database database = new StandardDatabase(db); migrate(database, daoClasses); } public static void migrate(SQLiteDatabase db, ReCreateAllTableListener listener, Class<? extends AbstractDao<?, ?>>... daoClasses) { weakListener = new WeakReference<>(listener); migrate(db, daoClasses); } public static void migrate(Database database, ReCreateAllTableListener listener, Class<? extends AbstractDao<?, ?>>... daoClasses) { weakListener = new WeakReference<>(listener); migrate(database, daoClasses); } public static void migrate(Database database, Class<? extends AbstractDao<?, ?>>... daoClasses) { printLog("【Generate temp table】start"); generateTempTables(database, daoClasses); printLog("【Generate temp table】complete"); ReCreateAllTableListener listener = null; if (weakListener != null) { listener = weakListener.get(); } if (listener != null) { listener.onDropAllTables(database, true); printLog("【Drop all table by listener】"); listener.onCreateAllTables(database, false); printLog("【Create all table by listener】"); } else { dropAllTables(database, true, daoClasses); createAllTables(database, false, daoClasses); } printLog("【Restore data】start"); restoreData(database, daoClasses); printLog("【Restore data】complete"); } private static void generateTempTables(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) { for (int i = 0; i < daoClasses.length; i++) { String tempTableName = null; DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]); String tableName = daoConfig.tablename; if (!isTableExists(db, false, tableName)) { printLog("【New Table】" + tableName); continue; } try { tempTableName = daoConfig.tablename.concat("_TEMP"); StringBuilder dropTableStringBuilder = new StringBuilder(); dropTableStringBuilder.append("DROP TABLE IF EXISTS ").append(tempTableName).append(";"); db.execSQL(dropTableStringBuilder.toString()); StringBuilder insertTableStringBuilder = new StringBuilder(); insertTableStringBuilder.append("CREATE TEMPORARY TABLE ").append(tempTableName); insertTableStringBuilder.append(" AS SELECT * FROM ").append(tableName).append(";"); db.execSQL(insertTableStringBuilder.toString()); printLog("【Table】" + tableName +"\n ---Columns-->"+getColumnsStr(daoConfig)); printLog("【Generate temp table】" + tempTableName); } catch (SQLException e) { Log.e(TAG, "【Failed to generate temp table】" + tempTableName, e); } } } private static boolean isTableExists(Database db, boolean isTemp, String tableName) { if (db == null || TextUtils.isEmpty(tableName)) { return false; } String dbName = isTemp ? SQLITE_TEMP_MASTER : SQLITE_MASTER; String sql = "SELECT COUNT(*) FROM " + dbName + " WHERE type = ? AND name = ?"; Cursor cursor=null; int count = 0; try { cursor = db.rawQuery(sql, new String[]{"table", tableName}); if (cursor == null || !cursor.moveToFirst()) { return false; } count = cursor.getInt(0); } catch (Exception e) { e.printStackTrace(); } finally { if (cursor != null) cursor.close(); } return count > 0; } private static String getColumnsStr(DaoConfig daoConfig) { if (daoConfig == null) { return "no columns"; } StringBuilder builder = new StringBuilder(); for (int i = 0; i < daoConfig.allColumns.length; i++) { builder.append(daoConfig.allColumns[i]); builder.append(","); } if (builder.length() > 0) { builder.deleteCharAt(builder.length() - 1); } return builder.toString(); } private static void dropAllTables(Database db, boolean ifExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) { reflectMethod(db, "dropTable", ifExists, daoClasses); printLog("【Drop all table by reflect】"); } private static void createAllTables(Database db, boolean ifNotExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) { reflectMethod(db, "createTable", ifNotExists, daoClasses); printLog("【Create all table by reflect】"); } /** * dao class already define the sql exec method, so just invoke it */ private static void reflectMethod(Database db, String methodName, boolean isExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) { if (daoClasses.length < 1) { return; } try { for (Class cls : daoClasses) { Method method = cls.getDeclaredMethod(methodName, Database.class, boolean.class); method.invoke(null, db, isExists); } } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } } private static 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"); if (!isTableExists(db, true, tempTableName)) { continue; } try { // get all columns from tempTable, take careful to use the columns list List<TableInfo> newTableInfos = TableInfo.getTableInfo(db, tableName); List<TableInfo> tempTableInfos = TableInfo.getTableInfo(db, tempTableName); ArrayList<String> selectColumns = new ArrayList<>(newTableInfos.size()); ArrayList<String> intoColumns = new ArrayList<>(newTableInfos.size()); for (TableInfo tableInfo : tempTableInfos) { if (newTableInfos.contains(tableInfo)) { String column = '`' + tableInfo.name + '`'; intoColumns.add(column); selectColumns.add(column); } } // NOT NULL columns list for (TableInfo tableInfo : newTableInfos) { if (tableInfo.notnull && !tempTableInfos.contains(tableInfo)) { String column = '`' + tableInfo.name + '`'; intoColumns.add(column); String value; if (tableInfo.dfltValue != null) { value = "'" + tableInfo.dfltValue + "' AS "; } else { value = "'' AS "; } selectColumns.add(value + column); } } if (intoColumns.size() != 0) { StringBuilder insertTableStringBuilder = new StringBuilder(); insertTableStringBuilder.append("REPLACE INTO ").append(tableName).append(" ("); insertTableStringBuilder.append(TextUtils.join(",", intoColumns)); insertTableStringBuilder.append(") SELECT "); insertTableStringBuilder.append(TextUtils.join(",", selectColumns)); insertTableStringBuilder.append(" FROM ").append(tempTableName).append(";"); db.execSQL(insertTableStringBuilder.toString()); printLog("【Restore data】 to " + tableName); } StringBuilder dropTableStringBuilder = new StringBuilder(); dropTableStringBuilder.append("DROP TABLE ").append(tempTableName); db.execSQL(dropTableStringBuilder.toString()); printLog("【Drop temp table】" + tempTableName); } catch (SQLException e) { Log.e(TAG, "【Failed to restore data from temp table 】" + tempTableName, e); } } }

轉載于:https://www.cnblogs.com/Free-Thinker/p/10654474.html

總結

以上是生活随笔為你收集整理的一篇好文之Android数据库 GreenDao的完全解析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。