GreenDao教程(3)：一對一，一對多，多對多

阿新 • • 發佈：2019-01-26

1. 前言

主要介紹GreenDao 一對一，一對多，多對多應用
這部分還是有些坑的，注意看示例程式碼中註釋即可避開
本文資料來源網路公開資源，並根據個人實踐見解純手打整理，如有錯誤請隨時指出。
本文主要用於個人積累及分享，文中可能引用其他技術大牛文章（僅引用連結不轉載），如有侵權請告知必妥善處理。

2. 一對一

2.1. 註解

@ToOne(joinProperty = "childId")

2.2. 示例

這裡舉一個簡單的例子，使用者物件UserBean和使用者其他資訊物件OtherUserInfoBean，每個使用者都對應一個使用者其他資訊

檢視以下程式碼和註釋，可以清楚的瞭解一對一如何使用（自動注入程式碼可以適當忽略）

以下程式碼主要包括實體類定義（UserBean.java、OtherUserInfoBean.java），insert一組資料，delete一組資料3個部分

2.2.1. 實體類定義

以下示例為rebuild之後的程式碼

UserBean.java

@Entity
public class UserBean {
    @Id
    //必須使用包裝類物件型別Long，而非基本型別long
    private Long id;
    @NotNull
    private String name;
    private int age;
    private 
 String province;
    private boolean isMale;
    private String idCard;

    //ToOne註解使用的joinProperty = "otherUserInfoId"指的是UserBean中自定義的這個otherUserInfoId
    private Long otherUserInfoId;

    //在insert時，將otherUserInfoId同一對一關聯的OtherUserInfoBean的主鍵id繫結
    @ToOne(joinProperty = "otherUserInfoId")
    private 
 OtherUserInfoBean otherUserInfoBean;

    //-------------------------------自動注入程式碼部分---開始
    @Generated(hash = 4979683)
    private transient Long otherUserInfoBean__resolvedKey;
    /**
     * Used for active entity operations.
     */
    @Generated(hash = 83707551)
    private transient UserBeanDao myDao;
    /**
     * Used to resolve relations
     */
    @Generated(hash = 2040040024)
    private transient DaoSession daoSession;


