天天看點
傳回

Android下Sqlite資料庫ORM架構之GreenDao詳解一、建立一個JAVA工程，用于裝載GreenDao類，生成Dao類檔案。二、Android工程中GreenDao的使用

    在大型項目中，android的資料庫操作不可能再像第二篇文章那樣，用最基礎的API去實作各方面的操作，那樣效率會十分的底下。那麼，在android開發中，提拱了androrm，Ormlite,greenDao三個主流架構，部落客三生有幸，再開發第一個項目的時候，就被逼着學習使用greenDao這個ORM架構。現在回過頭看，greenDao似乎是三種架構中效率最高的，但是對于初學者來說，使用起來非常的不方面，因為官方是純英文文檔，例子也不夠詳細。部落客那個時候真的是在前進中摸索，各種坎坷，網上的博文介紹的都不夠詳細，不能滿足部落客的需求，對于資料庫的多表設計，網上的例子也都不夠詳細，而且大部分都是從官方文檔直接copy過來，并不是自己寫的，更不會有注釋。對于新手不好上手。最近這段時間部落客比較有時間，于是整理之前的筆記，在資料庫專題來詳細講解一下greendao的使用。部落客從零開始，一段一段代碼自己敲，并配上注釋，保證新手容易上手。熟練掌握greendao的使用。

GreenDao官網：http://greendao-orm.com/

GreenDao github下載下傳位址：https://github.com/greenrobot/greenDAO

GreenDao設計目的：最大性能，最快的Android ORM架構，易于使用的API，高度優化，最小記憶體的損耗

有興趣的同學可以将完整的工程下載下傳下來學習，看完後絕對可以掌握GreenDao的使用，可以直接拿去自己的項目工程裡使用

示例代碼下載下傳位址：http://download.csdn.net/detail/victorfreedom/8353631

好了，廢話說完了，接下來一步一步的開發一個使用greenDao的android項目工程。

一、建立一個JAVA工程，用于裝載GreenDao類，生成Dao類檔案。

在這個工程裡面必須導入 greendao-generator.jar和freemarker.jar或者直接在下載下傳下來的例子裡面的de.greenrobot.daogenerator包内容導入 部落客的項目結構如圖：

Android下Sqlite資料庫ORM架構之GreenDao詳解一、建立一個JAVA工程，用于裝載GreenDao類，生成Dao類檔案。二、Android工程中GreenDao的使用

