【Android】GreenDao数据库的使用方式

需求

使用GreenDao数据库进行数据的存储。
介绍

GreenDao 是一个轻量级的对象关系映射（ORM）库，用于简化 Android 应用中的数据库操作。它提供了以下主要功能：
简化数据库操作：通过注解界说实体类，GreenDao 自动生成 DAO（数据访问对象）类，简化了数据库的增、删、改、查操作。
高性能：GreenDao 设计目标之一是高效地执行数据库操作，尤其在处置惩罚大量数据时体现出色。
自动生成代码：通过编译时生成代码，减少了手动编写 SQL 和数据处置惩罚逻辑的需要。
变乱支持：支持数据库变乱，确保数据操作的原子性和同等性。
机动性：可以通过自界说查询和批量操作，满意复杂的数据处置惩罚需求。
小巧：库体积小，得当需要轻量级 ORM 的应用。
集成

在 build.gradle 文件中添加 GreenDao 依赖：

1. implementation 'org.greenrobot:greendao:3.3.0'

复制代码

设置 build.gradle 以生成 DAO 类。添加插件和设置：

1. apply plugin: 'org.greenrobot.greendao'
3. greendao {
4.     schemaVersion 1 //定义数据库的版本号，用于处理数据库升级。
5.     daoPackage 'com.example.dao' //指定生成的 DAO 类包名。
6.     targetGenDir 'src/main/java' //指定生成的实体类包名。
7. }

复制代码

使用

创建实体类：
使用 GreenDao 提供的注解界说实体类。举例：

1. @Entity
2. public class UpdateBean{
3.      @Id(autoincrement = true)
4.     private Long id;
5.     private String name;
7.     // getters and setters
8. }

复制代码

创建实体类之后，使用Build重新构建一下项目，然后会自动生成相关文件
【DaoMaster】【DaoSession】【UpdateBeanDao】
创建一个帮助类 【UpdateOpenHelper】

1. public class UpdateOpenHelper extends DaoMaster.OpenHelper {
3.     public UpdateOpenHelper(Context context, String name) {
4.         super(context, name);
5.     }
7.     public UpdateOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
8.         super(context, name, factory);
9.     }
11.     @Override
12.     public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
13.         DaoMaster.dropAllTables(wrap(db), true);
14.     }
15.    
16.     @Override
17.     public void onUpgrade(Database db, int oldVersion, int newVersion) {
18.         super.onUpgrade(db, oldVersion, newVersion);
19.     }
20. }

复制代码

创建一个管理类【UpdateManager 】

1. public class UpdateManager {
3.     private Context mContext;
4.     private static UpdateManager manager = new UpdateManager();
5.     private static ConcurrentHashMap<String, DaoMaster> masterMap = new ConcurrentHashMap<>();
6.     private static ConcurrentHashMap<String, DaoSession> daoSessionMap = new ConcurrentHashMap<>();
7.     private static ConcurrentHashMap<String, UpdateOpenHelper> helperMap = new ConcurrentHashMap<>();
9.     public static UpdateManager getInstance() {
10.         return manager;
11.     }
13.     public void init(Context context) {
14.         this.mContext = context;
15.     }
17.     private DaoMaster getDaoMaster(String dbName) {
18.         if (!masterMap.containsKey(dbName)) {
19.             UpdateOpenHelper openHelper = helperMap.get(dbName);
20.             if (openHelper == null) {
21.                 UGDaoContext daoContext = new UGDaoContext(mContext);
22.                 openHelper = new UpdateOpenHelper(daoContext, dbName, null);
23.                 helperMap.put(dbName, openHelper);
24.             }
25.             DaoMaster master;
26.             try {
27.                 master = new DaoMaster(openHelper.getWritableDatabase());
28.                 masterMap.put(dbName, master);
29.             } catch (Exception e) {
30.                 e.printStackTrace();
31.             }
32.         }
33.         return masterMap.get(dbName);
34.     }
37.     public DaoSession getDaoSession(String dbName) {
38.         if (!daoSessionMap.containsKey(dbName)) {
39.             DaoMaster master = getDaoMaster(dbName);
40.             if (master != null) {
41.                 DaoSession session = master.newSession();
42.                 daoSessionMap.put(dbName, session);
43.             }
44.         }
45.         return daoSessionMap.get(dbName);
46.     }
48.     /**
49.      * 关闭指定数据库连接
50.      *
51.      * @param dbName 数据库名字
52.      */
53.     public void closeConnection(String dbName) {
54.         DaoSession session = daoSessionMap.get(dbName);
55.         if (session != null) {
56.             session.clear();
57.             daoSessionMap.remove(dbName);
58.         }
59.         DaoMaster master = masterMap.get(dbName);
60.         if (master != null) {
61.             master = null;
62.             masterMap.remove(dbName);
63.         }
64.         UpdateOpenHelper helper = helperMap.get(dbName);
65.         if (helper != null) {
66.             helper.close();
67.             helperMap.remove(dbName);
68.         }
69.     }
71.     /**
72.      * 关闭所有数据库连接
73.      */
74.     public void closeAllConnection() {
75.         // 关闭所有DaoSessions
76.         synchronized (this) {
77.             for (String dbName : daoSessionMap.keySet()) {
78.                 closeConnection(dbName); // 关闭每一个连接
79.             }
80.             // 额外步骤：清理所有映射
81.             daoSessionMap.clear();
82.             masterMap.clear();
83.             helperMap.clear();
84.         }
85.     }
87. }

