greenDao框架浅入深出

首先我要说明一下在众多的数据库框架当中为什么我要花时间去学习greendao这个框架，如果按照学习成本估算的话，学习这个数据库框架最花时间，最难理解的，凡是有利有弊，那为什么还要继续学习呢？？？
androrm，Ormlite,greenDao三个主流框架greenDao似乎是三种框架中效率最高的。
GreenDao设计目的：最大性能，最快的Android ORM框架，易于使用的API，高度优化，最小内存的损耗
这些就是我们客户端一直追求的性能好了废话不多说，直入主题。
第一步环境搭建
首先下载架包一、新建一个JAVA工程，用于装载GreenDao类，生成Dao类文件，在这个工程里面必须导入 greendao-generator.jar和freemarker.jar，注意这里是生成java工程而不是android工程，也许这里比较麻烦，本人使用的是androidstudio所以这里详细讲解一下框架配置
新建存放greenDAO的生成目录
在 */src/main目录下新建一个与 java 同层级的java-gen目录，用于存放由 greenDAO 生成的 Bean、DAO、DaoMaster、DaoSession类:然后配置 Android工程（app）的 build.gradle脚本如下图

这个至关重要
然后新建一个java工程（module）用于生成DAO（数据库）
过程步骤如下图：
新建模块

选择library

填写包名类名点击完成

配置该模块工程的 build.gradle，添加 dependencies：
然后就是编写java类：代码如下：

package com.batways.apopo.generator;

import de.greenrobot.daogenerator.DaoGenerator;
import de.greenrobot.daogenerator.Entity;
import de.greenrobot.daogenerator.Property;
import de.greenrobot.daogenerator.Schema;
import de.greenrobot.daogenerator.ToMany;

/**
 * @ClassName: TestCase
 * @author victor_freedom (x_freedom_reddevil@126.com)
 * @createddate 2015-1-12 下午2:17:52
 * @Description: TODO
 */
public class TestCase {
    // 数据库升级
    private static int dbVersion = 1;
    private String modelPackage = "com.example.freedomsql.bean";
    private Schema schema = new Schema(dbVersion, modelPackage);

    public static void main(String[] args) throws Exception {
        TestCase testCase = new TestCase();
        testCase.init();
        testCase.schema.enableKeepSectionsByDefault();
        testCase.schema.enableActiveEntitiesByDefault();
        new DaoGenerator().generateAll(testCase.schema,
                "E:\\mayflygeek\\mayflygeekprojects\\FreedomSql\\src");
    }

    public void init() {

        // 定义一个实体
        Entity OrderHeader = schema.addEntity("OrderHeader");
        // 实现序列化接口
        OrderHeader.implementsSerializable();
        // 定义ID主键
        OrderHeader.addIdProperty();
        // 增加其他字段，这里可以定义很多类型，还可以指定属性
        OrderHeader.addStringProperty("orderName").notNull();

        //如果不想用上面的定义ID主键，还可以自己这样定义。
//      OrderHeader.addLongProperty("orderId").primaryKey().autoincrement();

        //后面的实体定义和上面的差不多。就不在详细描述
        Entity OrderItem = schema.addEntity("OrderItem");
        OrderItem.implementsSerializable();
        OrderItem.addIdProperty();
        OrderItem.addStringProperty("itemName");
        // 用于做多表设计使用
        Property orderId = OrderItem.addLongProperty("orderId").getProperty();

        Entity Student = schema.addEntity("Student");
        Student.implementsSerializable();
        Student.addIdProperty();
        Student.addStringProperty("studentName");
        // 增加一个字段，数据库升级
        // Student.addDoubleProperty("results");

        Entity Teacher = schema.addEntity("Teacher");
        Teacher.implementsSerializable();
        Teacher.addIdProperty();
        Teacher.addStringProperty("teacherName");

        Entity StudentTeacher = schema.addEntity("StudentTeacher");
        Property teacherId = StudentTeacher.addLongProperty("teacherId")
                .getProperty();
        Property studentId = StudentTeacher.addLongProperty("studentId")
                .getProperty();

        // Entity Grade = schema.addEntity("Grade");
        // Grade.implementsSerializable();
        // Grade.addIdProperty();
        // Grade.addStringProperty("gradeName");

        // 树状结构，自身实现1对多
        Entity Tree = schema.addEntity("Tree");
        Tree.addIdProperty();
        Tree.addStringProperty("treeName");
        Property parentId = Tree.addLongProperty("parentId").getProperty();
        Tree.addToOne(Tree, parentId).setName("parent");
        Tree.addToMany(Tree, parentId).setName("children");

        // 外键添加,1对多
        OrderItem.addToOne(OrderHeader, orderId);
        ToMany addToMany = OrderHeader.addToMany(OrderItem, orderId);
        addToMany.setName("orderItems");

        // greenDao不支持多对多的实现，但是我们可以 自定义实现多对多
        StudentTeacher.addToOne(Student, studentId);
        StudentTeacher.addToOne(Teacher, teacherId);
        Student.addToMany(StudentTeacher, studentId)
                .setName("studentsteachers");
        Teacher.addToMany(StudentTeacher, teacherId)
                .setName("studentsteachers");

    }
}