接下來，我們來寫Dao類檔案的生成代碼，詳情請看代碼： [java] view plain copy

  1. package com.batways.apopo.generator;  
  2. import de.greenrobot.daogenerator.DaoGenerator;  
  3. import de.greenrobot.daogenerator.Entity;  
  4. import de.greenrobot.daogenerator.Property;  
  5. import de.greenrobot.daogenerator.Schema;  
  6. import de.greenrobot.daogenerator.ToMany;  
  7. public class TestCase {  
  8.     // 資料庫更新  
  9.     private static int dbVersion = 1;  
  10.     private String modelPackage = "com.example.freedomsql.bean";  
  11.     private Schema schema = new Schema(dbVersion, modelPackage);  
  12.     public static void main(String[] args) throws Exception {  
  13.         TestCase testCase = new TestCase();  
  14.         testCase.init();  
  15.         testCase.schema.enableKeepSectionsByDefault();  
  16.         testCase.schema.enableActiveEntitiesByDefault();  
  17.         new DaoGenerator().generateAll(testCase.schema,  
  18.                 "E:\\mayflygeek\\mayflygeekprojects\\FreedomSql\\src");  
  19.     }  
  20.     public void init() {  
  21.         // 定義一個實體  
  22.         Entity OrderHeader = schema.addEntity("OrderHeader");  
  23.         // 實作序列化接口  
  24.         OrderHeader.implementsSerializable();  
  25.         // 定義ID主鍵  
  26.         OrderHeader.addIdProperty();  
  27.         // 增加其他字段，這裡可以定義很多類型，還可以指定屬性  
  28.         OrderHeader.addStringProperty("orderName").notNull();  
  29.         //如果不想用上面的定義ID主鍵，還可以自己這樣定義。  
  30. //      OrderHeader.addLongProperty("orderId").primaryKey().autoincrement();  
  31.         //後面的實體定義和上面的差不多。就不在較長的描述  
  32.         Entity OrderItem = schema.addEntity("OrderItem");  
  33.         OrderItem.implementsSerializable();  
  34.         OrderItem.addIdProperty();  
  35.         OrderItem.addStringProperty("itemName");  
  36.         // 用于做多表設計使用  
  37.         Property orderId = OrderItem.addLongProperty("orderId").getProperty();  
  38.         Entity Student = schema.addEntity("Student");  
  39.         Student.implementsSerializable();  
  40.         Student.addIdProperty();  
  41.         Student.addStringProperty("studentName");  
  42.         // 增加一個字段，資料庫更新  
  43.         // Student.addDoubleProperty("results");  
  44.         Entity Teacher = schema.addEntity("Teacher");  
  45.         Teacher.implementsSerializable();  
  46.         Teacher.addIdProperty();  
  47.         Teacher.addStringProperty("teacherName");  
  48.         Entity StudentTeacher = schema.addEntity("StudentTeacher");  
  49.         Property teacherId = StudentTeacher.addLongProperty("teacherId")  
  50.                 .getProperty();  
  51.         Property studentId = StudentTeacher.addLongProperty("studentId")  
  52.                 .getProperty();  
  53.         // Entity Grade = schema.addEntity("Grade");  
  54.         // Grade.implementsSerializable();  
  55.         // Grade.addIdProperty();  
  56.         // Grade.addStringProperty("gradeName");  
  57.         // 樹狀結構，自身實作1對多  
  58.         Entity Tree = schema.addEntity("Tree");  
  59.         Tree.addIdProperty();  
  60.         Tree.addStringProperty("treeName");  
  61.         Property parentId = Tree.addLongProperty("parentId").getProperty();  
  62.         Tree.addToOne(Tree, parentId).setName("parent");  
  63.         Tree.addToMany(Tree, parentId).setName("children");  
  64.         // 外鍵添加,1對多  
  65.         OrderItem.addToOne(OrderHeader, orderId);  
  66.         ToMany addToMany = OrderHeader.addToMany(OrderItem, orderId);  
  67.         addToMany.setName("orderItems");  
  68.         // greenDao不支援多對多的實作，但是我們可以 自定義實作多對多  
  69.         StudentTeacher.addToOne(Student, studentId);  
  70.         StudentTeacher.addToOne(Teacher, teacherId);  
  71.         Student.addToMany(StudentTeacher, studentId)  
  72.                 .setName("studentsteachers");  
  73.         Teacher.addToMany(StudentTeacher, teacherId)  
  74.                 .setName("studentsteachers");  
  75.     }  
  76. }  

二、Android工程中GreenDao的使用

首先需要導入對應的jar包。這個無需在詳細說明。下載下傳下來的例子裡面有。

1、Android工程中代碼生成的結構

1、DaoMaster,DaoSession的生成

  這兩個檔案是最關鍵的兩個檔案，資料庫的生成和表的操作都在這兩個類裡面。如果沒有指定生成目錄，會和實體檔案一起生成在同一目錄裡面

2、實體類和對應Dao類的生成

