greenDao3的基本使用

最新推荐文章于 2025-08-01 16:01:03 发布
最新推荐文章于 2025-08-01 16:01:03 发布
阅读量1.8k 收藏 5
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 第三方框架的学习 文章标签： GreenDao
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_25412055/article/details/53123315
本文详细介绍GreenDao数据库操作框架的配置及使用方法，包括核心类解释、配置步骤、基本的增删改查操作，并提供了封装好的操作类实例。

greenDao是一个开源的AndroidORM对象关系映射型数据库操作框架，它的使用效率要高于其他ORM型数据库框架。

greenDao官网：http://greenrobot.org/greendao/

greenDao GitHub地址：https://github.com/greenrobot/greenDAO


greenDao核心类：

DaoMaster:
DaoMaster保存了数据库对象和管理DAO类的classes，其提供了一些静态方法创建和删除表，内部类OpenHelper和DevOpenHelper 实现了SQLiteOpenHelper并创建数据库的框架。

DaoSession：
管理所有可用的DAO对象，可以通过getter方法获得。DaoSession还提供了一些通用的持久性方法比如插入、加载、更新,刷新和删除实体。

DAOs:
数据访问对象，每一个实体类都有对应的greenDAO对象。

Entities：
实体类对象


其中，在greenDao中，Dao是由Entitie 编译后自动生成的。


使用配置：

在app的build.gradle中添加 

apply plugin: 'org.greenrobot.greendao'

greendao {
    schemaVersion 2 //数据库版本
    daoPackage 'com.example.entity.gen'//dao自动生成的目录
    targetGenDir 'src/main/java'//dao所在文件
}

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.greenrobot:greendao-gradle-plugin:3.1.0'
    }
}

dependencies {
    compile 'org.greenrobot:greendao-generator:3.1.0'
    compile 'org.greenrobot:greendao:3.1.0'
}

经过上面的配置，GreenDao就配置完成了。

基本使用：

greenDao3采用注解的方式对Entity配置，一个数据表对应一个Entity。
greenDao对数据库进行操作时需要用到DaoMaster和DaoSession，建议把这个两个对象的获取方法写到Application中，可以保证其单例调用。 

/**
 * 取得DaoMaster
 *
 * @param context
 * @return
 */
public static DaoMaster getDaoMaster(Context context) {
   if (daoMaster == null) {
      DaoMaster.OpenHelper helper = new DaoMaster.DevOpenHelper(context,DatabasePath, null);
      daoMaster = new DaoMaster(helper.getWritableDatabase());
   }
   return daoMaster;
}

/**
 * 取得DaoSession
 *
 * @param context
 * @return
 */
public static DaoSession getDaoSession(Context context) {
   if (daoSession == null) {
      if (daoMaster == null) {
         daoMaster = getDaoMaster(context);
      }
      daoSession = daoMaster.newSession();
   }
   return daoSession;
}

例如下面有个表：


我们可以新建一个Entity存入对应字段，然后make project就可以自动生成dao文件： 
@Entity(nameInDb = "FoowwReminders", createInDb = false)
public class FoowwRemindersEntity implements Serializable {

   private static final long serialVersionUID = 8675420969232321045L;

   @Property(nameInDb = "PKFoowwReminder")
   @Convert(converter = UUID2BytesConverter.class, columnType = byte[].class)
   public UUID PKFoowwReminder;

   @Property(nameInDb = "FoowwReminderType")
   public int FoowwReminderType;

   @Property(nameInDb = "PKObject")
   @Convert(converter = UUID2BytesConverter.class, columnType = byte[].class)
   public UUID PKObject;

   @Property(nameInDb = "FoowwReminderContent")
   public String FoowwReminderContent;

   @Property(nameInDb = "FoowwReminderStartDate")
   public String FoowwReminderStartDate;

   @Property(nameInDb = "FoowwReminderEndDate")
   public String FoowwReminderEndDate;

   @Property(nameInDb = "PKCreator")
   @Convert(converter = UUID2BytesConverter.class, columnType = byte[].class)
   public UUID PKCreator;

   @Property(nameInDb = "CreateTime")
   public String CreateTime;