到这里，环境算是配置OK了，下面开始撸代码了：
首先操作数据局demo代码如下接口类：

package com.example.freedomsql.service;

import com.example.freedomsql.bean.OrderHeader;
import com.example.freedomsql.bean.OrderItem;
import com.example.freedomsql.bean.Student;
import com.example.freedomsql.bean.Teacher;

public interface IOrderHeaderService {

    /**
     * @Title: createOrder
     * @Description: 创建一个订单
     * @param order
     * @return
     * @throws
     */
    public OrderHeader createOrder(OrderHeader order);

    /**
     * @Title: updateOrder
     * @Description: 更新一个订单
     * @param orderHeader
     * @return
     * @throws
     */
    public OrderHeader updateOrder(OrderHeader orderHeader);

    /**
     * @Title: findOrderByName
     * @Description: 根据名称查找订单
     * @param orderName
     * @return
     * @throws
     */
    public OrderHeader findOrderByName(String orderName);

    /**
     * @Title: findOrderById
     * @Description: 根据主键ID查找订单
     * @param orderId
     * @return
     * @throws
     */
    public OrderHeader findOrderById(long orderId);

    /**
     * @Title: findOrderItemById
     * @Description:根据主键ID查找订单明细
     * @param orderItemId
     * @return
     * @throws
     */
    public OrderItem findOrderItemById(long orderItemId);

    /**
     * @Title: findOrderItemByName
     * @Description: 根据名称查找订单明细
     * @param orderItemName
     * @return
     * @throws
     */
    public OrderItem findOrderItemByName(String orderItemName);

    /**
     * @Title: createOrderItem
     * @Description: 创建订单明细
     * @param orderHeader
     * @param name
     * @return
     * @throws
     */
    public OrderItem createOrderItem(OrderHeader orderHeader, String name);
}

实现类：

package com.example.freedomsql.service.impl;

import android.content.Context;

import com.example.freedomsql.bean.DaoSession;
import com.example.freedomsql.bean.GreenDao;
import com.example.freedomsql.bean.OrderHeader;
import com.example.freedomsql.bean.OrderHeaderDao;
import com.example.freedomsql.bean.OrderItem;
import com.example.freedomsql.bean.OrderItemDao;
import com.example.freedomsql.service.IOrderHeaderService;

/**
 * @ClassName: OrderHeaderService
 * @author victor_freedom (x_freedom_reddevil@126.com)
 * @createddate 2015-1-12 下午3:26:41
 * @Description: TODO
 */
public class OrderHeaderService implements IOrderHeaderService {

    private static DaoSession daoSession;
    private static OrderHeaderService service;
    private OrderHeaderDao orderHeaderDao;
    private OrderItemDao orderItemDao;

    private OrderHeaderService(OrderHeaderDao orderHeaderDao,
            OrderItemDao orderItemDao) {
        this.orderHeaderDao = orderHeaderDao;
        this.orderItemDao = orderItemDao;
    }

    /**
     * @param context
     * @return
     */
    public static OrderHeaderService getService(Context context) {
        if (service == null) {
            daoSession = GreenDao.getDaoSession(context);
            service = new OrderHeaderService(daoSession.getOrderHeaderDao(),
                    daoSession.getOrderItemDao());
        }
        return service;
    }

    @Override
    public OrderHeader createOrder(OrderHeader order) {
        return orderHeaderDao.loadByRowId(orderHeaderDao.insert(order));
    }

    @Override
    public OrderHeader updateOrder(OrderHeader orderHeader) {
        orderHeaderDao.update(orderHeader);
        return orderHeader;
    }

    @Override
    public OrderHeader findOrderByName(String orderName) {
        OrderHeader orderHeader = orderHeaderDao.queryBuilder()
                .where(OrderHeaderDao.Properties.OrderName.eq(orderName))
                .unique();
        return orderHeader;
    }

    @Override
    public OrderHeader findOrderById(long orderId) {
        return orderHeaderDao.load(orderId);
    }

    @Override
    public OrderItem findOrderItemById(long orderItemId) {
        return orderItemDao.load(orderItemId);
    }

    @Override
    public OrderItem findOrderItemByName(String orderItemName) {
        return orderItemDao.queryBuilder()
                .where(OrderItemDao.Properties.ItemName.eq(orderItemName))
                .unique();
    }

    @Override
    public OrderItem createOrderItem(OrderHeader orderHeader, String name) {
        OrderItem orderItem = new OrderItem();
        orderItem.setItemName(name);
        orderItem.setOrderHeader(orderHeader);
        return orderItemDao.load(orderItemDao.insert(orderItem));
    }

}

我们可以看到，查询条件非常容易写，这里博主只写了些简单的查询条件，在where方法中是可以支持多条件限制查询的，查询方法非常的强大，由于本博主还没有在项目中正正使用这个框架，先讲解到这里，后期将继续详细讲解这个框架原理以及实现过程。