這裡以OrderHeader實體來說明，詳情看代碼： [java] view plain copy

  1. package com.example.freedomsql.bean;  
  2. import java.util.List;  
  3. import com.example.freedomsql.bean.DaoSession;  
  4. import de.greenrobot.dao.DaoException;  
  5. // THIS CODE IS GENERATED BY greenDAO, EDIT ONLY INSIDE THE "KEEP"-SECTIONS  
  6. // KEEP INCLUDES - put your custom includes here  
  7. // KEEP INCLUDES END  
  8. public class OrderHeader implements java.io.Serializable {  
  9.     private Long id;  
  10.     private String orderName;  
  11.     private transient DaoSession daoSession;  
  12.     private transient OrderHeaderDao myDao;  
  13.     private List<OrderItem> orderItems;  
  14.     // 如果設定了enableKeepSectionsByDefault();enableActiveEntitiesByDefault();這兩個屬性，那麼我們可以再指定的區域内寫入自定義代碼，友善下次更新的時候不會被覆寫掉  
  15.     // KEEP FIELDS - put your custom fields here  
  16.     // KEEP FIELDS END  
  17.     public OrderHeader() {  
  18.     }  
  19.     public OrderHeader(Long id) {  
  20.         this.id = id;  
  21.     }  
  22.     public OrderHeader(Long id, String orderName) {  
  23.         this.id = id;  
  24.         this.orderName = orderName;  
  25.     }  
  26.     public void __setDaoSession(DaoSession daoSession) {  
  27.         this.daoSession = daoSession;  
  28.         myDao = daoSession != null ? daoSession.getOrderHeaderDao() : null;  
  29.     }  
  30.     public Long getId() {  
  31.         return id;  
  32.     }  
  33.     public void setId(Long id) {  
  34.         this.id = id;  
  35.     }  
  36.     public String getOrderName() {  
  37.         return orderName;  
  38.     }  
  39.     public void setOrderName(String orderName) {  
  40.         this.orderName = orderName;  
  41.     }  
  42.     public List<OrderItem> getOrderItems() {  
  43.         if (orderItems == null) {  
  44.             if (daoSession == null) {  
  45.                 throw new DaoException("Entity is detached from DAO context");  
  46.             }  
  47.             OrderItemDao targetDao = daoSession.getOrderItemDao();  
  48.             List<OrderItem> orderItemsNew = targetDao  
  49.                     ._queryOrderHeader_OrderItems(id);  
  50.             synchronized (this) {  
  51.                 if (orderItems == null) {  
  52.                     orderItems = orderItemsNew;  
  53.                 }  
  54.             }  
  55.         }  
  56.         return orderItems;  
  57.     }  
  58.     public synchronized void resetOrderItems() {  
  59.         orderItems = null;  
  60.     }  
  61.     public void delete() {  
  62.         if (myDao == null) {  
  63.             throw new DaoException("Entity is detached from DAO context");  
  64.         }  
  65.         myDao.delete(this);  
  66.     }  
  67.     public void update() {  
  68.         if (myDao == null) {  
  69.             throw new DaoException("Entity is detached from DAO context");  
  70.         }  
  71.         myDao.update(this);  
  72.     }  
  73.     public void refresh() {  
  74.         if (myDao == null) {  
  75.             throw new DaoException("Entity is detached from DAO context");  
  76.         }  
  77.         myDao.refresh(this);  
  78.     }  
  79.     // KEEP METHODS - put your custom methods here  
  80.     // KEEP METHODS END  
  81. }  