   @Property(nameInDb = "AdvanceTime")
   public int AdvanceTime;

   @Property(nameInDb = "UpdateTime")
   public String UpdateTime;

   @Property(nameInDb = "DeleteStatus")
   public int DeleteStatus;
}

greenDao3中，用注解来对字段进行设定。具体
greenDao中对数据库操作都要使用数据表对应的dao进行操作。

基本增删改查： 

FoowwRemindersEntity reminder = new FoowwRemindersEntity();
String createTime = Utility.GetTimeNow();
reminder.CreateTime = createTime;
reminder.AdvanceTime = getAdvanceMin(tvAdvanceTime.getText().toString());
reminder.DeleteStatus = 0;
reminder.FoowwReminderContent = etReminder.getText().toString().trim();
reminder.FoowwReminderEndDate = reminderEndTime;
reminder.FoowwReminderStartDate = reminderStartTime;
UUID pkReminder = UUID.randomUUID();
reminder.PKFoowwReminder = pkReminder;
reminder.PKCreator = App.PKUser;
reminder.PKObject = null;
reminder.UpdateTime = createTime;
reminder.FoowwReminderType = 0;
reminder.PushStatus = 0;
//插入
App.getDaoSession(context).insert(reminder);
//删除,需要设置主键
App.getDaoSession(context).delete(reminder);
//修改,需要设置主键
App.getDaoSession(context).update(reminder);
//查询一
QueryBuilder db = reminder.queryBuilder();
List<FoowwRemindersEntity> list = db.where(FoowwRemindersEntityDao.Properties.HouseType.eq(1)).list();
//查询二
List<FoowwRemindersEntity> list = (List<FoowwRemindersEntity>)App.getDaoSession(context).getDao(FoowwRemindersEntity.class).queryRaw("where houseType=1");
上面是最基本的几个使用方法，具体的一些api、注解等可以看这篇博客： GreenDao3 api、注解说明

下面是我封装的一些操作方法：
Application的继承类App: 
/**
	 * 取得DaoMaster
	 *
	 * @param context
	 * @return
	 */
	public static DaoMaster getDaoMaster(Context context) {
		if (daoMaster == null) {
			DaoMaster.OpenHelper helper = new DaoMaster.DevOpenHelper(context,DatabasePath, null);
			daoMaster = new DaoMaster(helper.getWritableDatabase());
		}
		return daoMaster;
	}

	/**
	 * 取得DaoSession
	 *
	 * @param context
	 * @return
	 */
	public static DaoSession getDaoSession(Context context) {
		if (daoSession == null) {
			if (daoMaster == null) {
				daoMaster = getDaoMaster(context);
			}
			daoSession = daoMaster.newSession();
		}
		return daoSession;
	}
ISQLiteOperate操作数据库的接口: 
public interface ISQLiteOperate {

	boolean execSQL(String sql);

	boolean execSQLList(List<String> sqlList);

	boolean execSQLs(List<String[]> sqlList);

	boolean execSQLIgnoreError(List<String> sqlList);

	Cursor query(String sql);

	Cursor query(String sql, String[] params);

	void close();

	<T> void insert(T entity);

	<T> void insertInTx(Class<T> entityClass,T... entities);

	<T> void insertOrReplace(T entity);

	<T> void delete(T entity);

	<T> void deleteInTx(Class<T> entityClass,T... entities);

	<T> void update(T entity);

	<T> void updateInTx(Class<T> entityClass,T... entities);

	void runInTx(Runnable runnable);

	<T> QueryBuilder<T> queryBuilder(Class<T> entityClass);

	<T> List<T> queryRaw(Class<T> entityClass, String conditions);

	DaoSession getDaoSession();
}
SQLiteDataProxyForGreenDao具体实现类： 
public class SQLiteDataProxyForGreenDao implements ISQLiteOperate{

	private static DaoMaster mDaoMaster;
	private static DaoSession mDaoSession;
	private static SQLiteDataProxyForGreenDao proxy;
	Cursor cursor;

