Android GreenDao

最新推荐文章于 2024-03-28 17:11:46 发布
最新推荐文章于 2024-03-28 17:11:46 发布
阅读量1.7k 收藏 1
点赞数 1
分类专栏： android 文章标签： android sqlite
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39582021/article/details/108286691
版权

离线开发

开发工具： androidStudio ,SQLite3

使用开源库：GreenDao 3.2.2

离线已实现：

1.  增、删、改、查

2. 新增表，字段，更改字段，升级数据迁移

3. 从服务器下载数据，并更新到本地数据表，避免重复添加

4. 代码封装

集成：

1. 项目根目录添加环境

buildscript {
    ...
    dependencies {
        classpath 'com.android.tools.build:gradle:3.6.0'
        classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' // 添加 GreenDao 插件
    }
}
allprojects {
    repositories {
        google()
        jcenter()
        maven { url 'https://jitpack.io' } // 添加
    }
}

2. app 下添加依赖

// 与 application 同级
apply plugin: 'com.android.application'
apply plugin: 'org.greenrobot.greendao'

// android 节点中，rootProject.ext.publish.versionCode 文尾介绍
greendao {
  // 数据库升级视为 App 重大升级，跟随 versionCode ，方便记忆
  schemaVersion rootProject.ext.publish.versionCode
}

// dependencies 节点中
implementation 'org.greenrobot:greendao:3.2.2' // 添加

3. 对象，也就是表

@Entity(nameInDb = "Users")
public class UserBean {
    @Id(autoincrement = true)
    @Index(unique = true)//设置唯一性
    @Property(nameInDb = "F_id")
    private Long F_id;
    @Property(nameInDb = "F_byyx")
    private String F_byyx;
    @Property(nameInDb = "F_csrq")
    private String F_csrq;
    
	...
}

4. 普通的增删改查

UserBeanDao userBeanDao = DaoManager.getInstance().getDaoSession().getUserBeanDao();

// 增
userBeanDao.insert(new UserBean(100L, "王大锤", "女"));

// 删
userBeanDao.deleteByKey(100L);

// 改
UserBean bean = mUserBeanDao.load(32L);
bean.setF_csrq("改改");
userBeanDao.update(bean);

// 查
StringBuilder sb = new StringBuilder();
List<UserBean> userBeans = mUserBeanDao.loadAll();
for (UserBean userBean : userBeans) {
    sb.append("id:").append(userBean.getId())
       .append("f_id:").append(userBean.getF_id())
       .append("F_byyx:").append(userBean.getF_byyx())
       .append("F_csrq:").append(userBean.getF_csrq())
        .append("\n");
}
Log.i(TAG, "showDataList: "+sb.toString();

5. 新增表，字段，更改字段，升级时数据迁移，最后全部代码介绍

// 这里升级最好是将所有的表都写上，工具类会自动进行数据迁移
		MigrationHelper.migrate(
			db,
			StuffBeanDao.class,
			DepartmentBeanDao.class
        );

6. 从服务器下载数据，并更新到本地数据表，业务上会一次下载多张表，所以我统一放到了一个子线程中处理（真正实现过程使用的 IntentService ，其内部就是子线程，用完后，会自动销毁）

// 模拟网络数据
List<UserBean> list = new ArrayList<>();
list.add(new UserBean( 111L, "王大宝", "男"));
list.add(new UserBean( 112L, "王大宝", "男"));
list.add(new UserBean( 113L, "王大宝", "男"));
list.add(new UserBean( 114L, "王大宝", "男"));
list.add(new UserBean( 115L, "王大宝", "男"));
list.add(new UserBean( 116L, "王大宝", "男"));
list.add(new UserBean( 117L, "王大宝", "男"));

// 更新或插入操作
for (int i = 0; i < list.size(); i++) {

	UserBean bean = list.get(i);
	
	// dao.hasKey(bean) 这句话只是说这个对象中是否存在主键，因为我设置了主键所以肯定存在
	// mUserBeanDao.load(bean.getF_id()) != null ，查询看看是否存在，存在则更新，不存在则插入
	
	if (mUserBeanDao.load(bean.getF_id()) != null) {

		mUserBeanDao.update(bean);

	} else {
		mUserBeanDao.insert(bean);
	}

}

全部源码

// 常量
public interface DbConstants {

    String DB_NAME = "test.db";// 数据库名称

}

// 应用启动类
public class GreenDaoApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        initGreenDao();
    }
    /**
     * 初始化 GreenDao 数据库
     */
    private void initGreenDao() {
        DaoManager.getInstance().init(this);
        DaoManager.getInstance().getDaoMaster();
    }
}