這裡需要特别注意的是，在使用getOrderItems（）拿到自己1對多的實體内容的時候，一定要記得resetOrderItems一下，不然由于緩存機制，會拿不到最新的實體内容。我們可以看到剛剛在test類中設定的内容都出現了，而且和Orderitem的1對多關系也得到了展現。在資料庫操作的時候會變得非常的便捷 在看看Dao類 [java] view plain copy

  1. package com.example.freedomsql.bean;  
  2. import android.database.Cursor;  
  3. import android.database.sqlite.SQLiteDatabase;  
  4. import android.database.sqlite.SQLiteStatement;  
  5. import de.greenrobot.dao.AbstractDao;  
  6. import de.greenrobot.dao.Property;  
  7. import de.greenrobot.dao.internal.DaoConfig;  
  8. import com.example.freedomsql.bean.OrderHeader;  
  9. // THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT.  
  10. public class OrderHeaderDao extends AbstractDao<OrderHeader, Long> {  
  11.     public static final String TABLENAME = "ORDER_HEADER";  
  12.     public static class Properties {  
  13.         public final static Property Id = new Property(0, Long.class, "id", true, "_id");  
  14.         public final static Property OrderName = new Property(1, String.class, "orderName", false, "ORDER_NAME");  
  15.     };  
  16.     private DaoSession daoSession;  
  17.     public OrderHeaderDao(DaoConfig config) {  
  18.         super(config);  
  19.     }  
  20.     public OrderHeaderDao(DaoConfig config, DaoSession daoSession) {  
  21.         super(config, daoSession);  
  22.         this.daoSession = daoSession;  
  23.     }  
  24.     public static void createTable(SQLiteDatabase db, boolean ifNotExists) {  
  25.         String constraint = ifNotExists? "IF NOT EXISTS ": "";  
  26.         db.execSQL("CREATE TABLE " + constraint + "'ORDER_HEADER' (" + //  
  27.                 "'_id' INTEGER PRIMARY KEY ," + // 0: id  
  28.                 "'ORDER_NAME' TEXT);"); // 1: orderName  
  29.     }  
  30.     public static void dropTable(SQLiteDatabase db, boolean ifExists) {  
  31.         String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "'ORDER_HEADER'";  
  32.         db.execSQL(sql);  
  33.     }  
  34.     @Override  
  35.     protected void bindValues(SQLiteStatement stmt, OrderHeader entity) {  
  36.         stmt.clearBindings();  
  37.         Long id = entity.getId();  
  38.         if (id != null) {  
  39.             stmt.bindLong(1, id);  
  40.         }  
  41.         String orderName = entity.getOrderName();  
  42.         if (orderName != null) {  
  43.             stmt.bindString(2, orderName);  
  44.         }  
  45.     }  
  46.     @Override  
  47.     protected void attachEntity(OrderHeader entity) {  
  48.         super.attachEntity(entity);  
  49.         entity.__setDaoSession(daoSession);  
  50.     }  
  51.     @Override  
  52.     public Long readKey(Cursor cursor, int offset) {  
  53.         return cursor.isNull(offset + 0) ? null : cursor.getLong(offset + 0);  
  54.     }      
  55.     @Override  
  56.     public OrderHeader readEntity(Cursor cursor, int offset) {  
  57.         OrderHeader entity = new OrderHeader( //  
  58.             cursor.isNull(offset + 0) ? null : cursor.getLong(offset + 0), // id  
  59.             cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1) // orderName  
  60.         );  
  61.         return entity;  
  62.     }  
  63.     @Override  
  64.     public void readEntity(Cursor cursor, OrderHeader entity, int offset) {  
  65.         entity.setId(cursor.isNull(offset + 0) ? null : cursor.getLong(offset + 0));  
  66.         entity.setOrderName(cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1));  
  67.      }  
  68.     @Override  
  69.     protected Long updateKeyAfterInsert(OrderHeader entity, long rowId) {  
  70.         entity.setId(rowId);  
  71.         return rowId;  
  72.     }  
  73.     @Override  
  74.     public Long getKey(OrderHeader entity) {  
  75.         if(entity != null) {  
  76.             return entity.getId();  
  77.         } else {  
  78.             return null;  
  79.         }  
  80.     }  
  81.     @Override      
  82.     protected boolean isEntityUpdateable() {  
  83.         return true;  
  84.     }  
  85. }  

我們可以看到對應的表生成語句和字段綁定等都在這個類裡面。其實這個類和之前哪篇檔案說的Dao類一樣，是操作資料庫用的。增删改查全部靠這個類來實行。

2、使用greenDao在項目中操作資料庫。

1、操作DaoMaster,DaoSession類編寫

    之前說過，DaoMaster和DaoSession是非常關鍵的兩個類，是以我們需要單獨将他們兩個類獨立出來處理，建立一個GreenDao類來實作，詳情看代碼： [java] view plain copy

  1. package com.example.freedomsql.bean;  
  2. import android.content.Context;  
  3. import com.example.freedomsql.utils.Config;  
  4. public class GreenDao {  
  5.     private static DaoMaster daoMaster;  
  6.     private static DaoSession daoSession;  
  7.     public static DaoMaster getDaoMaster(Context context) {  
  8.         if (daoMaster == null) {  
  9.             DaoMaster.OpenHelper helper = new DaoMaster.DevOpenHelper(context,  
  10.                     Config.DB_NAME, null);  
  11.             daoMaster = new DaoMaster(helper.getWritableDatabase());  
  12.         }  
  13.         return daoMaster;  
  14.     }  
  15.     public static DaoSession getDaoSession(Context context) {  
  16.         if (daoSession == null) {  
  17.             if (daoMaster == null) {  
  18.                 daoMaster = getDaoMaster(context);  
  19.             }  
  20.             daoSession = daoMaster.newSession();  
  21.         }  
  22.         return daoSession;  
  23.     }  
  24. }  

