轉自：http://www.jianshu.com/p/dbec25bd575f

前言

之前用過數據庫框架：realm、kjdb，今天準備實踐學習一下greendao 3.0。
greendao 3.0之前的版本有很大的不同，主要是增加了annotation註解，然後表之間和對象之間的關系也通過註解而變得更加靈活方便了。以前用過舊版本的都知道，對於多表多對象之間的關聯，要寫的代碼不少。

我在學習greendao 3.0的時候，有一個感觸，網上的文章很多，但是千篇一律，大多都是翻譯官方文檔而來，舉得例子可謂是“無一例外”。網上搜羅了半天，收藏幾篇比較好的帖子。
史上最高效的ORM方案——GreenDao3.0詳解

特別是關於3.0對象多表多對象關聯的博客更是沒有，所以打算自己實踐學習然後總結分享一番。

踩坑

主要踩了兩個坑：

• greendao的關聯關系是通過主外鍵（對象之間關聯的id）來構建的。realm是直接通過對象關系來自動構建的。
• 如果屬性是List<> xx, greendao不會自動調用設置xx的值，只有手動調用getXX的時候獲取.我在打印log的時候被坑慘了，無論怎麽樣都是為null.

發現

• 首先bean類，會自動生成一些方法，比如get set 構造方法 getSession等
• 如果是list或者數組類型的屬性XX，只有getXX方法，沒有setXX方法
• 如果你要打印bean類的toString方法，這裏要調用getXXX方法，而不是直接打印對象（因為沒有賦值,而是在getXX的時候才賦值的）

    @Override
    public String toString() {
        return "Person{" +
               "students=" + getStudents() +  //這裏不是直接students
                ", id=" + id +
                ", cardId=" + cardId +
                ", age=" + age +
                ", name=‘" + name + ‘\‘‘ +
                ", average=" + average +
                ", cid=" + cid +
                ", cls=" + cls +
                ", fid=" + fid +
                ", friends=" + getFriends() +
                ‘}‘;
    }
   
  

• greendao支持 自身對自身的關系關聯，比如

正文： 多表映射關聯

一對一：比如一個人有一個頭

如果是按照以往的對象關系數據庫

#person類中

   @Id(autoincrement = true)
    private Long id;
    private String name;

//    private Long hid;
    @ToOne
    private Head head;

  Head head = new Head();
        head.setId(13l);
        head.setName("head");

        Person p = new Person();
        p.setId(null);
        p.setHead(head);//直接設置對象
        p.setName("jafir");

直接寫對象，然後setHead(head) 就搞定了。但是在greendao中一切對象關聯關系都是通過主外鍵來實現的。應該改為如下：

#person類中
  @Id(autoincrement = true)
    private Long id;
    private String name;

    private Long hid;//這是與頭關聯的外鍵
    @ToOne(joinProperty = "hid") //這個是註解綁定 hid就是上面一行的hid
    private Head head;//對象，但是不需要setHead

build之後，就有setHid的方法了，我們的對象關聯不采用setHead,而是setHid

PersonDao personDao = GreendaoHelper.getDaoSession().getPersonDao();
        HeadDao headDao = GreendaoHelper.getDaoSession().getHeadDao();

        Head head = new Head();
        head.setId(13l);//這裏的head id和person裏的hid一樣
        head.setName("head");

        Person p = new Person();
        p.setId(null);
        p.setHid(13l);//這裏的hid是head的id,就是這樣通過id構建起關聯的
        p.setName("jafir");

        headDao.insert(head);
        personDao.insert(p);

        List<Person> persons = personDao.queryBuilder().build().list();
        for (Person person : persons) {
            Log.d("debug","person:"+person.toString());
        }

註意：person的toString()方法系統生成的需要修改一下：

 @Override
    public String toString() {
        return "Person{" +
                "head=" + getHead() +//這裏需要改為getHead
                ", name=‘" + name + ‘\‘‘ +
                ", id=" + id +
                ‘}‘;
    }

tips:

• bean的id最好用Long類型而不是long

  @Id(autoincrement = true)
  private Long id;
  Person p = new Person();
        p.setId(null);
        p.setHid(14l);
        p.setName("jafir");

  因為，如果Long,我們設置了id是自增長,我們可以setId(null),便是自增長。如果是long類型，你設置setId(null)，就報空指針。

一對多：比如一個老師有多個學生

#teacher類中
 @ToMany(referencedJoinProperty = "tid")//指定與之關聯的其他類的id
 private List<Student> studnets;

#student類中
  @Id
  private Long id;
  private Long tid;//這個就是外鍵 就是person的id

關系描述：
多個學生都有同一個老師，所以每個學生的tid，就應該是同樣的，並且tid 就是老師的id ,這樣就構成了1對多的關系

註意：學生的自增長id ,跟與老師關聯的tid是不一樣的，兩碼事

一對多：比如一個人有一群朋友（朋友也是person）

按照我們上面的思路，那麽person類裏面就應該有一個外鍵指向自身的主鍵id

#person類中
 private Long id;//自身id
 private Long fid;//外鍵關聯id
 @ToMany(referencedJoinProperty ="fid" )//指定與之關聯的其他類的id
 private List<Person> friends;

如果一個人的id是1，他有3個朋友，那麽friends裏面person的fid都是1，這樣這個人調用getFriends就能拿到自己的3個朋友。主要就是通過設置id來構建關聯關系的。

多對多：

多對多的話就比較復雜，不是兩個表或者兩個對象直接關聯，而是要通過一個“第三者”