// 数据迁移类
public final class MigrationHelper {

	private static final String TAG = "MigrationHelper";
	private static final String SQLITE_MASTER = "sqlite_master";
	private static final String SQLITE_TEMP_MASTER = "sqlite_temp_master";

	public static void migrate(SQLiteDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
		LogUtil.d(TAG,"【The Old Database Version】" + db.getVersion());
		Database database = new StandardDatabase(db);
		migrate(database, daoClasses);
	}


	public static void migrate(Database database, Class<? extends AbstractDao<?, ?>>... daoClasses) {
		LogUtil.d(TAG,"【Generate temp table】start");
		generateTempTables(database, daoClasses);
		LogUtil.d(TAG,"【Generate temp table】complete");

		LogUtil.d(TAG,"【Drop all table and recreate all table】");
		for (int i = 0; i < daoClasses.length; i++) {
			DaoConfig daoConfig = new DaoConfig(database, daoClasses[i]);
			dropTable(database, true, daoConfig);
			createTable(database, false, daoConfig);
		}

		LogUtil.d(TAG,"【Restore data】start");
		restoreData(database, daoClasses);
		LogUtil.d(TAG,"【Restore data】complete");
	}

	private static void dropTable(Database database, boolean ifExists, DaoConfig daoConfig) {
		String sql = String.format("DROP TABLE %s\"%s\"", ifExists ? "IF EXISTS " : "", daoConfig.tablename);
		database.execSQL(sql);
	}

	private static void generateTempTables(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
		for (int i = 0; i < daoClasses.length; i++) {
			String tempTableName = null;

			DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
			String tableName = daoConfig.tablename;
			if (!isTableExists(db, false, tableName)) {
				LogUtil.d(TAG,"【New Table】" + tableName);
				continue;
			}
			try {
				tempTableName = daoConfig.tablename.concat("_TEMP");
				StringBuilder dropTableStringBuilder = new StringBuilder();
				dropTableStringBuilder.append("DROP TABLE IF EXISTS ").append(tempTableName).append(";");
				LogUtil.d(TAG,"【Generate temp table】 dropTableStringBuilder:" + dropTableStringBuilder);
				db.execSQL(dropTableStringBuilder.toString());

				StringBuilder insertTableStringBuilder = new StringBuilder();
				insertTableStringBuilder.append("CREATE TEMPORARY TABLE ").append(tempTableName);
				insertTableStringBuilder.append(" AS SELECT * FROM ").append(tableName).append(";");
				LogUtil.d(TAG,"【Generate temp table】 insertTableStringBuilder:" + insertTableStringBuilder);
				db.execSQL(insertTableStringBuilder.toString());
				LogUtil.d(TAG,"【Table】" + tableName +"\n ---Columns-->" + getColumnsStr(daoConfig));
				LogUtil.d(TAG,"【Generate temp table】" + tempTableName);
			} catch (SQLException e) {
				Log.e(TAG, "【Failed to generate temp table】" + tempTableName, e);
			}
		}
	}

	private static boolean isTableExists(Database db, boolean isTemp, String tableName) {
		if (db == null || TextUtils.isEmpty(tableName)) {
			return false;
		}
		String dbName = isTemp ? SQLITE_TEMP_MASTER : SQLITE_MASTER;
		String sql = "SELECT COUNT(*) FROM " + dbName + " WHERE type = ? AND name = ?";
		Cursor cursor=null;
		int count = 0;
		try {
			cursor = db.rawQuery(sql, new String[]{"table", tableName});
			if (cursor == null || !cursor.moveToFirst()) {
				return false;
			}
			count = cursor.getInt(0);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (cursor != null)
				cursor.close();
		}
		return count > 0;
	}