2、資料庫增删改查接口類編寫

   在拿到兩個非常重要的類之後，接下來就是對資料庫操作的接口類的編寫。我們以OrderHeader和OrderItem類來舉例說明我們寫先接口 [java] view plain copy

  1. package com.example.freedomsql.service;  
  2. import com.example.freedomsql.bean.OrderHeader;  
  3. import com.example.freedomsql.bean.OrderItem;  
  4. import com.example.freedomsql.bean.Student;  
  5. import com.example.freedomsql.bean.Teacher;  
  6. public interface IOrderHeaderService {  
  7.     public OrderHeader createOrder(OrderHeader order);  
  8.     public OrderHeader updateOrder(OrderHeader orderHeader);  
  9.     public OrderHeader findOrderByName(String orderName);  
  10.     public OrderHeader findOrderById(long orderId);  
  11.     public OrderItem findOrderItemById(long orderItemId);  
  12.     public OrderItem findOrderItemByName(String orderItemName);  
  13.     public OrderItem createOrderItem(OrderHeader orderHeader, String name);  
  14. }  

接下來寫實作類： [java] view plain copy

  1. package com.example.freedomsql.service.impl;  
  2. import android.content.Context;  
  3. import com.example.freedomsql.bean.DaoSession;  
  4. import com.example.freedomsql.bean.GreenDao;  
  5. import com.example.freedomsql.bean.OrderHeader;  
  6. import com.example.freedomsql.bean.OrderHeaderDao;  
  7. import com.example.freedomsql.bean.OrderItem;  
  8. import com.example.freedomsql.bean.OrderItemDao;  
  9. import com.example.freedomsql.service.IOrderHeaderService;  
  10. public class OrderHeaderService implements IOrderHeaderService {  
  11.     private static DaoSession daoSession;  
  12.     private static OrderHeaderService service;  
  13.     private OrderHeaderDao orderHeaderDao;  
  14.     private OrderItemDao orderItemDao;  
  15.     private OrderHeaderService(OrderHeaderDao orderHeaderDao,  
  16.             OrderItemDao orderItemDao) {  
  17.         this.orderHeaderDao = orderHeaderDao;  
  18.         this.orderItemDao = orderItemDao;  
  19.     }  
  20.     public static OrderHeaderService getService(Context context) {  
  21.         if (service == null) {  
  22.             daoSession = GreenDao.getDaoSession(context);  
  23.             service = new OrderHeaderService(daoSession.getOrderHeaderDao(),  
  24.                     daoSession.getOrderItemDao());  
  25.         }  
  26.         return service;  
  27.     }  
  28.     @Override  
  29.     public OrderHeader createOrder(OrderHeader order) {  
  30.         return orderHeaderDao.loadByRowId(orderHeaderDao.insert(order));  
  31.     }  
  32.     @Override  
  33.     public OrderHeader updateOrder(OrderHeader orderHeader) {  
  34.         orderHeaderDao.update(orderHeader);  
  35.         return orderHeader;  
  36.     }  
  37.     @Override  
  38.     public OrderHeader findOrderByName(String orderName) {  
  39.         OrderHeader orderHeader = orderHeaderDao.queryBuilder()  
  40.                 .where(OrderHeaderDao.Properties.OrderName.eq(orderName))  
  41.                 .unique();  
  42.         return orderHeader;  
  43.     }  
  44.     @Override  
  45.     public OrderHeader findOrderById(long orderId) {  
  46.         return orderHeaderDao.load(orderId);  
  47.     }  
  48.     @Override  
  49.     public OrderItem findOrderItemById(long orderItemId) {  
  50.         return orderItemDao.load(orderItemId);  
  51.     }  
  52.     @Override  
  53.     public OrderItem findOrderItemByName(String orderItemName) {  
  54.         return orderItemDao.queryBuilder()  
  55.                 .where(OrderItemDao.Properties.ItemName.eq(orderItemName))  
  56.                 .unique();  
  57.     }  
  58.     @Override  
  59.     public OrderItem createOrderItem(OrderHeader orderHeader, String name) {  
  60.         OrderItem orderItem = new OrderItem();  
  61.         orderItem.setItemName(name);  
  62.         orderItem.setOrderHeader(orderHeader);  
  63.         return orderItemDao.load(orderItemDao.insert(orderItem));  
  64.     }  
  65. }  

