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

最新推荐文章于 2024-04-11 00:40:25 发布
最新推荐文章于 2024-04-11 00:40:25 发布
阅读量1.3w 收藏 21
点赞数 16
分类专栏： Android进阶实践 文章标签： GreenDao Android sqlite
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RobotHost/article/details/70098744
版权

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的绑定，注意以上示例代码注释
  • 说实话多对多比较坑，感觉没什么使用的必要，可能我还没遇到能用到的项目，如果你有好的例子，欢迎留言链接
RobotHost
关注
专栏目录
GreenDAODemo:greenDAO演示。 简单易用；一对多
04-29
GreenDAODemogreenDAO demo. simple use ;...这个是生成代码保存的包名 targetGenDir 'E:\\GreenDAODemo\\app\\src\\main\\java'//保存到java代码路径 }升级时候别忘了改版本号，targetGenDir地址一定要写对
GreenDao一对多关系操作
君羊
09-24 5691
&amp;amp;amp;nbsp; 概述 &amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;&amp;amp;amp;nbsp;GreenDAO是一个对象关系映射（ORM）的框架，能够提供一个接口通过操作对象的方式去操作关系型数据库
使用GreenDao创建表、关联表（一对一，一对多，多对多）、CURD、升级数据库等操作
热门推荐
zhanlv的博客
09-05 1万+
        应用场景：从照片中找出包含有用户人脸的照片，并保存该照片中的人脸特征、使用该特征和用户人脸特征对比，满足条件，照片就保存到该用户表里 一、创建表 GreenDao托管地址：https://github.com/greenrobot/greenDAO 官方文档：http://greenrobot.org/greendao/documentation/updating-to-gr...