	public static SQLiteDataProxyForGreenDao getSQLiteProxy(Context context) {
		if (proxy == null) {
			synchronized (SQLiteDataProxyForGreenDao.class) {
				if (proxy == null) {
					proxy = new SQLiteDataProxyForGreenDao();
					mDaoMaster = App.getDaoMaster(context);
					mDaoSession = App.getDaoSession(context);
				}
			}
		}
		return proxy;
	}

	@Override
	public boolean execSQL(String sql) {
		boolean result = true;
		try {
			mDaoMaster.getDatabase().execSQL(sql);
		} catch (Exception e) {
			Log.e("SQLERROR", "execSQL：" + e.getMessage() + sql);
			result = false;
		}
		return result;
	}

	@Override
	public boolean execSQLList(List<String> sqlList) {
		boolean result = true;
		String currentSqlString = "";
		try {
			mDaoMaster.getDatabase().beginTransaction();
			for (String sql : sqlList) {
				currentSqlString = sql;
				mDaoMaster.getDatabase().execSQL(sql);
			}
			mDaoMaster.getDatabase().setTransactionSuccessful();
			result = true;
		} catch (Exception e) {
			result = false;
			Log.e("SQLERROR", "execSQLList: " + e.getMessage() + currentSqlString);
		} finally {
			mDaoMaster.getDatabase().endTransaction();
		}
		return result;
	}

	@Override
	public boolean execSQLs(final List<String[]> sqlList) {
		boolean result = true;
		String currentSql = "";
		Cursor curCount;
		try {
			mDaoMaster.getDatabase().beginTransaction();
			for (String[] arr : sqlList) {
				currentSql = arr[0];
				curCount = mDaoMaster.getDatabase().rawQuery(arr[0], null);
				curCount.moveToFirst();
				int count = curCount.getInt(0);
				curCount.close();
				if (count == 0) {
					if (arr[1] != null && arr[1].length() > 0) {
						currentSql = arr[1];
						mDaoMaster.getDatabase().execSQL(arr[1]);
					}
				} else {
					if (arr.length > 2 && arr[2] != null && arr[2].length() > 0) {
						currentSql = arr[2];
						mDaoMaster.getDatabase().execSQL(arr[2]);
					}
				}
			}
			mDaoMaster.getDatabase().setTransactionSuccessful();
			result = true;
		} catch (Exception e) {
			Log.e("SQLERROR", "execSQLs: " + currentSql + e.getMessage());
			result = false;
		} finally {
			mDaoMaster.getDatabase().endTransaction();
			curCount.closed();
		}
		return result;
	}

	@Override
	public boolean execSQLIgnoreError(List<String> sqlList) {
		mDaoMaster.getDatabase().beginTransaction();
		for (String sql : sqlList) {
			try {
				mDaoMaster.getDatabase().execSQL(sql);
			} catch (Exception e) {
				Log.e("SQLERROR", "execSQLIgnoreError: " + sql + e.getMessage());
			}
//			mDaoMaster.getDatabase().execSQL(sql);
		}
		mDaoMaster.getDatabase().setTransactionSuccessful();
		mDaoMaster.getDatabase().endTransaction();
		return false;
	}

	@Override
	public Cursor query(String sql) {
		return query(sql,null);
	}

	@Override
	public Cursor query(String sql, String[] params) {
		cursor = mDaoMaster.getDatabase().rawQuery(sql, params);
		return cursor;
	}

	@Override
	public void close() {
		if(cursor != null){
			cursor.closed();
		}
	}

	@Override
	public <T> void insert(T entity){
		mDaoSession.insert(entity);
	}

	@Override
	public <T> void insertInTx(Class<T> entityClass,T... entities) {
		//TODO
		//mDaoSession.getDao(entityClass).insert(entities);
	}

	@Override
	public void runInTx(Runnable runnable) {
		mDaoSession.runInTx(runnable);
	}

	@Override
	public <T> void insertOrReplace(T entity) {
		mDaoSession.insertOrReplace(entity);
	}

	@Override
	public <T> void delete(T entity) {
		mDaoSession.delete(entity);
	}

	@Override
	public <T> void deleteInTx(Class<T> entityClass,T... entities) {
	//TODO
	}