我們可以看到，查詢條件非常容易寫，這裡部落客隻寫了些簡單的查詢條件，在where方法中是可以支援多條件限制查詢的，查詢方法非常的強大。還支援延遲lazy查詢。但是使用延遲查詢的話要記得close（）掉。我們可以将相關系的表檔案的Dao檔案寫到一起，便于查詢方法的編寫。這裡部落客沒有示範删除操作，其實也非常簡單，API在Dao類裡面，一看就懂的。

3、在主項目中的編寫

1、接口位置的放置 這些接口，我們肯定是要做成全局變量的，那麼，之前說過，全局變量的最好放置地方就是在Application中，參考代碼如下 [java] view plain copy

  1. package com.example.freedomsql;  
  2. import android.app.Application;  
  3. import com.example.freedomsql.service.IClassService;  
  4. import com.example.freedomsql.service.IOrderHeaderService;  
  5. import com.example.freedomsql.service.impl.ClassService;  
  6. import com.example.freedomsql.service.impl.OrderHeaderService;  
  7. public class FreedomApplication extends Application {  
  8.     public IClassService classService;  
  9.     public IOrderHeaderService orderHeaderService;  
  10.     @Override  
  11.     public void onCreate() {  
  12.         super.onCreate();  
  13.         classService = ClassService.getService(getApplicationContext());  
  14.         orderHeaderService = OrderHeaderService  
  15.                 .getService(getApplicationContext());  
  16.     }  
  17. }  

2、主Activity的編寫 我們需要在這裡生成一些資料來觀察資料庫：（那些 注釋掉的東西是部落客後面用來更新資料庫使用的） [java] view plain copy

  1. package com.example.freedomsql;  
  2. import android.app.Activity;  
  3. import android.os.Bundle;  
  4. import com.example.freedomsql.bean.OrderHeader;  
  5. import com.example.freedomsql.bean.Student;  
  6. import com.example.freedomsql.bean.StudentTeacher;  
  7. import com.example.freedomsql.bean.Teacher;  
  8. import com.example.freedomsql.service.IClassService;  
  9. import com.example.freedomsql.service.IOrderHeaderService;  
  10. public class MainActivity extends Activity {  
  11.     private IClassService classService;  
  12.     private IOrderHeaderService orderHeaderService;  
  13.     @Override  
  14.     protected void onCreate(Bundle savedInstanceState) {  
  15.         super.onCreate(savedInstanceState);  
  16.         setContentView(R.layout.activity_main);  
  17.         classService = ((FreedomApplication) getApplication()).classService;  
  18.         orderHeaderService = ((FreedomApplication) getApplication()).orderHeaderService;  
  19.         initGreenDaoDB();  
  20.     }  
  21.     private void initGreenDaoDB() {  
  22.         Teacher t1 = new Teacher();  
  23.         t1.setTeacherName("freedom");  
  24.         // t1.setTeacherName("freedom2");  
  25.         classService.createTeacher(t1);  
  26.         Teacher t2 = new Teacher();  
  27.         t2.setTeacherName("freedom1");  
  28.         // t2.setTeacherName("freedom3");  
  29.         Student t3 = new Student();  
  30.         t3.setStudentName("victor");  
  31.         // t3.setStudentName("victor2");  
  32.         Student t4 = new Student();  
  33.          t4.setStudentName("victor1");  
  34.         // t4.setStudentName("victor3");  
  35.         classService.createTeacher(t1);  
  36.         classService.createTeacher(t2);  
  37.         classService.createStudent(t3);  
  38.         classService.createStudent(t4);  
  39.         StudentTeacher st1 = new StudentTeacher(t1.getId(), t3.getId());  
  40.         StudentTeacher st2 = new StudentTeacher(t1.getId(), t4.getId());  
  41.         StudentTeacher st3 = new StudentTeacher(t2.getId(), t3.getId());  
  42.         StudentTeacher st4 = new StudentTeacher(t2.getId(), t4.getId());  
  43.         classService.createStudentTeacher(st1);  
  44.         classService.createStudentTeacher(st2);  
  45.         classService.createStudentTeacher(st3);  
  46.         classService.createStudentTeacher(st4);  
  47.         OrderHeader order = new OrderHeader();  
  48.         order.setOrderName("訂單1");  
  49.         // order.setOrderName("訂單3");  
  50.         OrderHeader order1 = new OrderHeader();  
  51.         order1.setOrderName("訂單2");  
  52.         // order1.setOrderName("訂單4");  
  53.         orderHeaderService.createOrder(order);  
  54.         orderHeaderService.createOrder(order1);  
  55.         orderHeaderService.createOrderItem(order1, "明細1");  
  56.         orderHeaderService.createOrderItem(order1, "明細2");  
  57.         // orderHeaderService.createOrderItem(order1, "明細3");  
  58.         // orderHeaderService.createOrderItem(order1, "明細4");  
  59.     }  
  60. }  

