安卓中引入GreenDAO数据库框架，包括封装好的数据库操作工具类_import de.greenrobot.daogenerator.schema-CSDN博客

本文链接：https://blog.csdn.net/qq_23363425/article/details/52398083

1.配置工程

在./src/main目录下创建一个与java同层级的java-gen文件夹.

2.在build.gradle中配置

//buildTypes{}中配置
sourceSets {
    main {
        java.srcDirs = ['src/main/java', 'src/main/java-gen']
    }
}

3.添加依赖

dependencies {
    compile 'de.greenrobot:greendao:1.3.7'
}

4.为了操作简单可直接引入JAVA项目greendao，在安卓项目中直接添加依赖，现附上greendao的java项目

资源链接 http://download.csdn.net/detail/qq_23363425/9618837

为了方便我将代码粘出来：备注（需要在java项目中添加依赖compile('de.greenrobot:DaoGenerator:1.3.0')）


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


public class MyDaoGenerator {


    public static void main(String args[]) throws Exception {
        Schema schema = new Schema(5, "com.aaa.bean");
        // 1: 数据库版本号
        // com.xxx.bean:自动生成的Bean对象会放到/java-gen/com/xxx/bean中


        schema.setDefaultJavaPackageDao("com.aaa.dao");
        // DaoMaster.java、DaoSession.java、BeanDao.java会放到/java-gen/com/xxx/dao中


        // 上面这两个文件夹路径都可以自定义，也可以不设置


        initTable(schema); // 初始化Bean了


        new DaoGenerator().generateAll(schema, "D:\\Dao\\app\\src\\main\\java-gen");// 自动创建
    }


    private static void initTable(Schema schema) {
        Entity table = schema.addEntity("ContentEntity");// 表名
       // table.setTableName("table"); // 可以对表重命名
       //table.addLongProperty("id").primaryKey().index().autoincrement();
        table.addIdProperty().autoincrement();// 主键，索引


        table.addStringProperty("status");
        table.addLongProperty("version");
        table.addStringProperty("tableTypeId");
        table.addStringProperty("storeId");
        table.addStringProperty("name");
        table.addStringProperty("orderby");
    }
}

</pre><p></p><pre>

5.这就完成了添加，运行之后会生成相应的文件，并在控制台打印出相应的日志，搞定！

6、为了完善还可以封装添加操作db的工具类

BaseApplication

package com.wp.dao.daohelp;

import android.app.Application;
import android.content.Context;

import com.aaa.dao.DaoMaster;
import com.aaa.dao.DaoSession;

/**
 * Created by wp on 2016/8/12.
 */

public class BaseApplication extends Application {
    public static BaseApplication mInstance;
    public static DaoMaster daoMaster;
    public static DaoSession daoSession;


    @Override


    public void onCreate() {
        super.onCreate();
        if (mInstance == null)
            mInstance = this;
    }

/**
     * 取得DaoMaster
     *
     * @param context 上下文
     * @return DaoMaster
     */


    public static DaoMaster getDaoMaster(Context context) {
        if (daoMaster == null) {
            // DaoMaster.OpenHelper helper = new DaoMaster.DevOpenHelper(context,"myDb",null);
            DaoMaster.OpenHelper helper = new TableOpenHelper(context, "myDb", null);
            daoMaster = new DaoMaster(helper.getWritableDatabase());
        }
        return daoMaster;
    }

/**
     * 取得DaoSession
     *
     * @param context 上下文
     * @return DaoSession
     */


    public static DaoSession getDaoSession(Context context) {
        if (daoSession == null) {
            if (daoMaster == null) {
                daoMaster = getDaoMaster(context);
            }
            daoSession = daoMaster.newSession();
        }
        return daoSession;
    }
}

TableOpenHelper升级用
package com.wp.dao.daohelp;/*
package com.wp.dao.daohelp;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;

import com.aaa.dao.DaoMaster;
import com.aaa.dao.TableDao;

*/

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;

import com.aaa.dao.ContentEntityDao;
import com.aaa.dao.DaoMaster;

/**
 * Created by wp on 2016/8/12.
 */

public class TableOpenHelper extends DaoMaster.OpenHelper {


    public TableOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
        super(context, name, factory);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        switch (oldVersion) {
            case 1:
                //创建新表，注意createTable()是静态方法
                ContentEntityDao.createTable(db, true);

                // 加入新字段
                //db.execSQL("ALTER TABLE 'moments' ADD 'audio_path' TEXT;");

                // TODO
                break;
        }
    }
}

DbService操作数据库工具类
package com.wp.dao.daohelp;

import android.content.Context;
import android.text.TextUtils;
import android.util.Log;

import com.aaa.bean.AllData;
import com.aaa.bean.ContentEntity;
import com.aaa.dao.ContentEntityDao;
import com.aaa.dao.DaoSession;

import java.util.List;

import de.greenrobot.dao.query.QueryBuilder;
import de.greenrobot.dao.query.WhereCondition;

/**
 * Created by wp on 2016/8/15.
 */