    @Generated(hash = 359442482)
    public UserBean(Long id, @NotNull String name, int age, String province,
                    boolean isMale, String idCard, Long otherUserInfoId) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.province = province;
        this.isMale = isMale;
        this.idCard = idCard;
        this.otherUserInfoId = otherUserInfoId;
    }

    @Generated(hash = 1203313951)
    public UserBean() {
    }

    /**
     * Convenient call for {@link org.greenrobot.greendao.AbstractDao#refresh(Object)}.
     * Entity must attached to an entity context.
     */
    @Generated(hash = 1942392019)
    public void refresh() {
        if (myDao == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        myDao.refresh(this);
    }

    /**
     * Convenient call for {@link org.greenrobot.greendao.AbstractDao#update(Object)}.
     * Entity must attached to an entity context.
     */
    @Generated(hash = 713229351)
    public void update() {
        if (myDao == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        myDao.update(this);
    }

    /**
     * Convenient call for {@link org.greenrobot.greendao.AbstractDao#delete(Object)}.
     * Entity must attached to an entity context.
     */
    @Generated(hash = 128553479)
    public void delete() {
        if (myDao == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        myDao.delete(this);
    }

    /**
     * called by internal mechanisms, do not call yourself.
     */
    @Generated(hash = 1952804343)
    public void setOtherUserInfoBean(OtherUserInfoBean otherUserInfoBean) {
        synchronized (this) {
            this.otherUserInfoBean = otherUserInfoBean;
            otherUserInfoId = otherUserInfoBean == null ? null : otherUserInfoBean.getId();
            otherUserInfoBean__resolvedKey = otherUserInfoId;
        }
    }

    /**
     * To-one relationship, resolved on first access.
     */
    @Generated(hash = 1275005484)
    public OtherUserInfoBean getOtherUserInfoBean() {
        Long __key = this.otherUserInfoId;
        if (otherUserInfoBean__resolvedKey == null || !otherUserInfoBean__resolvedKey.equals(__key)) {
            final DaoSession daoSession = this.daoSession;
            if (daoSession == null) {
                throw new DaoException("Entity is detached from DAO context");
            }
            OtherUserInfoBeanDao targetDao = daoSession.getOtherUserInfoBeanDao();
            OtherUserInfoBean otherUserInfoBeanNew = targetDao.load(__key);
            synchronized (this) {
                otherUserInfoBean = otherUserInfoBeanNew;
                otherUserInfoBean__resolvedKey = __key;
            }
        }
        return otherUserInfoBean;
    }

    public Long getOtherUserInfoId() {
        return this.otherUserInfoId;
    }

    public void setOtherUserInfoId(Long otherUserInfoId) {
        this.otherUserInfoId = otherUserInfoId;
    }

    public String getIdCard() {
        return this.idCard;
    }

    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }

    public boolean getIsMale() {
        return this.isMale;
    }

    public void setIsMale(boolean isMale) {
        this.isMale = isMale;
    }

    public String getProvince() {
        return this.province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return this.name;
    }

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

    public Long getId() {
        return this.id;
    }

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

    /** called by internal mechanisms, do not call yourself. */
    @Generated(hash = 1491512534)
    public void __setDaoSession(DaoSession daoSession) {
        this.daoSession = daoSession;
        myDao = daoSession != null ? daoSession.getUserBeanDao() : null;
    }
    //-------------------------------自動注入程式碼部分---結束

    @Override
    public String toString() {
        //toString UserBean一對一關聯的otherUserInfoBean時，
        //不能直接使用變數otherUserInfoBean，需要呼叫自動注入生成的getOtherUserInfoBean()獲取關聯物件
        return "UserBean{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", province='" + province + '\'' +
                ", isMale=" + isMale +
                ", idCard='" + idCard + '\'' +
                ", otherUserInfoId=" + otherUserInfoId +
                ", otherUserInfoBean=" + (getOtherUserInfoBean() == null ? "null" : getOtherUserInfoBean().toString()) +
                '}';
    }

OtherUserInfoBean.java

@Entity
public class OtherUserInfoBean {
    @Id
    //必須使用包裝類物件型別Long，而非基本型別long
    private Long id;
    private String address;
    private String tel;
    private Date birthday;

    //-------------------------------自動注入程式碼部分---開始
    public Date getBirthday() {
        return this.birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getTel() {
        return this.tel;
    }

    public void setTel(String tel) {
        this.tel = tel;
    }

    public String getAddress() {
        return this.address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Long getId() {
        return this.id;
    }

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

    @Generated(hash = 647485055)
    public OtherUserInfoBean(Long id, String address, String tel, Date birthday) {
        this.id = id;
        this.address = address;
        this.tel = tel;
        this.birthday = birthday;
    }

    @Generated(hash = 59605238)
    public OtherUserInfoBean() {
    }
    //-------------------------------自動注入程式碼部分---結束

    @Override
    public String toString() {
        return "OtherUserInfoBean{" +
                "id=" + id +
                ", address='" + address + '\'' +
                ", tel='" + tel + '\'' +
                ", birthday=" + birthday +
                '}';
    }

2.2.2. insert一組資料

以下程式碼，其中GreenDaoUtil是獲取DaoSession的一個單例工具工具類。獲取DaoSession可以通過自己的方式獲取，但請保持單例。

UserBean user = new UserBean();
user.setAge((int) (Math.random() * 100 + 10));
user.setIdCard((int) (Math.random() * 10000) + "123456789");
if (Math.random() * 100 > 50) {
    user.setIsMale(true);
} else {
    user.setIsMale(false);
}
user.setName("李看啥" + (int) (Math.random() * 1000));
user.setProvince("shanhaijing");
Long otherUserInfoId = (long) (Math.random() * 1000);

//只setOtherUserInfoId，不setOtherUserInfoBean
user.setOtherUserInfoId(otherUserInfoId);

//insert user
GreenDaoUtil.getDaoSession(activity).getUserBeanDao().insert(user);


OtherUserInfoBean otherUserInfoBean = new OtherUserInfoBean();

//主鍵id使用user的otherUserInfoId
otherUserInfoBean.setId(otherUserInfoId);

otherUserInfoBean.setTel(String.valueOf((i + 100) * 19 + Math.random() * 100));
otherUserInfoBean.setAddress("dongshanjing");
Date date = new Date();
date.setTime((long) (System.currentTimeMillis() - Math.random() * 2000000000));
otherUserInfoBean.setBirthday(date);

//insert otherUserInfoBean
GreenDaoUtil.getDaoSession(activity).getOtherUserInfoBeanDao().insert(otherUserInfoBean);

2.2.3. delete一組資料

以下程式碼，其中GreenDaoUtil是獲取DaoSession的一個單例工具類。DaoSession可以通過自己的方式獲取，但請保持單例。

之所以把簡單的delete拿出來說，是因為，delete任意一組一對一關聯資料其中一個一部分（比如只delete userBean，不delete otherUserInfoBean），另一部分不受影響

GreenDaoUtil.getDaoSession(activity).getUserBeanDao().deleteByKey(user.getId());

2.3. 結語（一對一）

關於id的繫結，注意以上示例程式碼註釋

關於刪除資料，並沒有關聯刪除

3. 一對多

3.1. 註解

@ToMany(referencedJoinProperty = "parentId")

3.2. 示例

舉例，LeaderBean和MemberBean，每個leader可能對應多個member

檢視以下程式碼和註釋，可以清楚的瞭解一對多如何使用（自動注入程式碼可以適當忽略）

以下程式碼主要包括實體類定義（LeaderBean.java、MemberBean.java），insert一組資料2個部分

3.2.1. 實體類定義

以下示例為rebuild之後的程式碼

LeaderBean.java

/**
 * 一對多
 * Created by songyuan on 2017/3/31.
 */
@Entity
public class LeaderBean {
    @Id
    private Long id;
    private String name;

    //此處的leaderId是在MemberBean中定義的一個變數（請看下面的MemberBean.java）
    @ToMany(referencedJoinProperty = "leaderId")
    private List<MemberBean> memberBeanList;

    //-------------------------------自動注入程式碼部分---開始
    /**
     * Convenient call for {@link org.greenrobot.greendao.AbstractDao#refresh(Object)}.
     * Entity must attached to an entity context.
     */
    @Generated(hash = 1942392019)
    public void refresh() {
        if (myDao == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        myDao.refresh(this);
    }

    /**
     * Convenient call for {@link org.greenrobot.greendao.AbstractDao#update(Object)}.
     * Entity must attached to an entity context.
     */
    @Generated(hash = 713229351)
    public void update() {
        if (myDao == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        myDao.update(this);
    }

    /**
     * Convenient call for {@link org.greenrobot.greendao.AbstractDao#delete(Object)}.
     * Entity must attached to an entity context.
     */
    @Generated(hash = 128553479)
    public void delete() {
        if (myDao == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        myDao.delete(this);
    }

    /**
     * Resets a to-many relationship, making the next get call to query for a fresh result.
     */
    @Generated(hash = 73665005)
    public synchronized void resetMemberBeanList() {
        memberBeanList = null;
    }

    /**
     * To-many relationship, resolved on first access (and after reset).
     * Changes to to-many relations are not persisted, make changes to the target entity.
     */
    @Generated(hash = 1515955432)
    public List<MemberBean> getMemberBeanList() {
        if (memberBeanList == null) {
            final DaoSession daoSession = this.daoSession;
            if (daoSession == null) {
                throw new DaoException("Entity is detached from DAO context");
            }
            MemberBeanDao targetDao = daoSession.getMemberBeanDao();
            List<MemberBean> memberBeanListNew = targetDao._queryLeaderBean_MemberBeanList(id);
            synchronized (this) {
                if (memberBeanList == null) {
                    memberBeanList = memberBeanListNew;
                }
            }
        }
        return memberBeanList;
    }

    /**
     * Used for active entity operations.
     */
    @Generated(hash = 703242250)
    private transient LeaderBeanDao myDao;
    /**
     * Used to resolve relations
     */
    @Generated(hash = 2040040024)
    private transient DaoSession daoSession;

    public String getName() {
        return this.name;
    }

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

    public Long getId() {
        return this.id;
    }

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

    @Generated(hash = 590590377)
    public LeaderBean(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    @Generated(hash = 1761610276)
    public LeaderBean() {
    }

    /** called by internal mechanisms, do not call yourself. */
    @Generated(hash = 1648395956)
    public void __setDaoSession(DaoSession daoSession) {
        this.daoSession = daoSession;
        myDao = daoSession != null ? daoSession.getLeaderBeanDao() : null;
    }

    //-------------------------------自動注入程式碼部分---結束
    @Override
    public String toString() {
        String memberBeanListStr = "";
        if (getMemberBeanList().size() > 0) {
            for (MemberBean memberBean : getMemberBeanList()) {
                memberBeanListStr = memberBeanListStr + memberBean.toString() + ";";
            }
        }else{
            memberBeanListStr = "null";
        }


        return "LeaderBean{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", memberBeanList=" + memberBeanListStr +
                '}';
    }
}

MemberBean.java

/**
 * Created by songyuan on 2017/3/31.
 */
@Entity
public class MemberBean {
    @Id
    private Long id;

    //此處自定義leaderId，用於和LeaderBean對應
    private Long leaderId;

    private String name;

    //-------------------------------自動注入程式碼部分---開始
    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Long getLeaderId() {
        return this.leaderId;
    }
    public void setLeaderId(Long leaderId) {
        this.leaderId = leaderId;
    }
    public Long getId() {
        return this.id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    @Generated(hash = 1935793106)
    public MemberBean(Long id, Long leaderId, String name) {
        this.id = id;
        this.leaderId = leaderId;
        this.name = name;
    }
    @Generated(hash = 1592035565)
    public MemberBean() {
    }
    //-------------------------------自動注入程式碼部分---結束

    @Override
    public String toString() {
        return "MemberBean{" +
                "id=" + id +
                ", leaderId=" + leaderId +
                ", name='" + name + '\'' +
                '}';
    }
}

3.2.2. insert一組資料

for (int i = 0; i < 2; i++) {
    LeaderBean leader = new LeaderBean();
    leader.setName("張吃啥" + (int) (Math.random() * 1000));

    GreenDaoUtil.getDaoSession(activity).getLeaderBeanDao().insert(leader);

    for (int j = 0; j < 3; j++) {
        MemberBean memberBean = new MemberBean();

        //setLeaderId，值為其所屬的leader的id（leaderBean儲存完成後，快取即可獲取到資料庫中生成的主鍵id）
        memberBean.setLeaderId(leader.getId());
        memberBean.setName("趙小" + (int) (Math.random() * 1000));

        GreenDaoUtil.getDaoSession(activity).getMemberBeanDao().insert(memberBean);
    }
}

3.3. 結語（一對多）

關於id的繫結，注意以上示例程式碼註釋

delete一個LeaderBean資料，對應的MemberBean資料不會被刪除（同一對一的效果）

4. 多對多

4.1. 註解

@JoinEntity(entity = TeacherJoinStudentBean.class,
            sourceProperty = "tId",
            targetProperty = "sId")

4.2. 示例

舉例，TeacherBean和StudentBean，每個teacher可能對應多個student，每個student也可能對應多個teacher，就如同大學的選修課

多對多的實現關鍵是一個關係繫結類（TeacherJoinStudentBean.java），這個類中只有變數teacherId和studentId，用來記錄繫結的關係

檢視以下程式碼和註釋，可以清楚的瞭解多對多如何使用（自動注入程式碼可以適當忽略）

以下程式碼主要包括實體類定義（TeacherBean.java、StudentBean.java），繫結類定義（TeacherJoinStudentBean.java），insert一組資料3個部分

4.2.1. 實體類定義

以下示例為rebuild之後的程式碼

TeacherBean.java

@Entity
public class TeacherBean {
    @Id
    private Long id;

    //entity指的是繫結類
    //sourceProperty填寫繫結類中標示自身的id，此處為tId，指TeacherBean的id
    //targetProperty填寫繫結類中標示關聯類的id，此處為sId，指StudentBean的id
    @ToMany
    @JoinEntity(entity = TeacherJoinStudentBean.class,
            sourceProperty = "tId",
            targetProperty = "sId")
    private List<StudentBean> studentBeanList;

    //-------------------------------自動注入程式碼部分---開始
    /**
     * Convenient call for {@link org.greenrobot.greendao.AbstractDao#refresh(Object)}.
     * Entity must attached to an entity context.
     */
    @Generated(hash = 1942392019)
    public void refresh() {
        if (myDao == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        myDao.refresh(this);
    }

    /**
     * Convenient call for {@link org.greenrobot.greendao.AbstractDao#update(Object)}.
     * Entity must attached to an entity context.
     */
    @Generated(hash = 713229351)
    public void update() {
        if (myDao == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        myDao.update(this);
    }

    /**
     * Convenient call for {@link org.greenrobot.greendao.AbstractDao#delete(Object)}.
     * Entity must attached to an entity context.
     */
    @Generated(hash = 128553479)
    public void delete() {
        if (myDao == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        myDao.delete(this);
    }

    /**
     * Resets a to-many relationship, making the next get call to query for a fresh result.
     */
    @Generated(hash = 747728825)
    public synchronized void resetStudentBeanList() {
        studentBeanList = null;
    }

    /**
     * To-many relationship, resolved on first access (and after reset).
     * Changes to to-many relations are not persisted, make changes to the target entity.
     */
    @Generated(hash = 767851859)
    public List<StudentBean> getStudentBeanList() {
        if (studentBeanList == null) {
            final DaoSession daoSession = this.daoSession;
            if (daoSession == null) {
                throw new DaoException("Entity is detached from DAO context");
            }
            StudentBeanDao targetDao = daoSession.getStudentBeanDao();
            List<StudentBean> studentBeanListNew = targetDao._queryTeacherBean_StudentBeanList(id);
            synchronized (this) {
                if (studentBeanList == null) {
                    studentBeanList = studentBeanListNew;
                }
            }
        }
        return studentBeanList;
    }

    /**
     * Used for active entity operations.
     */
    @Generated(hash = 121856788)
    private transient TeacherBeanDao myDao;
    /**
     * Used to resolve relations
     */
    @Generated(hash = 2040040024)
    private transient DaoSession daoSession;

    public Long getId() {
        return this.id;
    }

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

    @Generated(hash = 121852154)
    public TeacherBean(Long id) {
        this.id = id;
    }

    @Generated(hash = 1376380279)
    public TeacherBean() {
    }

    /** called by internal mechanisms, do not call yourself. */
    @Generated(hash = 1588249045)
    public void __setDaoSession(DaoSession daoSession) {
        this.daoSession = daoSession;
        myDao = daoSession != null ? daoSession.getTeacherBeanDao() : null;
    }
    //-------------------------------自動注入程式碼部分---結束

    @Override
    public String toString() {
        return "TeacherBean{" +
                "id=" + id +
                ", studentBeanList=" + (getStudentBeanList().size() == 0 ? "null" : getStudentBeanListStr()) +
                '}';
    }

    private String getStudentBeanListStr() {
        String studentBeanListStr = "";
        for (StudentBean studentBean : getStudentBeanList()) {
            studentBeanListStr = studentBeanListStr + studentBean.toStringStudentBeanOnly() + ";";
        }
        return studentBeanListStr;
    }

    /**
     * 用於student列印時呼叫
     * 僅列印TeacherBean的屬性，不列印關聯的student,否則死迴圈StackOverflowError
     *
     * @return
     */
    public String toStringTeacherBeanOnly() {
        return "TeacherBean{" +
                "id=" + id +
                '}';
    }
}

StudentBean.java

@Entity
public class StudentBean {
    @Id
    private Long id;

    //entity指的是繫結類
    //sourceProperty填寫繫結類中標示自身的id，此處為sId，指StudentBean的id
    //targetProperty填寫繫結類中標示關聯類的id，此處為tId，指TeacherBean的id
    @ToMany
    @JoinEntity(entity = TeacherJoinStudentBean.class,
            sourceProperty = "sId",
            targetProperty = "tId")
    private List<TeacherBean> teacherBeanList;

    //-------------------------------自動注入程式碼部分---開始
    /**
     * Convenient call for {@link org.greenrobot.greendao.AbstractDao#refresh(Object)}.
     * Entity must attached to an entity context.
     */
    @Generated(hash = 1942392019)
    public void refresh() {
        if (myDao == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        myDao.refresh(this);
    }

    /**
     * Convenient call for {@link org.greenrobot.greendao.AbstractDao#update(Object)}.
     * Entity must attached to an entity context.
     */
    @Generated(hash = 713229351)
    public void update() {
        if (myDao == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        myDao.update(this);
    }

    /**
     * Convenient call for {@link org.greenrobot.greendao.AbstractDao#delete(Object)}.
     * Entity must attached to an entity context.
     */
    @Generated(hash = 128553479)
    public void delete() {
        if (myDao == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        myDao.delete(this);
    }

    /**
     * Resets a to-many relationship, making the next get call to query for a fresh result.
     */
    @Generated(hash = 832141143)
    public synchronized void resetTeacherBeanList() {
        teacherBeanList = null;
    }

    /**
     * To-many relationship, resolved on first access (and after reset).
     * Changes to to-many relations are not persisted, make changes to the target entity.
     */
    @Generated(hash = 299074847)
    public List<TeacherBean> getTeacherBeanList() {
        if (teacherBeanList == null) {
            final DaoSession daoSession = this.daoSession;
            if (daoSession == null) {
                throw new DaoException("Entity is detached from DAO context");
            }
            TeacherBeanDao targetDao = daoSession.getTeacherBeanDao();
            List<TeacherBean> teacherBeanListNew = targetDao._queryStudentBean_TeacherBeanList(id);
            synchronized (this) {
                if (teacherBeanList == null) {
                    teacherBeanList = teacherBeanListNew;
                }
            }
        }
        return teacherBeanList;
    }

    /**
     * Used for active entity operations.
     */
    @Generated(hash = 1251043925)
    private transient StudentBeanDao myDao;
    /**
     * Used to resolve relations
     */
    @Generated(hash = 2040040024)
    private transient DaoSession daoSession;

    public Long getId() {
        return this.id;
    }

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

    @Generated(hash = 881285408)
    public StudentBean(Long id) {
        this.id = id;
    }

    @Generated(hash = 2097171990)
    public StudentBean() {
    }

    /** called by internal mechanisms, do not call yourself. */
    @Generated(hash = 2072577263)
    public void __setDaoSession(DaoSession daoSession) {
        this.daoSession = daoSession;
        myDao = daoSession != null ? daoSession.getStudentBeanDao() : null;
    }
    //-------------------------------自動注入程式碼部分---結束

    @Override
    public String toString() {
        String teacherBeanListStr = "";
        if (getTeacherBeanList().size() > 0) {
            for (TeacherBean teacherBean : getTeacherBeanList()) {
                teacherBeanListStr = teacherBeanListStr + teacherBean.toStringTeacherBeanOnly() + ";";
            }
        } else {
            teacherBeanListStr = "null";
        }

        return "StudentBean{" +
                "id=" + id +
                ", teacherBeanList=" + (getTeacherBeanList().size() == 0 ? "null" : getTeacherBeanListStr()) +
                '}';
    }

    private String getTeacherBeanListStr() {
        String teacherBeanListStr = "";
        for (TeacherBean teacherBean : getTeacherBeanList()) {
            teacherBeanListStr = teacherBeanListStr + teacherBean.toStringTeacherBeanOnly() + ";";
        }
        return teacherBeanListStr;
    }

    /**
     * 用於teacher列印時呼叫
     * 僅列印StudentBean的屬性，不列印關聯的teacher,否則死迴圈StackOverflowError
     *
     * @return
     */
    public String toStringStudentBeanOnly() {
        return "StudentBean{" +
                "id=" + id +
                '}';
    }
}

4.2.2. 繫結類定義

TeacherJoinStudentBean.java

繫結類，包含teacher的id和student的id

@Entity
public class TeacherJoinStudentBean {
    @Id
    private Long id;
    private Long tId;
    private Long sId;

    //-------------------------------自動注入程式碼部分---開始
    public Long getSId() {
        return this.sId;
    }
    public void setSId(Long sId) {
        this.sId = sId;
    }
    public Long getTId() {
        return this.tId;
    }
    public void setTId(Long tId) {
        this.tId = tId;
    }
    public Long getId() {
        return this.id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    @Generated(hash = 998000662)
    public TeacherJoinStudentBean(Long id, Long tId, Long sId) {
        this.id = id;
        this.tId = tId;
        this.sId = sId;
    }
    @Generated(hash = 1542025906)
    public TeacherJoinStudentBean() {
    }
    //-------------------------------自動注入程式碼部分---結束
}

4.2.3. insert一組資料

//2個教師和3個學生的關係
//教師1，帶學生1、2
//教師2，帶學生1、3
//學生1，選修教師1和教師2的課

List<TeacherBean> teacherList = new ArrayList<TeacherBean>();
for (long i = 1; i < 3; i++) {
    TeacherBean teacherBean = new TeacherBean();
    teacherBean.setId(i);
    teacherList.add(teacherBean);
}
GreenDaoUtil.getDaoSession(activity).getTeacherBeanDao().insertInTx(teacherList);

List<StudentBean> studentList = new ArrayList<StudentBean>();
for (long j = 1; j < 4; j++) {
    StudentBean studentBean = new StudentBean();
    studentBean.setId(j);
    studentList.add(studentBean);
}
GreenDaoUtil.getDaoSession(activity).getStudentBeanDao().insertInTx(studentList);

List<TeacherJoinStudentBean> teacherJoinStudentList = new ArrayList<TeacherJoinStudentBean>();
//教師1帶學生1、2
TeacherJoinStudentBean teacherJoinStudentBean1 = new TeacherJoinStudentBean(null,1l,1l);
teacherJoinStudentList.add(teacherJoinStudentBean1);

TeacherJoinStudentBean teacherJoinStudentBean2 = new TeacherJoinStudentBean(null,1l,2l);
teacherJoinStudentList.add(teacherJoinStudentBean2);

//教師2帶學生1、3
TeacherJoinStudentBean teacherJoinStudentBean3 = new TeacherJoinStudentBean(null,2l,1l);
teacherJoinStudentList.add(teacherJoinStudentBean3);

TeacherJoinStudentBean teacherJoinStudentBean4 = new TeacherJoinStudentBean(null,2l,3l);
teacherJoinStudentList.add(teacherJoinStudentBean4);

GreenDaoUtil.getDaoSession(activity).getTeacherJoinStudentBeanDao().insertInTx(teacherJoinStudentList);

4.3. 結語（多對多）

關於id的繫結，注意以上示例程式碼註釋

說實話多對多比較坑，感覺沒什麼使用的必要，可能我還沒遇到能用到的專案，如果你有好的例子，歡迎留言連結

GreenDao教程(3)：一對一，一對多，多對多

1. 前言主要介紹GreenDao 一對一，一對多，多對多應用這部分還是有些坑的，注意看示例程式碼中註釋即可避開本文資料來源網路公開資源，並根據個人實踐見解純手打整理，如有錯誤請隨時指出。本文主要用於個人積累及分享，文中可能引用其他技術大牛

“遍體鱗傷”的直播開發：一對一原始碼+一對多+商城，能否“梅開二度”

“春花秋月何時了，往事知多少？” 對於風生水起的自媒體直播平臺，首先是流量向頭部平臺集中，所有流量會湧向這些大財團、大資本支援的平臺；第二是運營方式將更加多元化；第三是行業TOP3將更加明顯，中小平臺的生存環境會越來越艱難；無論是在秀場、直播、電商、泛娛樂、遊戲，每個垂直細分領域大概會留兩到三家平臺；第四是

Ogre基礎教程3：地形，天空，煙霧

本教程將專注於在一個場景中渲染地形。我們將涉及到需要被完成的基本設定，並且將介紹地形光照的使用。我們也會給出對使用天空盒(Skyboxes)、天空穹頂(Skydomes)以及天空面(Skyplanes)來模擬一片天空的一個簡明介紹。最後，我們會解釋如

node.js零基礎詳細教程(7)：node.js操作mongodb，及操作方法的封裝

font 裏的 ges 格式上進 ins 方法回調函數方式第七章建議學習時間4小時課程共10章學習方式：詳細閱讀，並手動實現相關代碼學習目標：此教程將教會大家安裝Node、搭建服務器、express、mysql、mongodb、編寫後臺業務邏輯、編寫接口

Gulp教程之：Gulp能做什麼，前端裝逼為何要用它

我們先說說平時web開發遇到的一些場景和苦惱無奈的情況： JavaScript和CSS的版本問題我們都知道 JavaScript和CSS屬於靜態檔案，如果地址不變，瀏覽器會快取這些檔案，那就意味著當我們需要改JavaScript或者CSS檔案的時候，即使我們後端改了，那麼客戶端也是看

tensorflow基本教程3：variable

#定義varible必須初始化 import tensorflow as tf state=tf.Variable(0,name='counter') one=tf.constant(1) new_value=tf.add(state,one) update=tf.assign(state,

易學筆記-RabbitMQ教程3：一個訊息發給所有消費者（路由器型別為：fanout）

RabbitMQ教程3：一個訊息發給多個消費者程式碼基礎：易學筆記-RabbitMQ教程1：一個生產者和一個消費者錯誤的訊息佇列模型生產者：傳送訊息的使用者程式佇列：儲存訊息的緩衝區消費者：接收訊息的使用者程式

Java：演算法 - 開局一對兔，兩月就成熟

題目：古典問題：有一對兔子，從出生後第3個月起每個月都生一對兔子，小兔子長到第三個月後每個月又生一對兔子，假如兔子都不死，問每個月的兔子對數為多少？程式分析：哇是斐波那契數列1,1,2,3,5,8,13,21… 用遞迴fn = fn-1 +fn-2 吐槽：題幹別讀成小兔子長到第三個月後

#地圖故事#教程3：如何製作分級大小地圖

新增資料在首頁點選“製圖地圖”導航欄或滾動圖片上的“開始製圖”按鈕，就可以線上製作地圖了。第一：選擇模板。在“分級大小地圖”處，預設以點繪製資料，然後點選“開始製作”。第二：新增資料。可以選擇“上傳檔案”，也可以選擇“線上填寫”。這裡選擇“上傳檔案”這種方式。

GreenDao教程(2)：基本應用

1. 前言主要介紹GreenDao的基本應用。本文資料來源網路公開資源，並根據個人實踐見解純手打整理，如有錯誤請隨時指出。本文主要用於個人積累及分享，文中可能引用其他技術大牛文章（僅引用連結不轉載），如有侵權請告知必妥善處理。 2.

R極簡教程-3：R及RStudio的安裝

說到R語言的安裝，再Windows平臺上是很簡單的。但是再Linux平臺上簡直就是一場噩夢……尤其是針對最新的R3.4等版本，每一次安裝R能夠在2小時內弄完，我就覺得是一個成功了。額外提一句，現在Microsoft開發了一種效率更高的R語言，叫做Mic

C語言專案教程3：求給定數的百位、十位和個位

本教材基於硬體講解C語言程式設計，由淺入深，開發環境基於Atmel Studio 7.0，僅適合初學者，教學使用，高手請繞過。專案名稱：求給定數的百位、十位和個位。除錯步驟：參照https://blog.csdn.net/qingwufeiyang12

自然語言處理學習3：中文分句re.split()，jieba分詞和詞頻統計FreqDist

1. 使用re.split() 分句，re.split(delimiter, text) import jieba import re # 輸入一個段落，分成句子，可使用split函式來實現 paragraph = "生活對我們任何人來說都不容易！我們必須努力，最重要的是

Webgis實踐3：生成圖層列表，複選圖層是否可見

/*上面都是表頭檔案，引入庫啥的。*/ dojo.require("esri.map"); var layer, map, visible = []; /*宣告layer、map、visible*/ function init

Git詳細使用教程(3)：git add, git commit詳解

創建 sta inf 詳解使用教程都是 index comm 博客在使用git之前，我們首先要初始化一個git管理的倉庫,這裏以博客(blog)為例 git init blog 我們進入目錄，執行git status查看git狀態,可以看到一個新的git管理的項目目

小猿圈python視頻教程講師：python開發語言的就業薪資有多高

人才 tiobe images 必須薪資由於機器推出 python爬蟲 2019年IT最受歡迎語言榜java第一次滑落了王座，python開發語言摘頂王冠。自從人工智能開始進入大眾視野，python成為了高薪就業的標簽。越來越多的年輕人通過python開發技術實現了

SpringMVC教程3【檔案上傳下載，靜態資源處理及資料校驗】

一，檔案上傳 web.xml配置通用 <?xml version="1.0" encoding=&q

在.NET Core中使用MongoDB明細教程(3)：Skip, Sort, Limit, Projections

![](https://img2020.cnblogs.com/blog/1377250/202008/1377250-20200818205326644-42430411.png) 到目前為止，我們已經討論了建立文件, 檢索文件，現在讓我們來研究一下文件排序，指定要跳過或限制返回的文件數量，以及如何進行投影

Raft算法系列教程3：日誌複製

1、日誌複製的過程 Leader選出後，就開始接收客戶端的請求。Leader把請求作為日誌條目（Log entries）加入到它的日誌中，然後並行的向其他伺服器發起 AppendEntries RPC 複製日誌條目。當這條日誌被複制到大多數伺服器上，Leader將這條日誌應用到它的狀態機並向客戶端返回執行結果

EL之Boosting之GB：利用梯度提升法解決迴歸(對多變數的資料集+實數值評分預測)問題

EL之Boosting之GB：利用梯度提升法解決迴歸(對多變數的資料集+實數值評分預測)問題輸出結果設計思路核心程式碼 xList = [] labels = [] names = [] firstLine = T

GreenDao教程(3)：一對一，一對多，多對多

1. 前言

2. 一對一

2.1. 註解

2.2. 示例

2.2.1. 實體類定義

2.2.2. insert一組資料

2.2.3. delete一組資料

2.3. 結語（一對一）

3. 一對多

3.1. 註解

3.2. 示例

3.2.1. 實體類定義

3.2.2. insert一組資料

3.3. 結語（一對多）

4. 多對多

4.1. 註解

4.2. 示例

4.2.1. 實體類定義

4.2.2. 繫結類定義

4.2.3. insert一組資料

4.3. 結語（多對多）

相關推薦