生成資料後如圖所示：這裡就隻上傳OrderHeader和OrderItem的圖

Android下Sqlite資料庫ORM架構之GreenDao詳解一、建立一個JAVA工程，用于裝載GreenDao類，生成Dao類檔案。二、Android工程中GreenDao的使用
Android下Sqlite資料庫ORM架構之GreenDao詳解一、建立一個JAVA工程，用于裝載GreenDao類，生成Dao類檔案。二、Android工程中GreenDao的使用

好了，greenDao的操作基本講解完畢，相信看了代碼的同學基本上學會了如何使用GreenDao，以及多表結構的設計。部落客這裡就不示範那些查詢方法了，都很簡單，通俗易懂。接下來部落客再講講再資料庫更新中，如何儲存原有資料。

3、使用GreenDao更新資料庫

1、TestCase類檔案修改

    資料庫的更新，一般是在于字段的增加或者表的增加，這裡，部落客再一個實體中增加一個字段，又增加一個實體來示範     首先，增加資料庫版本号： [java] view plain copy

  1. private static int dbVersion = 2;  

    再在Student類中增加一個字段 [java] view plain copy

  1. // 增加一個字段，資料庫更新  
  2.          Student.addDoubleProperty("results");  

    增加一個實體Grade [java] view plain copy

  1. Entity Grade = schema.addEntity("Grade");  
  2.         Grade.implementsSerializable();  
  3.         Grade.addIdProperty();  
  4.         Grade.addStringProperty("gradeName");  

2、DaoMaster類的修改，這裡我們隻需要重寫一下onUpgrade方法

[java] view plain copy

  1. @Override  
  2. public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {  
  3.     Log.i("greenDAO", "Upgrading schema from version " + oldVersion  
  4.             + " to " + newVersion + " by dropping all tables");  
  5.     //正常情況下，GreenDao預設更新的時候，将所有的表删除後再建，是以我們需要在這裡處理  
  6.     // dropAllTables(db, true);  
  7.     // onCreate(db);  
  8.     if (oldVersion == 1 && newVersion == 2) {  
  9.         // 增加一個實體表  
  10.         GradeDao.createTable(db, false);  
  11.         // 修改Student表  
  12.         db.execSQL("ALTER TABLE 'STUDENT' ADD 'RESULTS' REAL");  
  13.     }  
  14. }  

3、主Activity的修改，其他地方都不用修改了