	@Override
	public <T> void update(T entity) {
		mDaoSession.update(entity);
	}

	@Override
	public <T> void updateInTx(Class<T> entityClass,T... entities) {
	//TODO
	}

	@Override
	public <T> QueryBuilder<T> queryBuilder(Class<T> entityClass) {
		return mDaoSession.queryBuilder(entityClass);
	}

	@Override
	public  <T> List<T> queryRaw(Class<T> entityClass, String conditions) {
		List<T> list = (List<T>) mDaoSession.getDao(entityClass).queryRaw(conditions);
		return list;
	}

	@Override
	public DaoSession getDaoSession() {
		return mDaoSession;
	}

}
DBManager实际调用的类：

public class DBManager {
	private static final int BUFFERSIZE = 8192;
	private Context context;
	private ISQLiteOperate sqLiteOperate;

	public DBManager(Context context){
		this.context = context;
		sqLiteOperate = SQLiteDataProxyForGreenDao.getSQLiteProxy(context);
	}

	public void asyncExecSQL(final String sql){
		new Thread(new Runnable() {
			@Override
			public void run() {
				sqLiteOperate.execSQL(sql);
			}
		}).start();
	}

	public void asyncExecSQLList(final List<String> sqlList){
		new Thread(new Runnable() {
			@Override
			public void run() {
				sqLiteOperate.execSQLList(sqlList);
			}
		}).start();
	}

	public void asyncExecSQLs(final List<String[]> sqlList){
		new Thread(new Runnable() {
			@Override
			public void run() {
				sqLiteOperate.execSQLs(sqlList);
			}
		}).start();
	}

	public void asyncExecSQLIgnoreError(final List<String> sqlList){
		new Thread(new Runnable() {
			@Override
			public void run() {
				sqLiteOperate.execSQLIgnoreError(sqlList);
			}
		}).start();
	}

	public boolean execSQL(String sql){
		return sqLiteOperate.execSQL(sql);
	}

	public boolean execSQLList(List<String> sqlList){
		return sqLiteOperate.execSQLList(sqlList);
	}

	public boolean execSQLs(List<String[]> sqlList){
		return sqLiteOperate.execSQLs(sqlList);
	}

	public boolean execSQLIgnoreError(List<String> sqlList){
		return sqLiteOperate.execSQLIgnoreError(sqlList);
	}

	/**
	 * 每调用一次都需要手动close一次
	 * @param sql
	 * @return
	 */
	public Cursor query(String sql){
		return sqLiteOperate.query(sql);
	}

	/**
	 * 每调用一次都需要手动close一次
	 * @param sql
	 * @param params
	 * @return
	 */
	public Cursor query(String sql, String[] params){
		return sqLiteOperate.query(sql, params);
	}

	public void close(){
		sqLiteOperate.close();
	}

	public <T> void insert(T entity){
		sqLiteOperate.insert(entity);
	}

	public <T> void insertInTx(Class<T> entityClass,T... entities) {
		//TODO
		//mDaoSession.getDao(entityClass).insert(entities);
	}

	public void runInTx(Runnable runnable) {
		sqLiteOperate.runInTx(runnable);
	}

	public <T> void insertOrReplace(T entity) {
		sqLiteOperate.insertOrReplace(entity);
	}

	public <T> void delete(T entity) {
		sqLiteOperate.delete(entity);
	}

	public <T> void deleteInTx(Class<T> entityClass,T... entities) {
		//TODO
	}

	public <T> void update(T entity) {
		sqLiteOperate.update(entity);
	}

	public <T> void updateInTx(Class<T> entityClass,T... entities) {
		//TODO
	}

	public <T> QueryBuilder<T> queryBuilder(Class<T> entityClass){
		return sqLiteOperate.queryBuilder(entityClass);
	}

	/**
	 * 相当于Select * from "entityClass" + "....conditions...."
	 * @param entityClass
	 * @param conditions
	 * @param <T>
	 * @return
	 */
	public  <T> List<T> queryRaw(Class<T> entityClass,String conditions) {
		return sqLiteOperate.queryRaw(entityClass,conditions);
	}