public class DbService {
    private static final String TAG = DbService.class.getSimpleName();
    private static DbService instance;
    private static Context appContext;
    private DaoSession mDaoSession;
    private ContentEntityDao contentEntityDao;


    private DbService() {
    }

    /**
     * 采用单例模式
     *
     * @param context 上下文
     * @return dbservice
     */
    public static DbService getInstance(Context context) {
        if (instance == null) {
            instance = new DbService();
            if (appContext == null) {
                appContext = context.getApplicationContext();
            }
            instance.mDaoSession = BaseApplication.getDaoSession(context);
            instance.contentEntityDao = instance.mDaoSession.getContentEntityDao();
        }
        return instance;
    }

    /**
     * 根据用户id,取出用户信息
     *
     * @param id 用户id
     * @return 用户信息
     */
    public ContentEntity loadNote(Long id) {
        if (!TextUtils.isEmpty(id + "")) {
            return contentEntityDao.load(id);
        }
        return null;
    }


    /**
     * 取出所有数据
     *
     * @return 所有数据信息
     */
    public List<ContentEntity> loadAllNote() {
        return contentEntityDao.loadAll();
    }

    /**
     * 生成按id倒排序的列表
     *
     * @return 倒排数据
     */
    public List<ContentEntity> loadAllNoteByOrder() {
        return contentEntityDao.queryBuilder().orderDesc(ContentEntityDao.Properties.Id).list();
    }

    /**
     * 根据查询条件,返回数据列表
     *
     * @param where  条件
     * @param params 参数
     * @return 数据列表
     */
    public List<ContentEntity> queryNote(String where, String... params) {
        return contentEntityDao.queryRaw(where, params);
    }


    /**
     * 根据用户信息,插件或修改信息
     *
     * @param user 用户信息
     * @return 插件或修改的用户id
     */
    public long saveorReplace(ContentEntity user) {
        return contentEntityDao.insertOrReplace(user);
    }

    public long saveNote(ContentEntity user) {
        return contentEntityDao.insert(user);
    }


    /**
     * 批量插入或修改用户信息
     *
     * @param list 用户信息列表
     */
    public void saveNoteLists(final List<ContentEntity> list) {
        if (list == null || list.isEmpty()) {
            return;
        }
        contentEntityDao.getSession().runInTx(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < list.size(); i++) {
                    ContentEntity user = list.get(i);
                    //if (!instance.loadAllNote().equals(user.)){
                    contentEntityDao.insertOrReplace(user);
                    // }
                }
            }
        });

    }


    /**
     * 删除所有数据
     */
    public void deleteAllNote() {
        contentEntityDao.deleteAll();
    }

    /**
     * 根据id,删除数据
     *
     * @param id 用户id
     */
    public void deleteNote(long id) {
        contentEntityDao.deleteByKey(id);
        Log.i(TAG, "delete");
    }

    /**
     * 根据用户类,删除信息
     *
     * @param user 用户信息类
     */
    public void deleteNote(ContentEntity user) {
        contentEntityDao.delete(user);
    }


    public List queryPerson(WhereCondition arg0, WhereCondition... conditions) {
        QueryBuilder qb = contentEntityDao.queryBuilder();
        qb.where(arg0, conditions);
        List personList = qb.list();
        return personList;
    }

    /**
     * 检查数据库有没有重复数据 如果有 添加
     *
     * @param newList
     * @return
     */
    public void checkPersonExistAndUpdate(List<ContentEntity> newList) {
        List<ContentEntity> oldList = instance.loadAllNote();//获取数据库中的所有数据
        System.out.println(oldList.size() + "-------------数据库中的数据");


        if (oldList.size() > 0) {
            for (int i = 0; i < oldList.size(); i++) {
                for (int j = 0; j < newList.size(); j++) {
                    if (oldList.get(i).getTableTypeId().equals(newList.get(j).getTableTypeId())) {//如果本地数据库包括这个tabletypeID
                        //判断status
                        if (Integer.parseInt(newList.get(j).getStatus()) == 2) {//服务器的此条数据状态为2，从本地删除此条数据
                            instance.deleteNote(oldList.get(i));
                        } else {//服务器的此条数据状态为1,不管跳出循环
                            return;
                        }
                    } else {
                        if (Integer.parseInt(newList.get(j).getStatus()) == 2) {//服务器的此条数据状态为2，从本地删除此条数据
                            return;
                        } else {//服务器的此条数据状态为1,不管跳出循环
                            //return;
                            instance.deleteNote(oldList.get(i));
                        }
                        //本地数据库不包括这个tabletypeid，添加到本地数据库
                        // instance.saveNote(newList.get(j));

                    }
                }
            }

        } else {
            //如果本地没有数据库，将从网络获取的数据添加到数据库
            for (int j = 0; j < newList.size(); j++) {
                if (Integer.parseInt(newList.get(j).getStatus()) == 2) {
                    newList.remove(newList.get(j));
                }

            }

            instance.saveNoteLists(newList);
            System.out.println("已将服务器获取的数据添加到本地数据库" + oldList.size());

        }

    }
}

http://download.csdn.net/download/qq_23363425/9618892 完整项目地址在这里，如有不正，欢迎指出