【Android】ORM数据库框架之GreenDao【关联】关系操作

上一篇我们介绍了greendao的基本使用方法，如果您还不了解，建议先看下上篇文章再来看这篇会有更好的效果。今天我们来继续学习greendao的relation部分，即数据表的关联操作部分，greendao默认支持一对一，一对多的关系操作，多对多目前暂不支持，下面我们来一步步实现greendao的关联操作；

1.一对一关系

• 假设我们现在只允许一夫一妻制，好像现在就是啊，哈哈哈哈哈，那么一个男人可以娶一个老婆，一个老婆也只能有一个男人，下面我们分别创建man表和women表，来演示一对一的关联操作，greendao中可以用Entity.addToOne方法建立to-one关系。 addToOne方法的第一个参数是另一个实体，第二个参数是本实体的外键属性；

            
                /**
         * <男人表>
         */
        Entity man = schema.addEntity("Man");
        // 设置表名
        man.setTableName("man");
        // 身份证号
        man.addStringProperty("cardManNum").columnName("cardmannum").primaryKey();
        // 姓名
        man.addStringProperty("name").columnName("name");
        // 年龄
        man.addIntProperty("age").columnName("age");
        // 家庭住址
        man.addStringProperty("address").columnName("address");

        /**
         * <女人表>
         */
        Entity woman = schema.addEntity("Woman");
        // 设置表名
        woman.setTableName("woman");
        // 身份证号
        woman.addStringProperty("cardWomanNum").columnName("cardwomannum").primaryKey();
        // 姓名
        woman.addStringProperty("name").columnName("name");
        // 性别
        woman.addStringProperty("sex").columnName("sex");
        // 年龄
        woman.addIntProperty("age").columnName("age");
        // 家庭住址
        woman.addStringProperty("address").columnName("address");
        

• 创建一对一关联

            
                /**
         * <一对一映射>
         */
                // 在woman表中插入外键(man表的主键)进行关联
        Property cardnum = man.addStringProperty("fkmannum").getProperty();
        man.addToOne(woman, cardnum);
        // 在man表中插入外键(woman表的主键)进行关联
        Property womanCardNum = woman.addStringProperty("fkwomannum").getProperty();
        woman.addToOne(man, womanCardNum);
        

• 然后我们插入几条数据：

      man表：

      women表：

• 我们来查询下张三的媳妇是谁？

                    ManDao manDao = DBController.getDaoSession().getManDao();
        Man man = manDao.queryBuilder().where(ManDao.Properties.Name.eq("张三")).list().get(0);

        if (null != man)
        {
            //我们通过man的getWomen()方法可以直接拿到多对应的women对象
            showDbData("张三的媳妇是："+man.getWoman().getName());
        }
        

2.一对多关系

• 淘宝为例，一位顾客可以有很多订单，而一个订单只能属于一位顾客，所以这就成了一对多的关系，假设顾客Customer表有customerId（primaryKey）、name两个属性，
  订单Order表有orderId（primaryKey）、money两个属性。greendao中可以用Entity.addToMany方法建立to-many关系。 下面我们来创建表：

            
                /**
         * 顾客
         */
        Entity customer = schema.addEntity("Customer");
        // 设置表名
        customer.setTableName("customer");

        // customerId设置为主键
        customer.addLongProperty("customerId").primaryKey();

        customer.addStringProperty("name").columnName("name").notNull();

        /**
         * 订单
         */
        Entity orderinfo = schema.addEntity("OrderInfo");
        // 设置表名
        orderinfo.setTableName("orderinfo");
        // 身份证号码设置为主键
        orderinfo.addLongProperty("orderId").primaryKey();
        orderinfo.addDoubleProperty("money").notNull();

        

• 创建一对多关联

            
                /**
         * 一对多关联
         * 
         * 当设置了顾客对订单一对多关联后，Order实体（和表）中会多一个属性为customerId，
         * 所以通过订单我们可以得到该顾客信息，而Customer实体（和表）中会多一个List集合变量：
         * List<Order> orders，表示该顾客的所有订单，其中orders其实是我们自定义的名字，
         * 在刚刚setName("orders")就是给这个变量设置了“orders“名称，
         * 而Customer实体中还提供了一个方法getOrders()表示得到该顾客所有订单
         * 
         */
        Property property = orderinfo.addLongProperty("customerId").getProperty();
        // 一个订单对应一个顾客
        orderinfo.addToOne(customer, property, "customerfk");
        customer.addToMany(orderinfo, property).setName("orders");
        

• 然后我们插入几条数据：

      Customer表：

      OrderInfo表：

• 我们来查询下李四的所有订单号的价格信息：

                    CustomerDao customerDao = DBController.getDaoSession().getCustomerDao();
        Customer customer = customerDao.queryBuilder().where(CustomerDao.Properties.Name.eq("李四")).list().get(0);
        if (null != customer)
        {
            StringBuilder builder = new StringBuilder();
            // 通过customer拿到所有订单信息
            List<OrderInfo> orderInfos = customer.getOrders();
            for (int i = 0; i < orderInfos.size(); i++)
            {
                builder.append("---" + orderInfos.get(i).getMoney() + "\n");
            }
            showDbData(builder.toString());
        }
        

3.多对多关系