	public DaoSession getDaoSession() {
		return sqLiteOperate.getDaoSession();
	}

	public static boolean InitializeDatabase(Context context) {
		try {
			File oldDbFile = new File(App.DatabasePath);
			if (oldDbFile.exists()) {
				return true;
			}
			InputStream is = context.getResources().openRawResource(R.raw.foowwlite);
			FileOutputStream fos = new FileOutputStream(App.DatabasePath);
			byte[] buffer = new byte[BUFFERSIZE];
			while (is.read(buffer) > 0) {
				fos.write(buffer);
			}
			fos.close();
			is.close();
			return true;
		} catch (FileNotFoundException e) {
			return false;

		} catch (IOException e) {
			return false;
		}
	}

	public static boolean UpdateDatabase(Context context) {
		try {
			File oldDbFile = new File(App.DatabasePath);
			if (oldDbFile.exists()){
				oldDbFile.delete();
			}
			InputStream is = context.getResources().openRawResource(R.raw.foowwlite);
			FileOutputStream fos = new FileOutputStream(App.DatabasePath);
			byte[] buffer = new byte[BUFFERSIZE];
			while (is.read(buffer) > 0) {
				fos.write(buffer);
			}
			fos.close();
			is.close();
			return true;
		} catch (FileNotFoundException e) {
			return false;
		} catch (IOException e) {
			return false;
		}
	}
}








                

        

    

    
  



    



                



	

		

			

				
					
Android ORM 框架之 greenDAO

				
			

			

				

					是阿超
				

				

					01-25
					
					2831
					
				

			

		

		

			
				
Android ORM 框架之 greenDAO

			
		

	



                

            
              



	

		

			

				
					
一篇好文之Android数据库 GreenDao的使用指南(源码+案列)

					
热门推荐

				
			

			

				

					aserbao的博客
				

				

					10-23
					
					5万+
					
				

			

		

		

			
				
之前在开发过程中，数据库基本上会使用Litepal和SQlite自己写，最近换新环境，公司原先使用的数据库就是GreenDao，在各种情况的作用下，准备了解下GreenDao，顺便写一篇文章记录下GreenDao的基本使用！大家在使用GreenDao的时候遇到什么问题，欢迎在文章底部或者我的公众号aserbao给我留言！


本文主要从如下几个方面进行讲解：GreenDao的优缺点 1. Gree...

			
		

	



              


  
              

                


	

		

			

				
					
GreenDao3.2的基本使用方法

				
			

			

				

					Tongseng‘s Blog
				

				

					03-21
					
					736
					
				

			

		

		

			
				
前言   GreenDao是一款操作数据库的神器，经过了2.0版本的升级后，已经被广泛的开发者使用。确实是很好用，入门简单，可以剩去了数据库的建表操作和数据库SQL的编写，博主用了一次之后爱不释手，和以前的数据库操作一大堆的代码将它缩成了一句话，舒服.   GreenDao3.2的简介   认识GreenDao之前必须知道ORM（Object Relation Mapping对象关系映射），其表现...

			
		

	





	

		

			

				
					
Android ORM框架 GreenDao 的使用详解

				
			

			

				

					weixin_38478780的博客
				

				

					10-23
					
					1069
					
				

			

		

		

			
				
一、前言
关于 Android 中常用的数据存储方式我们前面已经讲了 Sp 存储  和 文件存储，但是对于数据量比较大，并且结构复杂的数据我们想要存储只能通过数据库进行处理，Android 中提供了一个 SQLite 数据库，但是使用起来比较繁琐和复杂，所以 Android 又推出了 Room 持久性库，Room 持久性库在 SQLite 的基础上提供了一个抽象层，让用户能够在充分利用 SQLite 的强大功能的同时，获享更强健的数据库访问机制。但是我们今天不讲 Room 这个组件（以后讲 Jetpack 

			
		

	



		

			
		



	

		

			

				
					
Android中Greendao的使用(AI+参考他人文章)

					
最新发布

				
			

			

				

					weixin_45367987的博客
				

				

					08-01
					
					1074
					
				

			

		

		

			
				