复制代码

还有需要修改数据库的文件的存储路径，GreenDao数据库默认的存储路径是在应用内部私有存储，以是假如删除了应用之后，数据文件也会被删除，同时也不利于外部查找数据库文件。
创建【UGDaoContext】修改数据库文件地点

1. public class UGDaoContext extends ContextWrapper {
3.     public UGDaoContext(Context base) {
4.         super(base);
5.     }
7.     @Override
8.     public File getDatabasePath(String name) {
9.         String dbDir;
10.         boolean isExistSDCar = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
11.         if (isExistSDCar) {
12.             dbDir = Environment.getExternalStorageDirectory().getAbsolutePath();
13.         } else {
14.             dbDir = Environment.getDataDirectory().getAbsolutePath();
15.         }
16.         String dbDirPath = dbDir + File.separator + "app_dao" + File.separator + "data_update";
18.         Log.d("TAG", "数据库的文件夹地址：" + dbDirPath);
19.         File dbDirFile = new File(dbDirPath);
20.         if (!dbDirFile.exists()) {
21.             dbDirFile.mkdirs();
22.         }
23.         String dbNamePath = dbDirPath + File.separator + name;
24.         File dbNameFile = new File(dbNamePath);
25.         boolean isSuccess = false;
26.         if (!dbNameFile.exists()) {
27.             try {
28.                 isSuccess = dbNameFile.createNewFile();
29.             } catch (IOException e) {
30.                 e.printStackTrace();
31.             }
32.         } else {
33.             isSuccess = true;
34.         }
35.         if (isSuccess) {
36.             Log.d("TAG", "数据库的文件地址：" + dbNamePath);
37.             return dbNameFile;
38.         } else {
39.             return super.getDatabasePath(name);
40.         }
41.     }
43.     @Override
44.     public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory) {
45.         return SQLiteDatabase.openOrCreateDatabase(getDatabasePath(name), null);
46.     }
48.     @Override
49.     public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler) {
50.         return SQLiteDatabase.openOrCreateDatabase(getDatabasePath(name), null);
51.     }
52. }

复制代码

接下里再创建一个工具类实现对数据库的操作【UpdateDaoUtil】