• 虽然greendao默认不支持多对多的关系，但是我们可以使用一对一addtoone和一对多addtomany来实现多对多的关系，举个最常见的例子，通常来说，在建立多对多关联上，我们都会采用新建一张中间表，利用中间表把多对多这种复杂关系简单化，在通常的选课系统上，一个学生可以选择多门课，一门课可以被多个学生选，这就是多对多关系了，假设Student有studentId、name两个属性， Course有courseId、courseName两个属性，下面我们来创建表：

                    // 学生
        Entity student = schema.addEntity("Student");
        student.addLongProperty("studentId").primaryKey();
        student.addStringProperty("name").notNull();

        // 课程
        Entity course = schema.addEntity("Course");
        course.addLongProperty("courseId").primaryKey();
        course.addStringProperty("courseName").notNull();

        // 建立多对多关系,StudentCourse中间表,简化多对多的关系
        Entity studentCourse = schema.addEntity("StudentCourse");
        studentCourse.addIdProperty().primaryKey();
        

• 创建多对多关联

                    Property studentId = studentCourse.addLongProperty("studentId").getProperty();
        Property courseId = studentCourse.addLongProperty("courseId").getProperty();

        // StudentCourse表分别与student和course表建立一对多关系，实现student和course的多对多
        studentCourse.addToOne(student, studentId);
        studentCourse.addToOne(course, courseId);

        student.addToMany(studentCourse, studentId);
        course.addToMany(studentCourse, courseId);
        

• 然后我们插入几条数据：

      Student表：

      Course表：

      StudentCourse表：

• 我们来查询下老王选了什么课：

                    StudentDao studentDao = DBController.getDaoSession().getStudentDao();

        List<Student> students = studentDao.queryBuilder().where(StudentDao.Properties.Name.eq("老王")).list();

        StringBuilder builder = new StringBuilder();

        Student student = students.get(0);

        List<StudentCourse> studentCourses = student.getStudentCourseList();

        for (int i = 0; i < studentCourses.size(); i++)
        {
            StudentCourse studentCourse = studentCourses.get(i);
            Course course = studentCourse.getCourse();
            builder.append("----课程:" + course.getCourseName() + "----课程ID:" + course.getCourseId());
            builder.append("\n");
        }
        showDbData(builder.toString());
        

4.自定义属性转换器

伴随着新接口PropertyConverter的出现，greendao的实体不再局限于原始的类型，如整数，字符串，日期和布尔值。通过实现PropertyConverter接口，可以定义从实体值到数据库中的值的转换。这个功能虽然简单，但是确非常的强大，保证了充分的灵活性。下面我们就来演示一下json字符串和json对象的转化，我们在数据库中存储json字符串，经过转换后直接查询出实体类的对象：

• 添加一个PersonModel实体类测试：

            
                public
                
                    class
                    PersonModel
                    implements
                    Serializable
{
                private String name;

    private String age;

    publicPersonModel(String name, String age)
    {
        super();
        this.name = name;
        this.age = age;
    }

    publicPersonModel()
    {
        super();
    }

    public String getName()
    {
        return name;
    }

    publicvoidsetName(String name)
    {
        this.name = name;
    }

    public String getAge()
    {
        return age;
    }

    publicvoidsetAge(String age)
    {
        this.age = age;
    }

    @Overridepublic String toString()
    {
        return"PersonModel [name=" + name + ", age=" + age + "]";
    }
}
        

• 我们实现PropertyConverter接口来处理转换逻辑：

            
                /**
 * 
 * 自定义数据库类型
 * 
 * Json
 */
                public
                
                    class
                    JsonPropertyConverter
                    implements
                    PropertyConverter<PersonModel, String>
{
                // 从数据库取出值后转为实体类里的类型
    @Override
    public PersonModel convertToEntityProperty(String databaseValue)
    {
        Gson gson = new Gson();
        PersonModel model = gson.fromJson(databaseValue, PersonModel.class);
        return model;
    }

    // 转换实体类该字段对应的数据库所存放的值
    @Override
    public String convertToDatabaseValue(PersonModel entityProperty)
    {
        Gson gson = new Gson();
        return gson.toJson(entityProperty);
    }

}
        

• 创建jsontable表：

            
                /**
     * 添加自定义属性
     * 此处用的gson解析
     * @param schema
     * @see [类、类#方法、类#成员]
     */
                private
                static
                void
                addPropertyConverter(Schema schema)
    {
        Entity item = schema.addEntity("JsonTable");
        item.addIdProperty().primaryKey();
        //第一个参数是我们转换后的类型的全路径，第二个是转化器类的路径
        item.addStringProperty("model").customType("com.relation.dao.PersonModel", "com.relation.dao.JsonPropertyConverter");
    }
        

• 往表里插入数据：

            JsonTableDao jsonTableDao = DBController.getDaoSession().getJsonTableDao();

        JsonTable jsonTable = new JsonTable(); 

        PersonModel model = new PersonModel();
        model.setName("周星驰");
        model.setAge("45");
        jsonTable.setModel(model);

        jsonTableDao.insertInTx(jsonTable);
        

• 查询id为1的数据：

                    JsonTableDao jsonTableDao = DBController.getDaoSession().getJsonTableDao();
        JsonTable jsonTable = jsonTableDao.queryBuilder().where(JsonTableDao.Properties.Id.eq(1)).unique();
        PersonModel model = jsonTable.getModel();
        showDbData(model.toString());
        

• 点击查询即可查询出对应的model类型的数据，可以方便我们直接使用；

到此本篇介绍基本完成，有疑问欢迎留言交流讨论！

---

源码下载