	private static String getColumnsStr(DaoConfig daoConfig) {
		if (daoConfig == null) {
			return "no columns";
		}
		StringBuilder builder = new StringBuilder();
		for (int i = 0; i < daoConfig.allColumns.length; i++) {
			builder.append(daoConfig.allColumns[i]);
			builder.append(",");
		}
		if (builder.length() > 0) {
			builder.deleteCharAt(builder.length() - 1);
		}
		return builder.toString();
	}


	private static void restoreData(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
		for (int i = 0; i < daoClasses.length; i++) {
			DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
			String tableName = daoConfig.tablename;
			String tempTableName = daoConfig.tablename.concat("_TEMP");

			if (!isTableExists(db, true, tempTableName)) {
				continue;
			}

			try {
				// get all columns from tempTable, take careful to use the columns list
				List<String> columns = getColumns(db, tempTableName);
				ArrayList<String> properties = new ArrayList<>(columns.size());
				for (int j = 0; j < daoConfig.properties.length; j++) {
					String columnName = daoConfig.properties[j].columnName;
					if (columns.contains(columnName)) {
						properties.add(columnName);
					}
				}
				if (properties.size() > 0) {
					final String columnSQL = TextUtils.join(",", properties);

					StringBuilder insertTableStringBuilder = new StringBuilder();
					insertTableStringBuilder.append("INSERT INTO ").append(tableName).append(" (");
					insertTableStringBuilder.append(columnSQL);
					insertTableStringBuilder.append(") SELECT ");
					insertTableStringBuilder.append(columnSQL);
					insertTableStringBuilder.append(" FROM ").append(tempTableName).append(";");
					LogUtil.d(TAG,"【Restore data】 db sql: " + insertTableStringBuilder);
					db.execSQL(insertTableStringBuilder.toString());
					LogUtil.d(TAG,"【Restore data】 to " + tableName);
				}
				StringBuilder dropTableStringBuilder = new StringBuilder();
				dropTableStringBuilder.append("DROP TABLE ").append(tempTableName);
				db.execSQL(dropTableStringBuilder.toString());
				LogUtil.d(TAG,"【Drop temp table】" + tempTableName);
			} catch (SQLException e) {
				Log.e(TAG, "【Failed to restore data from temp table 】" + tempTableName, e);
			}
		}
	}

	private static List<String> getColumns(Database db, String tableName) {
		List<String> columns = null;
		Cursor cursor = null;
		try {
			cursor = db.rawQuery("SELECT * FROM " + tableName + " limit 0", null);
			if (null != cursor && cursor.getColumnCount() > 0) {
				columns = Arrays.asList(cursor.getColumnNames());
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (cursor != null)
				cursor.close();
			if (null == columns)
				columns = new ArrayList<>();
		}
		return columns;
	}

	public static void createTable(Database db, boolean ifNotExists, DaoConfig daoConfig) {
		String tableName = daoConfig.tablename;
		StringBuilder builder = new StringBuilder();
		builder.append("CREATE TABLE ");
		builder.append(ifNotExists ? "IF NOT EXISTS ": "");
		builder.append(tableName);
		builder.append(getColumnsSql(daoConfig));
		LogUtil.d(TAG,"【createTable】 sql:" + builder.toString());
		db.execSQL(builder.toString()); // 6: Description
	}

	private static String getColumnsSql(DaoConfig daoConfig) {
		if (daoConfig == null) {
			return "";
		}
		StringBuilder builder = new StringBuilder(" (");
		for (int i = 0; i < daoConfig.properties.length; i++) {
			builder.append(String.format("\"%s\" %s,", daoConfig.properties[i].columnName,
					getPropertyType(daoConfig.properties[i].type)));
		}
		if (daoConfig.properties.length > 0 && builder.length() > 0) {
			builder.deleteCharAt(builder.length() - 1);
		}
		builder.append("); ");
		return builder.toString();
	}

	/**
	 * 根据字段类型返回对应的数据库字段语句
	 * @param type
	 * @return
	 */
	private static String getPropertyType(Class<?> type) {
		if (type.equals(byte[].class)) {
			return "BLOB";
		} else if (type.equals(String.class)) {
			return "TEXT DEFAULT ''";
		} else if (type.equals(boolean.class) || type.equals(Boolean.class)
				|| type.equals(int.class) || type.equals(Integer.class)
				|| type.equals(long.class) || type.equals(Long.class)
				|| type.equals(Date.class) || type.equals(Byte.class)) {
			return "INTEGER DEFAULT (0)";
		} else if (type.equals(float.class) || type.equals(Float.class)
				|| type.equals(double.class) || type.equals(Double.class)){
			return "REAL DEFAULT (0)";
		}
		return "TEXT DEFAULT ''";
	}

}

// 数据库管理类，封装
public class DaoManager {