Android数据库存储GreenDao 3.0(一对多 多对多关联) 详解实例
深南大盗的博客
05-03 2000
今天一大早收到GreenDao 3.0 正式发布的消息，自从2014年接触GreenDao至今，项目中一直使用GreenDao框架处理数据库操作，本人使用数据库路线 Sqlite---->OrmLite---->GreenDao GreenDao 介绍： greenDAO是一个对象关系映射（ORM）的框架，能够提供一个接口通过操作对象的方式去操作关系型数据库，它能够让你操...
Android GreenDao 一对一，一对多，多对多关系表的创建
7758258博客
04-03 132
GreenDao
Android GreenDao 使用全面讲解，2024最新大厂Android面经
m0_61549781的博客
03-28 880
这里附上上述的面试题相关的几十套字节跳动，京东，小米，腾讯、头条、阿里、美团等公司19年的面试题。网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。从GreenDao 3 使用注解来定义模型和实体，前面也讲过，通过注解的使用可以快速构建数据库表，包括设置主键，自增，值是否唯一等等等……
greendao 一对多
06-26
简单对greendao实现一对多张表的添加与查询， @ToMany(referencedJoinProperty = "parentId") 举例，teacher和studeng，每个teacher可能对应多个student
博客(GreenDao一对多关系操作)的示例demo
09-24
**博客GreenDao一对多关系操作示例Demo** 在Android应用开发中，数据库管理是一个不可或缺的部分。GreenDao是一款高效、轻量级的对象关系映射（ORM）框架，它使得Java对象和SQLite数据库之间的交互变得简单。本示例...
GreenDaoDemo.7z
11-14
Android中关系型数据库 GreenDao 3.2.2的使用 Demo，详细了解请移步：https://blog.csdn.net/zxc514257857/article/details/103061554
GreenDao3.2表关联、缓存
03-28
android studio分步讲解greendao3.2 表关联一对一 一对多的过程 及升级版本过程的一些坑 可参考详细文章：http://blog.csdn.net/jamesp1949/article/details/62887954
GreenDao的使用
10-26
greendao的导入基本使用，里面有外键一对一关联（ToOne）和一对多关联(ToMany)的详细使用和十分齐全的查询姿势。
Android GreenDao 使用全面讲解，2024年最新Android性能优化总结
最新发布
2401_84160041的博客
04-11 1182
初始化完成之后重新rebuild一下项目会发现在设置的targetGenDir的目录生成三个类文件，这个是GreenDao自动生成的！说明数据库已经连接好了，咱们接下来只需要进行数据库的增删改查操作就行了。Let’s Go!
GreenDao一对一，一对多查询
callmeL的博客
07-22 3020
  实体类中如何进行数据库表中的关联。GreenDao实现的很简单。 一对一，使用注解@ToOne（），括号中参数为对应表对应的外键 public class Son { @Id(autoincrement = true) private Long id; private String name; private int age; pr...
【Android】ORM数据库框架之GreenDao【关联】关系操作
风吹起如花般细碎流年
07-17 2936
上一篇我们介绍了greendao的基本使用方法，如果您还不了解，建议先看下上篇文章再来看这篇会有更好的效果。今天我们来继续学习greendao的relation部分，即数据表的关联操作部分，greendao默认支持一对一，一对多的关系操作，多对多目前暂不支持，下面我们来一步步实现greendao的关联操作；1.一对一关系
GreenDao中一对多的处理
weixin_34270865的博客
04-21 263
问题描述： 现有一个实体类Card(证件)  其中有属性：id、证件名称、姓名、卡号、备注，以及证件的照片，其中证件的照片可能有多张（1到4张），故需要用到一对多的关系。 思路：设计两张表，然后建立对应关系 证件类：Card 照片类：Photo GreenDao语法： @ToMany(referencedJoinProperty = "...
Android系列之GreenDao连表查询(二)
u010227042的博客
05-11 1396
背景 上一篇文章 Android系列之GreenDao基本使用（增、删、改、查）给大家介绍的GreenDao最基本的用法。看完上篇文章之后，大家对于基本的增删改查应该都已经学会了。那么这篇文章就给大家介绍下在GreenDao中如何进行连表查询。 GreenDao内置的注解@ToMany @ToOne 连表查询无非是这三种情况： 1.一对一 @ToOne 2. 一对多 @ToMany 3. 多对多 @ToMany //@JoinEntity注解：entity 中间表；sourceProper
Spring源码(二) refresh()
10-30 193
AbstractApplicationContext @Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { //准备刷新 prepareRefresh(); //获取新鲜的beanFactory ConfigurableListableBeanFactory beanFactory = o
GreenDao之一基本使用（ToOne,ToMany都附源代码）
qq_34723470的博客
10-25 3818
说起greendao的就要将3.0版本，3.0之前是通过java类的main方法来生成一些操作数据库的类；3.0之后是直接用注解来写实体生成对应的数据库表和操作类。   以下是3.2需要导入的依赖： compile 'org.greenrobot:greendao:3.2.0' compile 'org.greenrobot:greendao-generator:3.2.0'green
Android的greenDao一对多的关系
soha_dong的博客
01-01 2654
@Entity public class TestIndex { @Id private Long id; private String name; @ToMany(referencedJoinProperty = "indexId") private List<TestNum> testNumList; } @Entity public class TestNum { @Id private Long id; pr.
GreenDao一对多的使用
05-04
GreenDao是一种轻量级的ORM框架，它可以帮助开发人员更加方便地操作数据库。在GreenDao中，一对多的关系可以使用注解@ToMany来定义。 下面是一个示例： ``` @Entity public class User { @Id private Long id; private String name; @ToMany(referencedJoinProperty = "userId") private List<Address> addresses; // getters and setters } @Entity public class Address { @Id private Long id; private String street; private String city; private String state; private String zip; private Long userId; // getters and setters } ``` 在上面的示例中，User和Address之间是一对多的关系。使用@ToMany注解表示User可以有多个Address对象，referencedJoinProperty属性指定在Address实体中用于关联User的属性。 要在GreenDao中查询一对多关系，可以使用Query类的list方法和相关的QueryBuilder对象，例如： ``` List<User> users = userDao.queryBuilder() .where(UserDao.Properties.Name.eq("John")) .list(); for (User user : users) { List<Address> addresses = user.getAddresses(); // do something with addresses } ``` 在上面的示例中，首先使用userDao.queryBuilder()获取QueryBuilder对象，然后使用where方法指定查询条件，最后使用list方法获取符合条件的User对象列表。接着，遍历User对象列表，并使用getAddresses方法获取每个User对象的Address列表。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值