對于主Activity，我們需要重新生成一些資料對比之前的資料即可 [java] view plain copy

  1. package com.example.freedomsql;  
  2. import android.app.Activity;  
  3. import android.os.Bundle;  
  4. import com.example.freedomsql.bean.OrderHeader;  
  5. import com.example.freedomsql.bean.Student;  
  6. import com.example.freedomsql.bean.StudentTeacher;  
  7. import com.example.freedomsql.bean.Teacher;  
  8. import com.example.freedomsql.service.IClassService;  
  9. import com.example.freedomsql.service.IOrderHeaderService;  
  10. public class MainActivity extends Activity {  
  11.     private IClassService classService;  
  12.     private IOrderHeaderService orderHeaderService;  
  13.     @Override  
  14.     protected void onCreate(Bundle savedInstanceState) {  
  15.         super.onCreate(savedInstanceState);  
  16.         setContentView(R.layout.activity_main);  
  17.         classService = ((FreedomApplication) getApplication()).classService;  
  18.         orderHeaderService = ((FreedomApplication) getApplication()).orderHeaderService;  
  19.         initGreenDaoDB();  
  20.     }  
  21.     private void initGreenDaoDB() {  
  22.         Teacher t1 = new Teacher();  
  23.         // t1.setTeacherName("freedom");  
  24.         t1.setTeacherName("freedom2");  
  25.         classService.createTeacher(t1);  
  26.         Teacher t2 = new Teacher();  
  27.         // t2.setTeacherName("freedom1");  
  28.         t2.setTeacherName("freedom3");  
  29.         Student t3 = new Student();  
  30.         // t3.setStudentName("victor");  
  31.         t3.setStudentName("victor2");  
  32.         Student t4 = new Student();  
  33.         // t4.setStudentName("victor1");  
  34.         t4.setStudentName("victor3");  
  35.         classService.createTeacher(t1);  
  36.         classService.createTeacher(t2);  
  37.         classService.createStudent(t3);  
  38.         classService.createStudent(t4);  
  39.         StudentTeacher st1 = new StudentTeacher(t1.getId(), t3.getId());  
  40.         StudentTeacher st2 = new StudentTeacher(t1.getId(), t4.getId());  
  41.         StudentTeacher st3 = new StudentTeacher(t2.getId(), t3.getId());  
  42.         StudentTeacher st4 = new StudentTeacher(t2.getId(), t4.getId());  
  43.         classService.createStudentTeacher(st1);  
  44.         classService.createStudentTeacher(st2);  
  45.         classService.createStudentTeacher(st3);  
  46.         classService.createStudentTeacher(st4);  
  47.         OrderHeader order = new OrderHeader();  
  48.         // order.setOrderName("訂單1");  
  49.         order.setOrderName("訂單3");  
  50.         OrderHeader order1 = new OrderHeader();  
  51.         // order1.setOrderName("訂單2");  
  52.         order1.setOrderName("訂單4");  
  53.         orderHeaderService.createOrder(order);  
  54.         orderHeaderService.createOrder(order1);  
  55.         // orderHeaderService.createOrderItem(order1, "明細1");  
  56.         // orderHeaderService.createOrderItem(order1, "明細2");  
  57.         orderHeaderService.createOrderItem(order1, "明細3");  
  58.         orderHeaderService.createOrderItem(order1, "明細4");  
  59.     }  
  60. }  

我們來看看運作前後的資料庫Student表效果圖對比

Android下Sqlite資料庫ORM架構之GreenDao詳解一、建立一個JAVA工程，用于裝載GreenDao類，生成Dao類檔案。二、Android工程中GreenDao的使用
Android下Sqlite資料庫ORM架構之GreenDao詳解一、建立一個JAVA工程，用于裝載GreenDao類，生成Dao類檔案。二、Android工程中GreenDao的使用

我們可以看到新生的字段也在，之前的資料也在

在看看新生成的Grade表

Android下Sqlite資料庫ORM架構之GreenDao詳解一、建立一個JAVA工程，用于裝載GreenDao類，生成Dao類檔案。二、Android工程中GreenDao的使用

我們可以看到GRADE表也成功的生成了。整個資料庫的資料都還保留着。

android 資料庫 ORM greendao android下資料庫 性能最優
上一篇: GreenDao資料庫更新防止資料丢失工具類
下一篇: 資料緩存--Memcach詳解及如何使用（帶代碼）？

繼續閱讀