    private Context mContext;

    //创建数据库的名字
    private static final String DB_NAME = DbConstants.DB_NAME;

    //多线程中要被共享的使用volatile关键字修饰  GreenDao管理类
    private volatile static DaoManager mInstance;

    //它里边实际上是保存数据库的对象
    private static DaoMaster mDaoMaster;

    //创建数据库的工具
    private static DbOpenHelper mHelper;

    //管理gen里生成的所有的Dao对象里边带有基本的增删改查的方法
    private static DaoSession mDaoSession;


    private DaoManager() {
    }

    /**
     * 单例模式获得操作数据库对象
     *
     * @return
     */
    public static DaoManager getInstance() {
        if (mInstance == null) {
            synchronized (DaoManager.class) {
                if (mInstance == null) {
                    mInstance = new DaoManager();
                }
            }
        }
        return mInstance;
    }

    /**
     * 初始化上下文创建数据库的时候使用
     */
    public void init(Context context) {
        this.mContext = context;
    }

    /**
     * 判断是否有存在数据库，如果没有则创建
     *
     * @return
     */
    public DaoMaster getDaoMaster() {
        if (mDaoMaster == null) {
            mHelper = new DbOpenHelper(mContext,DB_NAME);
            mDaoMaster = new DaoMaster(mHelper.getWritableDatabase());
        }
        return mDaoMaster;
    }

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

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

    public void closeHelper() {
        if (mHelper != null) {
            mHelper.close();
            mHelper = null;
        }
    }

    public void closeDaoSession() {
        if (mDaoSession != null) {
            mDaoSession.clear();
            mDaoSession = null;
        }
    }
}

// 升级时需要的类

public class DbOpenHelper extends DaoMaster.OpenHelper {

	public DbOpenHelper(Context context, String name) {
		super(context, name);
	}

	@Override
	public void onCreate(Database db) {
		super.onCreate(db);
		startMigrate(db);
	}

	@Override
	public void onUpgrade(Database db, int oldVersion, int newVersion) {
		super.onUpgrade(db, oldVersion, newVersion);
		startMigrate(db);
	}