GreenDAO是一个开源的Android ORM(“对象/关系映射”)，通过ORM（称为“对象/关系映射”）DaoMaster：Dao中的管理者。它保存了sqlitedatebase对象以及操作DAO classes（注意：不是对象）。其提供了一些创建和删除table的静态方法，其内部类OpenHelper和DevOpenHelper实现了SQLiteOpenHelper，并创建数据库的框架。DaoSession：会话层。操作具体的DAO对象（注意：是对象），比如各种getter方法。

			
		

	





	

		

			

				
					
GreenDao3使用教程

				
			

			

				

					qq_36699930的博客
				

				

					08-10
					
					1万+
					
				

			

		

		

			
				
官网上的介绍，greenDAO 是一个将对象映射到 SQLite 数据库中的轻量且快速的 ORM 解决方案。

GreenDao特点


  性能最大化，可能是Android平台上最快的ORM框架 
  易于使用的API 
  最小的内存开销 
  依赖体积小 
  支持数据库加密 
  强大的社区支持


GreenDao配置

buildscript {

    repositories {...

			
		

	





	

		

			

				
					
GreenDAO3.0具体使用

				
			

			

				

					u014748504的博客
				

				

					10-23
					
					397
					
				

			

		

		

			
				
随着移动端的业务量的增大和用户体验的提高，SQLite的需求很明显了，大大小小的项目几乎成了必备，用我们项目经理的话来说：
1、不用管他什么数据，为了体验，先缓存一下！
2、什么？网络不好导致的？看什么，缓存啊！！！
真不知道他是在哪里听到的这个词，唉！
在他看来，缓存是如此简单的一件事情，当然，缓存其实并不难，就是有点麻烦而已！
之前我一直是用Realm，目前Realm被人称为移动端的新一代王者...

			
		

	





	

		

			

				
					
GreenDao的基本使用

				
			

			

				

					03-30
				

			

		

		

			
				
**GreenDao基本使用详解**  GreenDao是一款专门为Android平台设计的高效、轻量级的对象关系映射（ORM）框架，它允许开发者将数据模型类与SQLite数据库进行映射，从而简化了数据库操作。在Android应用开发中，使用...

			
		

	





	

		

			

				
					
GreenDao基本使用

				
			

			

				

					10-08
				

			

		

		

			
				
下面我们将深入探讨GreenDao的基本使用，包括增删改查、一对一、一对多以及多对多关系的处理。  **1. 增删改查（CRUD）**  - **创建（Create）**: 在GreenDao中，你需要定义一个实体类（Entity），这个类将对应...

			
		

	





	

		

			

				
					
GreenDao 3.0 基本使用

				
			

			

				

					u011424451的专栏
				

				

					03-22
					
					479
					
				

			

		

		

			
				
文章目录1、引入2、基本使用3、多表关联，@ToMany、@ToOne的使用3.1、1对多关系3.2、1对1关系3.3 多对多关系PS: 需要注意的问题
GreenDao是一款Android上的ORM框架（对象/关系映射），在数据库开发中能帮我们从枯燥的CRUD中节约大量的时间，这里针对GreenDao3.0以后的版本做一个简单的使用介绍。
1、引入
GreenDao Github地址
引入Gradle插件，
在根目录的build.gradle中，加入GreenDao的插件依赖地址：
    depende

			
		

	





	

		

			

				
					
GreenDao3 数据库的使用以升级时数据迁移和添加新表

				
			

			

				

					08-02
				

			

		

		

			
				
GreenDao3 数据库的使用以升级时数据迁移 在保留原数据的情况下最已有的表进行增加字段  在数据库里增加新的表

			
		

	





	

		

			

				
					
GreenDao3使用完全解析

				
			

			

				

					qq_21763489的博客
				

				

					05-27
					
					4490
					
				

			

		

		

			
				
1，gradle配置（官网样例地址https://github.com/greenrobot/greenDAO/blob/master/examples/RxDaoExample/build.gradle）
Module的gradle 里安装如下配置(官方给的配置样例)

buildscript {
    repositories {
        jcenter()
        m

			
		

	





	

		

			

				
					
转载：数据库原理丨GreenDao3.0简单使用

				
			

			

				

					一个IT人的技术成长历程。
				

				

					10-10
					
					319
					
				

			

		

		

			
				
greenDAO 优势
1、一个精简的库
2、性能最大化
3、内存开销最小化
4、易于使用的 APIs
5、对 Android 进行高度优化
Greendao3.0 最主要的三大改变：
1. 换包名
2. 实体注解
3. 加密支持的优化
GreenDao 3.0使用
GreenDao 3.0采用注解的方式来定义实体类，通过gradle插件生成相应的代码。
GreenDao3的配置
3.0相比2.0的配置较为方便，不用新建Module等一系列操作，可以直接在build.gradle里配置并新建实体用添加注解的

			
		

	





	

		

			

				
					
greendao3，图文详解

				
			

			

				

					m0_66684915的博客
				

				

					03-05
					
					1497
					
				

			

		

		

			
				
public class StudentDaoOpe {
private static final String DB_NAME = “test.db”;
private static final String PASSWPRD = “password”;
/**


添加数据至数据库



@param context


@param stu


*/
public static void insertData(Context context, Student stu) {
//        DbMa

			
		

	





	

		

			

				
					
Android数据库框架-GreenDao入门(3)，2024最新网易Android面经

				
			

			

				

					2401_84153285的博客
				

				

					04-07
					
					773
					
				

			

		

		

			
				
public class UserInfo {@Idprivate long id;@Property(nameInDb = “user_name”)private String userName;@Property(nameInDb = “phone_number”)private String phoneNumber;@Property(nameInDb = “address”)private String address;@Generated(hash = 459973421)public UserI

			
		

	





	

		

			

				
					
GreenDao3数据库加密实战指南

				
			

			

				

					weixin_33205138的博客
				

				

					06-03
					
					894
					
				

			

		

		

			
				
GreenDao3 是一个为 Android 平台设计的轻量级且性能优越的 ORM（Object-Relational Mapping）数据库解决方案。其设计初衷是为了解决在移动设备上对关系型数据库操作的便捷性以及轻量化的需求。与传统的 ORM 框架相比，GreenDao3 通过注解的方式来减少模板代码的编写，同时直接操作 SQLite 数据库，大幅度提高了数据存取的性能。其设计理念主要体现在以下几点：轻量化：GreenDao3 尽量减少资源消耗，不依赖大量外部库。易用性。

			
		

	





	

		

			

				
					
android数据库简单使用教程,Android 数据库--greenDAO 3.0 的基本使用方法

				
			

			

				

					weixin_29529047的博客
				

				

					05-29
					
					710
					
				

			

		

		

			
				
安卓开发主要使用的存储方式有三种：文件存储数据库存储网络存储一般轻量级存储，我们使用文件存储就够用了，但是一旦涉及大量存储数据时候，文件存储就显得很笨重了，这个时候就需要我们使用数据库存储了，android系统是自带 SQLite轻量级嵌入式数据库引擎，并提供了相应的调用api，但是书写复杂，大多数开发者都会选择封装后再使用，或者挑选一个开源库来使用。目前主流的的数据库有：LitePal 郭霖大神...

			
		

	





	

		

			

				
					
RxAndroid+Retrofit+GreenDao+MVP框架---通用基类封装（一）

				
			

			

				

					HL
				

				

					12-07
					
					840
					
				

			

		

		

			
				
打算分为通用的方法，基类封装；网络请求框架封装（RxAndroid+Retrofit）；查看完整框架可以到GitHub下载https://github.com/850125665/WeatherApp维护activity栈
有些需求需要一键退出应用功能，或者跳转到多个activity后，想一键返回到主activity
相关代码ActivityStack.java，注释应该还可以public clas

			
		

	





	

		

			

				
					
GreenDao的基本使用方法与代码解析

				
			

			

				

					
				

			

		

		

			
				
GreenDao是一种高效、轻量级的Android ORM解决方案，它用于将Java对象映射到SQLite数据库中。它主要用于简化本地数据库存储...掌握GreenDao的基本使用，对于开发高效、可维护的Android应用来说，是一个不可或缺的技能。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值