1. public class UpdateDaoUtil {
3.     private UpdateManager manager;
5.     public UpdateDaoUtil(Context context) {
6.         manager = UpdateManager.getInstance();
7.         manager.init(context);
8.     }
10.     /**
11.      * 完成UpdateBean记录的插入
12.      */
13.     public synchronized boolean insertUpdate(UpdateBean updateBean, String dbName) {
14.         boolean flag = false;
15.         if (manager.getDaoSession(dbName).getUpdateBeanDao().insert(updateBean) != -1) {
16.             flag = true;
17.         }
18.         return flag;
19.     }
21.     /**
22.      * 完成UpdateBean记录的插入
23.      */
24.     public synchronized boolean insertUpdate(UpdateBean updateBean) {
25.         boolean flag = false;
26.         if (manager.getDaoSession(getCurrentDBName()).getUpdateBeanDao().insert(updateBean) != -1) {
27.             flag = true;
28.         }
29.         return flag;
30.     }
33.     /**
34.      * 完成UpdateBean列表记录的插入
35.      */
36.     public synchronized boolean insertUpdate(List<UpdateBean> list) {
37.         int frequency = 0;
38.         UpdateBeanDao dao = manager.getDaoSession(getCurrentDBName()).getUpdateBeanDao();
40.         for (UpdateBean updateBean : list) {
41.             if (dao.insert(updateBean) == -1) {
42.                 frequency++;
43.             }
44.         }
45.         return frequency == 0;
46.     }
49.     /**
50.      * 删除单条记录
51.      */
52.     public synchronized boolean deleteUpdateBean(UpdateBean updateBean, String dbName) {
53.         boolean flag = false;
54.         try {
55.             manager.getDaoSession(dbName).delete(updateBean);
56.             flag = true;
57.         } catch (Exception e) {
58.             e.printStackTrace();
59.         }
60.         return flag;
61.     }
63.     /**
64.      * 删除单条记录
65.      */
66.     public synchronized boolean deleteUpdateBean(UpdateBean updateBean) {
67.         boolean flag = false;
68.         try {
69.             manager.getDaoSession(getCurrentDBName()).delete(updateBean);
70.             flag = true;
71.         } catch (Exception e) {
72.             e.printStackTrace();
73.         }
74.         return flag;
75.     }
78.     /**
79.      * 删除所有记录
80.      */
81.     public synchronized boolean deleteAll(String dbname) {
82.         boolean flag = false;
83.         try {
84.             manager.getDaoSession(dbname).deleteAll(UpdateBean.class);
85.             flag = true;
86.         } catch (Exception e) {
87.             e.printStackTrace();
88.         }
89.         return flag;
90.     }
92.     /**
93.      * 删除所有记录
94.      */
95.     public synchronized boolean deleteAll() {
96.         boolean flag = false;
97.         try {
98.             manager.getDaoSession(getCurrentDBName()).deleteAll(UpdateBean.class);
99.             flag = true;
100.         } catch (Exception e) {
101.             e.printStackTrace();
102.         }
103.         return flag;
104.     }
107.     /**
108.      * 查询数据库前 number 条数据
109.      */
110.     public synchronized List<UpdateBean> queryDataNumber(int number, String dbname) {
111.         QueryBuilder<UpdateBean> queryBuilder = manager.getDaoSession(dbname).queryBuilder(UpdateBean.class);
112.         return queryBuilder.limit(number).list();
113.     }
115.     /**
116.      * 查询数据库前 number 条数据
117.      */
118.     public synchronized List<UpdateBean> queryDataNumber(int number) {
119.         QueryBuilder<UpdateBean> queryBuilder = manager.getDaoSession(getCurrentDBName()).queryBuilder(UpdateBean.class);
120.         return queryBuilder.limit(number).list();
121.     }
124.     /**
125.      * 删除数据库前 number 条数据
126.      */
127.     public synchronized void deleteDataNumber(int number, String dbname) {
128.         UpdateBeanDao dao = manager.getDaoSession(dbname).getUpdateBeanDao();
129.         List<UpdateBean> lists = dao.queryBuilder().limit(number).list();
130.         dao.deleteInTx(lists);
131.     }
133.     /**
134.      * 删除数据库前 number 条数据
135.      */
136.     public synchronized void deleteDataNumber(int number) {
137.         UpdateBeanDao dao = manager.getDaoSession(getCurrentDBName()).getUpdateBeanDao();
138.         List<UpdateBean> lists = dao.queryBuilder().limit(number).list();
139.         dao.deleteInTx(lists);
140.     }
143.     /**
144.      * 查询所有记录
145.      */
146.     public synchronized List<UpdateBean> queryAll(String dbName) {
147.         return manager.getDaoSession(dbName).loadAll(UpdateBean.class);
148.     }
151.     /**
152.      * 查询所有记录
153.      */
154.     public synchronized List<UpdateBean> queryAll() {
155.         return manager.getDaoSession(getCurrentDBName()).loadAll(UpdateBean.class);
156.     }
162.     /**
163.      * 使用指定名称的数据库,每次查询200条未上传的数据
164.      *
165.      * @param dbname 数据库表名称
166.      */
167.     public synchronized List<UpdateBean> queryListUpdate(String dbname) {
168.         QueryBuilder<UpdateBean> queryBuilder = manager.getDaoSession(dbname).queryBuilder(UpdateBean.class);
169.         return queryBuilder.where(UpdateBeanDao.Properties.IsUpdate.eq(0)).limit(200).list();
170.     }
172.     /**
173.      * 更新是否上传状态
174.      *
175.      * @param list 上传数据的ID的list
176.      */
177.     public synchronized void updateStatus(List<Long> list) {
178.         DaoSession daoSession = manager.getDaoSession(getCurrentDBName());
179.         UpdateBeanDao updateBeanDao = daoSession.getUpdateBeanDao();
180.         try {
181.             daoSession.runInTx(() -> {
182.                 for (Long id : list) {
183.                     UpdateBean bean = updateBeanDao.load(id);
184.                     if (bean != null) {
185.                         bean.setIsUpdate(1);
186.                         updateBeanDao.update(bean);
187.                     }
188.                 }
189.             });
190.         } catch (Exception e) {
191.             e.printStackTrace();
192.         }
193.     }
195.     /**
196.      * 更新是否上传状态
197.      *
198.      * @param dbName 数据库表名字
199.      * @param list   上传数据的ID的list
200.      */
201.     public synchronized void updateStatus(String dbName, List<Long> list) {
202.         DaoSession daoSession = manager.getDaoSession(dbName);
203.         UpdateBeanDao updateBeanDao = daoSession.getUpdateBeanDao();
204.         try {
205.             daoSession.runInTx(() -> {
206.                 for (Long id : list) {
207.                     UpdateBean bean = updateBeanDao.load(id);
208.                     if (bean != null) {
209.                         bean.setIsUpdate(1);
210.                         updateBeanDao.update(bean);
211.                     }
212.                 }
213.             });
214.         } catch (Exception e) {
215.             e.printStackTrace();
216.         }
217.     }
220.     /**
221.      * 使用queryBuilder进行查询未上传的数据
222.      */
223.     public synchronized List<UpdateBean> queryItemByQueryBuilder(int isUpdate) {
224.         QueryBuilder<UpdateBean> queryBuilder = manager.getDaoSession(getCurrentDBName()).queryBuilder(UpdateBean.class);
225.         return queryBuilder.where(UpdateBeanDao.Properties.IsUpdate.eq(isUpdate)).limit(100).list();
226.     }
231.     /**
232.      * 关闭当前日期资源
233.      */
234.     public synchronized void close() {
235.         manager.closeConnection(getCurrentDBName());
236.     }
238.     /**
239.      * 关闭特定名字的数据资源
240.      */
241.     public synchronized void close(String dbName) {
242.         manager.closeConnection(dbName);
243.     }
245.     /**
246.      * 关闭所有连接
247.      */
248.     public synchronized void closeAll() {
249.         manager.closeAllConnection();
250.     }
252.     /**
253.      * 数据表的名称是当天的日期
254.      *
255.      * @return 当天日期
256.      */
257.     private static String getCurrentDateFormatted() {
258.         long currentTimeMillis = System.currentTimeMillis();
259.         Date date = new Date(currentTimeMillis);
260.         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd", Locale.getDefault());
261.         return sdf.format(date);
262.     }
264.     /**
265.      * 获取当天数据库表的名称
266.      */
267.     private static String getCurrentDBName() {
268.         return getCurrentDateFormatted() + "_db";
269.     }
271.     /**
272.      * 组装数据库名字
273.      *
274.      * @param dateTime 日期时间 例如 20240814
275.      */
276.     public static String setDBName(String dateTime) {
277.         return dateTime + "_db";
278.     }
279. }

复制代码

这样根本上一个数据库就创建了，剩下就是如何使用了。

1. UpdateDaoUtil updateDaoUtil;

复制代码

1. updateDaoUtil = new UpdateDaoUtil(this);

复制代码

1.    if (updateDaoUtil != null) {
2.                     Log.i("TAG", "将List数据存入本地数据库,存入条数 " + updateBeanList.size());
3.                     List<UpdateBean> list = new ArrayList<>(updateBeanList);
4.                     boolean update = updateDaoUtil.insertUpdate(list);
5.                     if (update) {
6.                         Log.i("TAG", "数据存入数据库正常");
7.                   
8.                     }
9.                 }

复制代码

记得烧毁

1.     @Override
2.     protected void onDestroy() {
3.         super.onDestroy();
4.         if (updateDaoUtil != null) {
5.             updateDaoUtil.closeAll();
6.         }
7.     }

复制代码

GreenDao数据库的根本使用方式就是这样了。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。