	private void startMigrate(Database db) {

		// 这里升级最好是将所有的表都写上，关键是数据库一定要更新,版本 和 app 同步，
		MigrationHelper.migrate(
				db,
				StuffBeanDao.class,
				DepartmentBeanDao.class
		);

	}

}

文章结尾：

解释：schemaVersion rootProject.ext.publish.versionCode ，就是全局配置，如果依赖库多了方便管理

步骤1：在项目根目录新建 config.gradle 文件

ext {

    android = [
            compileSdkVersion: 29,
            buildToolsVersion: "28.0.0",
            minSdkVersion    : 19,
            targetSdkVersion : 28,
            supportLibVersion: "28.0.0"
    ]

  
    publish = [
            applicationId: "com.test.test",
            versionCode  : 1,
            versionName  : "1.0"
    ]
}

步骤2：在项目根目录 build.gradle 文件顶部引入

apply from: "config.gradle"

步骤3：在 App build.gradle 文件中使用

greendao {
	// 跟随 versionCode todo 数据库升级视为 App 重大升级，直接升级 VersionCode & VersionName
	schemaVersion rootProject.ext.publish.versionCode
}

 

xiaobo-921
关注
专栏目录
AndroidGreenDAO
06-13
**Android GreenDAO** GreenDAO是一款针对Android平台的轻量级对象关系映射（ORM）库，它使得在Android应用中操作SQLite数据库变得简单而高效。GreenDAO能够将Java对象直接映射为SQLite数据库表，避免了传统的SQL...
【框架】GreenDao数据库框架
weixin_43526787的博客
06-21 1651
一、背景 Android数据库SQLite原生API SqliteOpenHelper不友好，所以出现了许多ORM框架来帮助我们处理数据库操作。所谓ORM框架，即Object-Relational Mapping，它的作用是在关系型数据库和对象之间做一个映射，这样，我们在具体的操作数据库的时候，就不需要再去和复杂的SQL语句打交道，只要像平时操作对象一样操作它就可以了。而GreenDao是基于Android的ORM框架中的佼佼者，优点如下： 性能（可能是Android上最快的ORM） 易用性（..
一篇好文之Android数据库 GreenDao的使用指南(源码+案列)
热门推荐
aserbao的博客
10-23 5万+
之前在开发过程中，数据库基本上会使用Litepal和SQlite自己写，最近换新环境，公司原先使用的数据库就是GreenDao，在各种情况的作用下，准备了解下GreenDao，顺便写一篇文章记录下GreenDao的基本使用！大家在使用GreenDao的时候遇到什么问题，欢迎在文章底部或者我的公众号aserbao给我留言！ 本文主要从如下几个方面进行讲解：GreenDao的优缺点 1. Gree...
Android greenDao
xiaowang_lj的博客
07-02 1526
greenDAO是一个开源的Android ORM(对象-关系映射)，它让SQLite数据库的开发再次变得有趣。它使开发人员免于处理低级数据库要求，同时节省了开发时间。SQLite是一个很棒的嵌入式关系数据库。尽管如此，编写SQL和解析查询结果仍然是非常繁琐且耗时的任务。通过将Java对象映射到数据库表（称为ORM，“对象/关系映射”），greenDAO使您摆脱了这些麻烦。这样，您可以使用简单的面向对象的API来存储，更新，删除和查询Java对象。 最佳性能 (可能是 Android 中最快的 ORM) ，
Android数据库GreenDao的使用完全解析
一个IT人的技术成长历程。
10-02 1739
之前在开发过程中，数据库基本上会使用Litepal或者SQlite自己写，最近换新环境，公司原先使用的数据库就是GreenDao，在各种情况的作用下，准备了解下GreenDao，顺便写一篇文章记录下GreenDao的基本使用！如果你是Android开发者，你在开发路上遇到任何问题，欢迎来我的公众号给我留言，咱们一起讨论，加入的Android开发讨论小组，一起进步！文章转载请注明出处。本文主要从如下几个方面进行讲解存储的数据库结构GreenDao的优缺点GreenDao的使用配置。
Android ORM 框架之 greenDAO
是阿超
01-25 2615
Android ORM 框架之 greenDAO
Android GreenDao 数据库框架的使用
09-09
**Android GreenDao数据库框架的深度解析** 在移动应用开发中，数据存储是不可或缺的一部分，而GreenDao作为Android平台上的一款高效、轻量级的对象关系映射（ORM）框架，深受开发者喜爱。它允许开发者以Java对象的...
Android GreenDao应用
11-27
**Android GreenDao应用** GreenDao是一款专门为Android平台设计的高效、轻量级的对象关系映射（ORM）框架，它使得开发者能够方便地将数据库操作与Java对象之间进行绑定，极大地简化了Android应用中的数据存储和...
Android GreenDao数据库升级
08-23
在版本迭代时，我们经常需要对数据库进行升级，而GreenDao3+默认的处理逻辑为在进行数据升级时，...具体的详情可以查看文章：《Android GreenDao数据库升级》https://blog.csdn.net/chen_md/article/details/132452503
Android GreenDao使用Demo
11-17
**Android GreenDao使用Demo** GreenDao是一款专门为Android平台设计的高效、轻量级的对象关系映射（ORM）框架，它允许开发者将数据模型类与SQLite数据库进行映射，从而简化了数据库操作。在这个Demo中，我们将深入...
Android数据库框架-GreenDao入门，阿里P8架构师Android大厂面试题总结
m0_64604178的博客
12-08 907
// in the individual module build.gradle files } } 之后点击Sync Project 2.2. 在app的build.gradle中配置 apply plugin: ‘com.android.application’ apply plugin: ‘org.greenrobot.greendao’ 之后在dependencies中添加依赖 dependencies { implementation fileTree(dir: ‘libs’, include:
Android GreenDao 使用全面讲解，2024最新大厂Android面经
最新发布
m0_61549781的博客
03-28 908
这里附上上述的面试题相关的几十套字节跳动，京东，小米，腾讯、头条、阿里、美团等公司19年的面试题。网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。从GreenDao 3 使用注解来定义模型和实体，前面也讲过，通过注解的使用可以快速构建数据库表，包括设置主键，自增，值是否唯一等等等……
Android 数据库之GreenDAO
qq_19688207的博客
08-08 1348
GreenDAO 是一款开源的面向 Android 的轻便、快捷的 ORM 框架，将 Java 对象映射到 SQLite 数据库中，我们操作数据库的时候，不再需要编写复杂的 SQL语句， 在性能方面，greenDAO 针对 Android 进行了高度优化，最小的内存开销 、依赖体积小 同时还是支持 数据库加密。对于每个实体类， greenDAO 都会生成一个与之对应 DAO 对象，如：User 实体，则会生成一个 UserDao 类。1、build.gradle(Module:app)中添加配置与依赖。
Android GreenDao 使用全面讲解，Android组件化入门
03-15 1758
我见过很多技术leader在面试的时候，遇到处于迷茫期的大龄程序员，比面试官年龄都大。这些人有一些共同特征：可能工作了5、6年，还是每天重复给业务部门写代码，工作内容的重复性比较高，没有什么技术含量的工作。问到这些人的职业规划时，他们也没有太多想法。其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。不断奔跑，你就知道学习的意义所在！
Android最火的框架系列（五）GreenDao
zhaojun的博客
05-29 2万+
其实工作以来，基本没跟数据库打过交道。今年年初，做一个项目，里面有数据持久化模块。当时尝试使用GreenDao，但是由于公司不让使用外网，连导入GreenDao都很困难，所以，最后不得已使用了Sqlite原生api进行数据的增删改查。最近工作不是很忙，今天偷偷地学习了一下GreenDao的使用，下班回来抓紧总结一下。 其实，一直以来，我写博客都只是为了总结自己所学。假如你恰好看到...
Android ORM 框架 GreenDao 使用详解，一线互联网移动架构师Android框架体系架构
2201_75604341的博客
03-27 1104
Override} else {} else {点击编译后，编译器不仅会为我们自动完成实体类代码的生成，还会在目录下生成三个文件。
android dao
weixin_35748962的博客
12-30 315
Android DAO(Data Access Object)是一种设计模式，用于在 Android 应用程序中访问数据库。它提供了一种简单的方法来从数据库中读取和写入数据，并使用简单的查询和持久化对象来维护这些数据。 DAO 通常与 Repository 一起使用，以帮助组织应用程序的数据访问层。 举个例子，假设你正在开发一个用于管理用户信息的应用程序。 你可以使用 DAO 来创建一个类，该类具...
Android GreenDao使用教程
木晓的博客
11-27 576
GreenDao是一款操作数据库的神器，经过了2.0版本的升级后，已经被广泛的开发者使用。确实是很好用，入门简单，可以剩去了数据库的建表操作和数据库SQL的编写 GreenDao3.2的配置 一、需要在工程（Project）的build.gradle中添加依赖 repositories { google() jcenter() } dependencies { classp...
Android Room 数据访问对象（DAO）详解
yingaizhu的博客
06-06 4160
使用 Room 库存储应用数据时，通过定义数据访问对象（DAOs）与存储的数据进行交互。每一个 DAO 包含用来访问应用数据库的抽象方法，在编译时， Room 会自动生成并实现在 DAO 中定义的访问方法 另外，本文本还介绍了 DAO 异步查询的相关内容，为了防止数据查询操作阻断 UI，造成 UI 卡顿，Room 不允许在 UI 主线程中访问数据库。这就意味着开发者必须将 DAO 中的查询定义成异步的。Room 库包含与多阿哥不同的框架进行集成，提供异步查询支持。
Android greendao
08-30
GreenDao是一个开源的Android ORM（“对象/关系映射”）框架，用于在Android项目中与SQLite数据库进行交互。它可以帮助开发人员快速且方便地进行数据库操作，节省开发时间。GreenDao的作用是通过ORM将Java对象与...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值