#person類中
    @Id(autoincrement = true)
    private Long id;
    private String name;
   // 對多，@JoinEntity註解：entity 中間表；sourceProperty 實體屬性；targetProperty 外鏈實體屬性
    @ToMany
    @JoinEntity(
            entity = JoinStudentToPerson.class,
            sourceProperty = "pid",
            targetProperty = "sid"
    )
    private List<Student> students;

//中間表   “第三者”
@Entity
public class JoinStudentToPerson {
   @Id(autoincrement = true)
    private Long id;
    //和person關聯的id
    private Long pid;
    //和student關聯的id
    private Long sid;
}

@Entity
public class Student {
    @Id
    private Long id;
    private String name;
    // 對多，@JoinEntity註解：entity 中間表；sourceProperty 實體屬性；targetProperty 外鏈實體屬性
    @ToMany
    @JoinEntity(
            entity = JoinStudentToPerson.class,
            sourceProperty = "sid",
            targetProperty = "pid"
    )
    private List<Person> persons;
}

然後測試代碼

  private void test() {

        PersonDao personDao = GreendaoHelper.getDaoSession().getPersonDao();
        HeadDao headDao = GreendaoHelper.getDaoSession().getHeadDao();
        StudentDao studentDao = GreendaoHelper.getDaoSession().getStudentDao();
        JoinStudentToPersonDao spDao = GreendaoHelper.getDaoSession().getJoinStudentToPersonDao();

//        Head head = new Head();
//        head.setId(14l);
//        head.setName("head");

        Person p1 = new Person();
        p1.setId(1l);
        p1.setName("jafir1");
        Person p2 = new Person();
        p2.setId(2l);
        p2.setName("jafir2");
        Person p3 = new Person();
        p3.setId(3l);
        p3.setName("jafir3");


        Student stu1 = new Student();
        stu1.setId(1l);
        stu1.setName("stu1");
        Student stu2 = new Student();
        stu2.setId(2l);
        stu2.setName("stu2");
        Student stu3 = new Student();
        stu3.setId(3l);
        stu3.setName("stu3");


        // 模擬 多對多關系
        // 假如 p1有3個：stu1\stu2\stu3
        //  stu1 stu2 stu3 都有2個 :p1\p2

        //p1有stu1 stu2 stu3     那麽反過來stu123都有p1
        JoinStudentToPerson sp1 = new JoinStudentToPerson();
        sp1.setPid(1l);
        sp1.setSid(1l);
        JoinStudentToPerson sp2 = new JoinStudentToPerson();
        sp2.setPid(1l);
        sp2.setSid(2l);
        JoinStudentToPerson sp3 = new JoinStudentToPerson();
        sp3.setPid(1l);
        sp3.setSid(3l);

        //p2有stu1 stu2 stu3     那麽反過來stu123都有p2
        JoinStudentToPerson sp4 = new JoinStudentToPerson();
        sp4.setPid(2l);
        sp4.setSid(1l);
        JoinStudentToPerson sp5 = new JoinStudentToPerson();
        sp5.setPid(2l);
        sp5.setSid(2l);
        JoinStudentToPerson sp6 = new JoinStudentToPerson();
        sp6.setPid(2l);
        sp6.setSid(3l);

        spDao.insert(sp1);
        spDao.insert(sp2);
        spDao.insert(sp3);
        spDao.insert(sp4);
        spDao.insert(sp5);
        spDao.insert(sp6);

        personDao.insert(p1);
        personDao.insert(p2);
        personDao.insert(p3);

        studentDao.insert(stu1);
        studentDao.insert(stu2);
        studentDao.insert(stu3);

//        headDao.insert(head);
//        personDao.insert(p1);

        List<Person> persons = personDao.queryBuilder().build().list();

        for (Person person : persons) {
            Log.d("debug","person:"+person.toString());
        }
    }

註意：在person和student的toString裏面不能都寫getStudents getPerson，不然會你調我，我調你，然後死循環，出現log打印Stack Overflow。只能單獨打印測試結果

//打印person的測試結果
Person{
students=[
Student{name=‘stu1‘, id=1}, 
Student{name=‘stu2‘, id=2},
 Student{name=‘stu3‘, id=3}], 
head=null, hid=null, name=‘jafir1‘, id=1}

Person{
students=[
Student{name=‘stu1‘, id=1}, 
Student{name=‘stu2‘, id=2}, 
Student{name=‘stu3‘, id=3}],
 head=null, hid=null, name=‘jafir2‘, id=2}

Person{
students=[], 
head=null, hid=null, name=‘jafir3‘, id=3}

students的測試結果就不列出了。
總之實現起來就是這樣。

後記

在探索3.0版本的時候，確實碰了不少壁，踩了很多坑，遇到了很多疑惑，但是通過自己不斷地摸索探究測試，最終還是找到了解決的方法。希望對大家有用，於是分享出來，歡迎大家指正。

這個還要再說一下自己的看法：
對於greendao或者realm,個人覺得，realm確實更高級一點，是直接對象關聯的，用起來也更方便一點，而且有很好的中文文檔。greendao呢，其實還算是比較原始的數據庫框架，但是它最大的優點就是效率高。

所以，如果你的數據量大要求效率，你應該使用greendao,不然簡小的數據庫還是建議使用realm。

作者：Jafir
鏈接：http://www.jianshu.com/p/dbec25bd575f
來源：簡書
著作權歸作者所有。商業轉載請聯系作者獲得授權，非商業轉載請註明出處。

android greendao3.0 多表關聯關系講解（轉）