Android greenDAO 3.2.2简单使用

github : https://github.com/greenrobot/greenDAO

集成

// In your root build.gradle file:
buildscript {
    repositories {
        jcenter()
        mavenCentral() // add repository
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.1.1'
        classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' // add plugin
    }
}
 
// In your app projects build.gradle file:
apply plugin: 'com.android.application'
apply plugin: 'org.greenrobot.greendao' // apply plugin
 
dependencies {
    implementation 'org.greenrobot:greendao:3.2.2' // add library
}

greendao {
    //数据库版本号
    schemaVersion 1
    //设置DaoMaster、DaoSession、Dao包名，也就是要放置这些类的包的路径。
    daoPackage 'com.yechaoa.test.dao'
    //设置DaoMaster、DaoSession、Dao目录
    targetGenDir 'src/main/java'
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
 

常用注解

• @Id(autoincrement = true) 主键自增长
• @NotNull 不为空
• @OrderBy(asc desc) 排序
• @Transient 短暂的，不会持久化，表示实体类中普通的字段
• @Property 参数 字段
• @Unique 唯一约束
• @ToOne 一对一，定义到另一个实体对象的关系，应在持有目标实体对象的字段上使用该注解
• @ToMany 一对多，使用@ToMany的属性代表目标实体的List，集合里的对象都必须至少有一个属性指向拥有@ToMany的实体
• @JoinEntity 多对多，如果两个实体是多对多的关系，那么需要第三张表（表示两个实体关系的表）

常用的SQL语句条件关键词

• eq()：==
• noteq()：!=
• orderAsc：升序排序
• orderDesc: 降序排序
• gt()： >
• t()：<
• ge：>=
• le:<=
• like()：包含
• between：俩者之间
• in：在某个值内
• notIn：不在某个值内
• limit(int): 限制查询的数量
• list() 返回一个集合
• listLazy() 懒查询

新建一个实体类

@Entity
public class OrderDB {

    @Id(autoincrement = true)
    private Long id;
	
	@NotNull
    private Integer price;

    private String name;

    private String num;

	....
    
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
 

然后编译会在自定义的文件夹包名（比如上面的‘com.yechaoa.test.dao’）下生成3个文件：

• DaoMaster
• DaoSession
• OrderDBDao

bean也会生成set get方法。

编写OrderDaoManager类

单例保证唯一性，统一入口

/**
 * Created by yechaoa on 2018/10/29.
 * Describe :
 */
public class OrderDaoManager {

    private static final String DB_NAME = "order_db";
    private Context context;
    @SuppressLint("StaticFieldLeak")
    private volatile static OrderDaoManager manager = new OrderDaoManager();
    private static DaoMaster sDaoMaster;
    @SuppressLint("StaticFieldLeak")
    private static DaoMaster.DevOpenHelper sHelper;
    private static DaoSession sDaoSession;

    /**
     * 单例模式获得操作数据库对象
     */
    public static OrderDaoManager getInstance() {
        return manager;
    }

    public void init(Context context) {
        this.context = context;
    }

    /**
     * 判断是否有存在数据库，如果没有则创建
     */
    private DaoMaster getDaoMaster() {
        if (sDaoMaster == null) {
            DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(context, DB_NAME, null);
            sDaoMaster = new DaoMaster(helper.getWritableDatabase());
        }
        return sDaoMaster;
    }

    /**
     * 完成对数据库的添加、删除、修改、查询操作
     */
    public DaoSession getDaoSession() {
        if (sDaoSession == null) {
            if (sDaoMaster == null) {
                sDaoMaster = getDaoMaster();
            }
            sDaoSession = sDaoMaster.newSession();
        }
        return sDaoSession;
    }

    /**
     * 关闭所有的操作，数据库开启后，使用完毕要关闭
     */
    public void closeConnection() {
        closeHelper();
        closeDaoSession();
    }

    private void closeHelper() {
        if (sHelper != null) {
            sHelper.close();
            sHelper = null;
        }
    }

    private void closeDaoSession() {
        if (sDaoSession != null) {
            sDaoSession.clear();
            sDaoSession = null;
        }
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
 

编写OrderDBHelper类，处理增删改查

/**
 * Created by yechao on 2018/10/29.
 * Describe :
 */
public class OrderDBHelper {

    private OrderDaoManager mManager;

    public OrderDBHelper(Context context) {
        mManager = OrderDaoManager.getInstance();
        mManager.init(context);
    }

    /**
     * 插入单条数据，如果表未创建，先创建OrderDB表
     */
    public boolean insertOrderDB(OrderDB o) {
        boolean flag;
        flag = mManager.getDaoSession().getOrderDBDao().insert(o) != -1;
        return flag;
    }

    /**
     * 插入多条数据，在子线程操作
     */
    public boolean insertMultiOrderDB(final List<OrderDB> oList) {
        boolean flag = false;
        try {
            mManager.getDaoSession().runInTx(new Runnable() {
                @Override
                public void run() {
                    for (OrderDB o : oList) {
                        mManager.getDaoSession().insertOrReplace(o);
                    }
                }
            });
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 修改一条数据
     */
    public boolean updateOrderDB(OrderDB o) {
        boolean flag = false;
        try {
            mManager.getDaoSession().update(o);
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 删除单条记录
     */
    public boolean deleteOrderDB(OrderDB o) {
        boolean flag = false;
        try {
            mManager.getDaoSession().delete(o);
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 删除所有记录
     */
    public boolean deleteAll() {
        boolean flag = false;
        try {
            mManager.getDaoSession().deleteAll(OrderDB.class);
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 查询所有记录
     */
    public List<OrderDB> queryAllOrderDB() {
        return mManager.getDaoSession().loadAll(OrderDB.class);
    }

    /**
     * 根据主键id查询记录
     */
    public OrderDB queryOrderDBById(long key) {
        return mManager.getDaoSession().load(OrderDB.class, key);
    }

    /**
     * 使用native sql进行查询操作
     */
    public List<OrderDB> queryOrderDBByNativeSql(String sql, String[] conditions) {
        return mManager.getDaoSession().queryRaw(OrderDB.class, sql, conditions);
    }

    /**
     * 使用queryBuilder进行查询
     */
    public List<OrderDB> queryOrderDBByQueryBuilder(long id) {
        QueryBuilder<OrderDB> queryBuilder = mManager.getDaoSession().queryBuilder(OrderDB.class);
        return queryBuilder.where(OrderDBDao.Properties.Id.eq(id)).list();
    }

    /**
     * orderAsc：升序排序  orderDesc: 降序排序
     */
    public List<OrderDB> queryOrderDBByQueryBuilder2(Integer price, String name) {
        QueryBuilder<OrderDB> queryBuilder = mManager.getDaoSession().queryBuilder(OrderDB.class);
        return queryBuilder
                .where(OrderDBDao.Properties.Price.eq(price),
                        OrderDBDao.Properties.Name.eq(name))
                .orderAsc(OrderDBDao.Properties.StatusId)
                .list();
    }

    /**
     * 模糊查找 关键词需要前后加上%
     */
    public List<OrderDB> queryOrderDBByQueryBuilderSearch(String key) {
        QueryBuilder<OrderDB> queryBuilder = mManager.getDaoSession().queryBuilder(OrderDB.class);
        return queryBuilder
                .where(OrderDBDao.Properties.Name.like("%" + key + "%"))
                .orderAsc(OrderDBDao.Properties.StatusId)
                .list();
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
74
  
75
  
76
  
77
  
78
  
79
  
80
  
81
  
82
  
83
  
84
  
85
  
86
  
87
  
88
  
89
  
90
  
91
  
92
  
93
  
94
  
95
  
96
  
97
  
98
  
99
  
100
  
101
  
102
  
103
  
104
  
105
  
106
  
107
  
108
  
109
  
110
  
111
  
112
  
113
  
114
  
115
  
116
  
117
  
118
  
119
  
120
  
121
  
122
  
123
  
124
  
125
  
126
  
127
  
128
  
129
  
130
  
131
  
132
  
133
  
134
  
135
  
136
  
137
 

使用

先初始化help对象

		mOrderDBHelper = new OrderDBHelper(PickActivity.this);

  

 

  
1
 

插入多条

		mOrderDBS = new ArrayList<>();
		mOrderDBHelper = new OrderDBHelper(this);
		for (int i = 0; i < mList.size(); i++) {
		   mOrderDBS.add(new OrderDB(null,  mDate,mList.get(i).price,,  mDate,mList.get(i).name, i, ...));
		}
		mOrderDBHelper.insertMultiOrderDB(mOrderDBS);

  

 

  
1
  
2
  
3
  
4
  
5
  
6
 

查询单条

		Long id = mOrderDBS.get(pos).getId();
		OrderDB orderDB1 = mOrderDBHelper.queryOrderDBById(id);

  

 

  
1
  
2
 

根据条件查询

		mOrderDBS = (ArrayList<OrderDB>) mOrderDBHelper.queryOrderDBByQueryBuilder2(mPrice, mName);

  

 

  
1
 

更新单条

		Long id = mOrderDBS.get(pos).getId();
		OrderDB orderDB1 = mOrderDBHelper.queryOrderDBById(id);
		orderDB1.setName("测试");
		mOrderDBHelper.updateOrderDB(orderDB1);

  

 

  
1
  
2
  
3
  
4
 

模糊查找

		mOrderDBS = (ArrayList<OrderDB>) mOrderDBHelper.queryOrderDBByQueryBuilderSearch(searchText);

  

 

  
1
 

删除所有

		mOrderDBHelper.deleteAll();

  

 

  
1
 

其他的使用起来大同小异，根据自己的业务添加

记得释放资源

		@Override
		protected void onDestroy() {
		    super.onDestroy();
		    //关闭资源
		    OrderDaoManager.getInstance().closeConnection();
		}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
 

数据库升级

• 修改版本号，即schemaVersion 1
• 修改实体类

然后编译即可。

特殊情况

自定义DBHelper，继承DaoMaster.OpenHelper

		public class DBHelper extends DaoMaster.OpenHelper {  
		    public static final String DBNAME = "lenve.db";  
		  
		    public DBHelper(Context context) {  
		        super(context, DBNAME, null);  
		    }  
		  
		    @Override  
		    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {  
		        super.onUpgrade(db, oldVersion, newVersion);  
		    }  
		} 

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
 

在onUpgrade方法中处理

然后数据库的初始化也需要重新处理

		DBHelper devOpenHelper = new DBHelper(this);  
		DaoMaster daoMaster = new DaoMaster(devOpenHelper.getWritableDb());  
		DaoSession daoSession = daoMaster.newSession();  
		userDao = daoSession.getUserDao(); 

  

 

  
1
  
2
  
3
  
4
 

主要是 增删改查 操作和一些SQL语句的应用

文章来源: blog.csdn.net，作者：yechaoa，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/yechaoa/article/details/83543013