greenDao多表关联

亲测可用，如有问题请私信！

之前我们看到了greenDao的简单使用，但是就这些是远远不够的，有时候我们需要存储的数据较为复杂，这个时候我们可能需要使用到多表关联的操作。

ToOne

一对一的关系映射。看个例子：

1. @Entity

2. public class Score {

3. @Id

4. private String id;

5. private int score;

6. }

8. @Entity

9. public class Student {

10. @Id

11. private String id;

12. private String name;

13. private int age;

14. private String scoreId;

15. @ToOne(joinProperty = "scoreId")

16. private Score score;

17. }

19. //先向数据库中插入两条数据

20. Score score = new Score("1101", 80);

21. Student magicer = new Student("110","Magicer",12,"1101");

22. scoreDao.insertOrReplace(score);

23. studentDao.insertOrReplace(magicer);

25. //之后查找我们插入的数据，就可以查询出来我们想要的带有成绩的学生实体。

26. QueryBuilder<Student> queryBuilder = studentDao.queryBuilder().where(StudentDao.Properties.Name.eq("Magicer"));

27. for (Student student : queryBuilder.list()) {

28. Log.i(TAG, "onCreate: "+student.toString());

29. }

在上面的例子中，我们设定每个学生有一门成绩，这个时候就是个ToOne一对一的关系。我们通过joinProperty来设置外键。我们就可以很方便的查询出某个学生的成绩了。

1. public @interface ToOne {

2. /**

3. * Name of the property inside the current entity which holds the key of related entity.

4. * If this parameter is absent(缺少的), then an additional column is automatically created to hold the key.

5. */

6. String joinProperty() default "";

7. }

ToMany

但是一般一个学生会有多个成绩，这个时候我们就需要使用ToMany一对多的关系了。先看下例子：

2. @Entity

3. public class Student {

4. @Id

5. private String id;

6. private String name;

7. private int age;

8. @ToMany(referencedJoinProperty = "studentId")

9. private List<Score> scores;

10. }

12. @Entity

13. public class Score {

14. @Id

15. private String id;

16. private int score;

17. private String type;

18. private String studentId;

19. }

22. Score math = new Score("1101", 87, "Math", "110");

23. Score english = new Score("1102", 99, "English", "110");

24. Score chinese = new Score("1103", 120, "Chinese", "110");

25. scoreDao.insertOrReplaceInTx(math,english,chinese);//使用事务插入或替换数据

26. Student magicer = new Student("110", "Magicer", 23);

27. studentDao.insertOrReplace(magicer);

29. Query<Student> query = studentDao.queryBuilder().where(StudentDao.Properties.Name.eq("Magicer")).build();

30. for (Student student : query.list()) {

31. Log.i(TAG, "onCreate: "+student);

32. }

34. //I/MainActivity: onCreate: Student{id='110', name='Magicer', age=23, score=[Score{id='1101', score=87, type='Math', studentId='110'}, Score{id='1102', score=99, type='English', studentId='110'}, Score{id='1103', score=120, type='Chinese', studentId='110'}]}

这个时候，一个学生就有Math Enghlish Chinese三个的成绩。这个时候，我们使用referencedJoinProperty 将成绩跟学生建立了关联关系。

1. public @interface ToMany {

2. /**

3. * Name of the property inside the target entity which holds id of the source (current) entity

4. * Required unless no {@link JoinProperty} or {@link JoinEntity} is specified

5. */

6. String referencedJoinProperty() default "";

8. /**

9. * Array of matching source -> target properties

10. * Required unless {@link #referencedJoinProperty()} or {@link JoinEntity} is specified

11. */

12. JoinProperty[] joinProperties() default {};

13. }

JoinEntity

有时我们还要创建多对多的关联关系N:M。在greenDao中就使用JoinEntity注解；先来看下他的定义：

1. public @interface JoinEntity {

2. /** Reference to join-entity class, which holds the source and the target properties */

3. Class<?> entity();

5. /** Name of the property inside the join entity which holds id of the source (current) entity */

6. String sourceProperty();

8. /** Name of the property inside the join entity which holds id of the target entity */

9. String targetProperty();

10. }

配置多对多关系的时候我们需要使用到ToMany和JoinEntity通过JoinEntity注解来配置关联的建。如下：

1. @Entity

2. public class Student {

3. @Id

4. private String id;

5. private String name;

6. private int age;

8. @ToMany

9. @JoinEntity(

10. entity = Join.class,

11. sourceProperty = "studentId",

12. targetProperty = "scoreId"

13. )

14. private List<Score> scores;

15. }

16. @Entity

17. public class Join {

18. @Id

19. private String id;

20. private String studentId;

21. private String scoreId;

22. }

23. @Entity

24. public class Score {

25. @Id

26. private String id;

27. private int score;

28. private String type;

29. private String studentId;

30. }

遇到的问题

当插入到数据库中的数据是网络请求得到的时候会有些注意事项。由于greenDao会帮助我们生成一些get和set方法。这个是时候就要注意了。来看下生成的代码：

1. @Entity

2. public class Point {

3. @Id

4. private Long id;

5. private Long strokeId;

6. private int x;

7. private int y;

8. }

10. @Entity

11. public class Stroke {

12. @Id

13. private Long id;

14. private String name;

15. @ToMany(referencedJoinProperty = "strokeId")

16. private List<Point> points;

17. }

如上面，我们现在有每个笔画Stroke会有很多的Point。编译下之后会生成很多get和set方法。
我们看下Stroke的一个get方法我们会看到下面这些代码。就由于这个代码。可能就会导致。我们解析到了Stroke后调用getPoints()方法想要获取点的集合是出现问题，这时候就可能会报错。这个时候我们可以在单独写另外的一个get方法，来支持直接获取points对象。

1. @Generated(hash = 404164872)

2. public List<Point> getPoints() {

3. if (points == null) {

4. final DaoSession daoSession = this.daoSession;

5. if (daoSession == null) {

6. throw new DaoException("Entity is detached from DAO context");

7. }

8. PointDao targetDao = daoSession.getPointDao();

9. List<Point> pointsNew = targetDao._queryStroke_Points(id);

10. synchronized (this) {

11. if(points == null) {

12. points = pointsNew;

13. }

14. }

15. }

16. return points;

17. }