Android数据存储框架GreenDao 3.0使用详解
greendao 在kotlin中的使用-概述说明以及解释

greendao 在kotlin中的使用-概述说明以及解释1.引言1.1 概述概述部分的内容可以描述Greendao在Kotlin中的使用的背景和基本介绍。
可以包括以下几个方面:在当今移动应用开发中,数据持久化是非常重要的一部分。
而GreenDao是一个功能强大的对象关系映射(ORM)框架,用于在Android 应用中进行数据库管理。
它提供了简单、高效和快速的数据持久化解决方案。
Kotlin是一种适用于Java虚拟机(JVM)的静态类型编程语言。
它具有更简洁、更安全、更灵活的语法,并通过提供许多有用的功能和功能来提高开发效率。
本文将介绍如何在Kotlin中使用GreenDao。
首先,我们将简要介绍Kotlin的特点和优势,然后详细介绍GreenDao的基本概念和使用方法。
通过结合Kotlin和GreenDao,开发者可以享受到同时拥有强大数据库管理功能和简洁灵活语法的优势。
Kotlin的可空类型和扩展函数等特性可以帮助开发者更好地处理数据库操作,提高代码的可读性和可维护性。
同时,GreenDao提供了高效和快速的数据库访问方式,可以大大简化开发过程,并提供了强大的查询功能和数据缓存机制。
然而,在使用GreenDao的过程中,开发者也需要注意一些事项。
本文将重点介绍一些常见的问题和解决方案,以及一些建议和最佳实践,以帮助开发者更好地使用GreenDao进行数据库管理。
通过本文的学习,读者将能够了解到Kotlin和GreenDao的基本概念和使用方法,并能够在Kotlin项目中高效地使用GreenDao进行数据持久化管理。
1.2 文章结构本文将会按照以下结构进行描述和分析Greendao在Kotlin中的使用。
第一部分是引言部分,通过概述本文的主题和目的,为读者提供一个整体的了解。
第二部分是正文部分,主要分为两个小节,分别介绍Kotlin简介和GreenDao介绍。
在Kotlin简介中,将会对Kotlin语言进行简要介绍,包括其历史背景、特点和优势。
Android关于greenDao的使用教程

Android 关于greenDao 的使⽤教程关于greenDao 的使⽤第⼀篇How to get started ?原⽂地址:该教程会带你浏览⼀个简单的greenDao ⽰例⼯程。
地址:,该⼯程包含两个⼦⼯程:DaoExample 和DaoExampleGenerator 。
你可以clone 到本地,运⾏或者直接在github 上直接浏览。
如果你从git 仓储中检出了DaoExample ,可以直接像Android 应⽤⼀样运⾏它。
正如你所看到的,它就是⼀个简单的笔记本。
可以添加新的note ,或者点击已存在的note 进⾏删除。
预⽣成代码和创建表在src-gen ⽬录下,你可以找到⼀些已经⽣成的⽂件1)Note.java ⼀个包含⼀个Note 所有数据的java 类。
2)NoteDao.java ⼀个DAO 类,是操作Note 对象的接⼝。
你可以通过DaoExampleGenerator ⼯程再次⽣成Note 和NoteDao 。
使⽤DaoMaster 类可以获得⼀个⽅便的SQLiteOpenHelper:new DaoMaster.DevOpenHelper(this, "notes-db", null)你不必编写“CREATE TABLE” SQL 语句,greenDao 会为你完成。
插⼊和删除Note 对象创建了Note 表后,就可以存储⼀些note 到数据库⾥了。
这是在NoteActivity 类⾥完成的。
在onCreate ⽅法⾥,我们准备了⼀个DAO 对象:添加⼀个新的note 到数据库中:该⽰例只是创建并插⼊了⼀个java 对象。
但insert ⽅法返回的时候,数据库的ID 已经分发到了刚插⼊的Note 对象上了。
在log 中可以看到。
删除⼀条note :⾮常简单明,在onListItemClick ⽅法中可以看到你也可以看⼀下其它的DAO ⽅法:loadAll 、update 。
GreenDao数据库的简单使用

GreenDao数据库的简单使⽤在app项⽬下的build.gradle中,先添加插件 apply plugin: 'org.greenrobot.greendao' 再添加依赖包 compile 'org.greenrobot:greendao:3.2.2'在project中的build.gradle中,添加仓库 repositories{ mavenCentral() } 在dependencies中添加依赖{ classpath 'org.greenrobot:greendao-gradle-plugin:3.2.0' } 再添加⼀个全⼯程的仓库allprojects { repositories { jcenter() maven { url "https://jitpack.io" } } }这样GreenDao依赖包中就添加完成了,接下来就是去创建数据库表,在表中添加数据。
有⼀个GreenDaoManager类,这个类提供⼀个session,通过这个对象得到表对象,然后去操作数据库。
直接copy过去使⽤就可以了。
public class GreenDaoManager {private DaoMaster mDaoMaster;private DaoSession mDaoSession;private static GreenDaoManager mInstance; //单例private GreenDaoManager(){DaoMaster.DevOpenHelper devOpenHelper = newDaoMaster.DevOpenHelper(MyApplication.getContext(), "user-db", null);//此处为⾃⼰需要处理的表mDaoMaster = new DaoMaster(devOpenHelper.getWritableDatabase());mDaoSession = mDaoMaster.newSession();}public static GreenDaoManager getInstance() {if (mInstance == null) {synchronized (GreenDaoManager.class) {//保证异步处理安全操作if (mInstance == null) {mInstance = new GreenDaoManager();}}}return mInstance;}public DaoMaster getMaster() {return mDaoMaster;}public DaoSession getSession() {return mDaoSession;}public DaoSession getNewSession() {mDaoSession = mDaoMaster.newSession();return mDaoSession;}}创建⼀个db⽂件夹,在⽂件夹中再创建⼀个dao⽂件夹,在这⾥⾯就要写数据库对应的bean,GreenDaoManager也放到⾥⾯,⽐较容易找到@Entitypublic class UserBean {@Id(autoincrement = true)Long id;@Uniqueprivate String fromUserName;@ToMany(joinProperties = {@JoinProperty(name = "fromUserName", referencedName = "contactionFromUserName")})List<ContactionBean> contactionBeanList;@ToMany(joinProperties = {@JoinProperty(name = "fromUserName", referencedName = "msgFromUserName")})List<MsgBean> msgBeanList;}UserBean对应⼀个数据库中的⼀张表。
【推荐下载】Android SQLite框架greenDAO的使用

Android SQLite 框架greenDAO 的使用2016/02/16 16388 Android 中集成了SQLite 数据库,Android 本身提供了完备的SDK 提供访问存取SQLite 的接口,通过SQLiteOpenHelper 类来管理SQLite 数据库。
在SQLiteOpenHelper 类中的onCreate 方法中创建数据库,在onUpgrade 方法中升级数据库。
但随着应用的复杂度越来越高,表设计中的字段越来越多,我们编写的SQL 语句越来越长,CURD 代码越来越冗余冗长,越来越难以维护,而且导致错误率上升,影响开发质量和效率。
于是各种ORM 的数据库框架应运而生。
比如ORMLite、SugarORM、GreenDAO、Active Android、Realm 等。
其中很多基于注解的ORM 实现,类似于Hibernate,但在Android 设备上,从性能上分析并不可取。
greenDAO 未采用注解,而是使用代码生成器生成Entity 来实现Java 对象到数据库实例的映射,效率非常高。
greenDAO 的github 地址是https://github/greenrobot/greenDAO,官网greenrobot/greendao。
Android Studio 中的集成过程:1、在module 的build.gradle 中dependencies 的添加compile ‘de.greenrobot:greendao:2.0.0’2、导入greenDAO 的代码生成器模块:我采用的方式是直接从github 上clone整个greenDAO 的项目,然后在自己的项目中导入需要的代码生成器模块,导入成功后如图:3、使用生成器生成Entity,DAO,Master 以及Session 等greenDAO 要用到的类DaoGenerator 和DAOExampleGenerator 模块都是Java 工程,可以直接右键运行,而且DAOExampleGenerator 是依赖于DAOGenerator 的。
greendao用法

GreenDao用法什么是GreenDao?GreenDao是一个用于Android平台的轻量级的对象关系映射(ORM)库。
它可以帮助开发者在Android应用中实现数据库操作,提供了高效、简洁的API,使得数据库的操作变得更加方便和快捷。
GreenDao的特点包括:•高性能:GreenDao使用了代码生成的方式,生成了高效的DAO层代码,使得数据库操作非常快速。
•少量的代码:GreenDao的API设计非常简洁,减少了开发者的工作量。
•轻量级:GreenDao的库文件非常小巧,对应用的性能影响非常小。
•支持多种数据类型:GreenDao支持基本的数据类型,如整型、浮点型等,同时也支持自定义的数据类型。
GreenDao的安装和配置要在Android项目中使用GreenDao,需要进行以下几个步骤的安装和配置:1.在项目的build.gradle文件中添加GreenDao的依赖:dependencies {implementation 'org.greenrobot:greendao:3.3.0'}2.在项目的build.gradle文件中添加GreenDao的插件:apply plugin: 'org.greenrobot.greendao'3.在项目的build.gradle文件中配置GreenDao的代码生成:greendao {schemaVersion 1 // 数据库版本号daoPackage 'com.example.dao' // 生成的DAO类的包名targetGenDir 'src/main/java' // 生成的DAO类的目标目录}4.在项目的AndroidManifest.xml文件中添加数据库的初始化代码:<application>...<meta-dataandroid:name="DATABASE"android:value="my-database.db" /> // 数据库的名称<meta-dataandroid:name="VERSION"android:value="1" /> // 数据库的版本号<meta-dataandroid:name="GREEN_DAO_ASYNC"android:value="true" /> // 是否启用异步操作</application>GreenDao的基本用法GreenDao的基本用法包括以下几个方面:实体类的定义首先,需要定义一个实体类,用于表示数据库中的一张表。
Android SQLite第三方数据库greendao 的使用

Android SQLite第三方数据库greendao的使用一、导包1、在Android Studio 中的build.gradle文件中的dependencies节点中添加以下代码,然后点击同步按钮2、或者搜索de.greenrobot:greendao-generator:2.1.0和de.greenrobot:greendao:2.1.0 两个包自动导入compile'de.greenrobot:greendao-generator:2.1.0'compile 'de.greenrobot:greendao:2.1.0'二、配置环境我是以User用户表为例子在你当前工程地址创建ExampleDaoGenerator类,并添加以下代码,然后选中这个类右键选中run……main(),如下图所示import de.greenrobot.daogenerator.DaoGenerator;import de.greenrobot.daogenerator.Entity;import de.greenrobot.daogenerator.Schema;public class ExampleDaoGenerator {//以下添加的属性会成为以表的字段,以及实体类的属性private static void addTaskDetail(Schema schema) {//指定实体类,参数是实体类的类名Entity entity = schema.addEntity("User");//添加id属性entity.addIdProperty();//添加属性userId,指定非空entity.addStringProperty("userId").notNull();//添加属性usernameentity.addStringProperty("username");//添加属性ageentity.addIntProperty("age");//添加属性phoneentity.addStringProperty("phone");}public static void main(String[] args) throws Exception {//生成数据库文件的目标包名//target package for dao files//第一个参数是数据库版本号,第二个参数是包的根目录的包Schema schema = new Schema(1, "cn.myregent.www.greendaotext.db ");addTaskDetail(schema);try {//'..'代表当前目录,接着是工程名/studio的包地址/new DaoGenerator().generateAll(schema,"../OptimizationSQliteDemo/app/src/main/java/");} catch (Exception e) {e.printStackTrace();}}}/OptimizationSQliteDemo/app/src/main/java/cn/myregent/www/optimizationsqlitedemo//OptimizationSQliteDemo→你的工程名/app/src/main/java/→studio的包路径运行成功后会在你相对应的包中自动生成一个db包,里面有相对应的类DaoMaster:是用于实例化DaoSession用于操作数据库,还保存了OpenHelper和SQLiteOpenHelper通过调同UserDao中的方法用于创建数据库表,版本更新,以及删除表的功能package cn.myregent.www.greendaotext.db;import android.content.Context;import android.database.sqlite.SQLiteDatabase;import android.database.sqlite.SQLiteDatabase.CursorFactory;import android.database.sqlite.SQLiteOpenHelper;import android.util.Log;import de.greenrobot.dao.AbstractDaoMaster;import de.greenrobot.dao.identityscope.IdentityScopeType;// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT./*** Master of DAO (schema version 1): knows all DAOs.*/public class DaoMaster extends AbstractDaoMaster {public static final int SCHEMA_VERSION = 1;/** Creates underlying database table using DAOs. */public static void createAllTables(SQLiteDatabasedb, boolean ifNotExists) { UserDao.createTable(db, ifNotExists);}/** Drops underlying database table using DAOs. */public static void dropAllTables(SQLiteDatabasedb, boolean ifExists) { UserDao.dropTable(db, ifExists);}public static abstract class OpenHelper extends SQLiteOpenHelper {public OpenHelper(Context context, String name, CursorFactory factory) {super(context, name, factory, SCHEMA_VERSION);}@Overridepublic void onCreate(SQLiteDatabasedb) {Log.i("greenDAO", "Creating tables for schema version " + SCHEMA_VERSION); createAllTables(db, false);}}/** WARNING: Drops all table on Upgrade! Use only during development. */public static class DevOpenHelper extends OpenHelper {public DevOpenHelper(Context context, String name, CursorFactory factory) { super(context, name, factory);}@Overridepublic void onUpgrade(SQLiteDatabasedb, int oldVersion, int newVersion) {Log.i("greenDAO", "Upgrading schema from version " + oldVersion + " to " + newVersion + " by dropping all tables");dropAllTables(db, true);onCreate(db);}}public DaoMaster(SQLiteDatabasedb) {super(db, SCHEMA_VERSION);registerDaoClass(UserDao.class);}public DaoSessionnewSession() {return new DaoSession(db, IdentityScopeType.Session, daoConfigMap);}public DaoSessionnewSession(IdentityScopeType type) {return new DaoSession(db, type, daoConfigMap);}}DaoSession:会话层,用于操作UserDao类,所以拿到UserDao操作类需要用过实例化DaoMaster来创建DaoSession,通过getUserDao()拿到UserDao进行操作package cn.myregent.www.greendaotext.db;import android.database.sqlite.SQLiteDatabase;import java.util.Map;import de.greenrobot.dao.AbstractDao;import de.greenrobot.dao.AbstractDaoSession;import de.greenrobot.dao.identityscope.IdentityScopeType;import de.greenrobot.dao.internal.DaoConfig;// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT./*** {@inheritDoc}** @see de.greenrobot.dao.AbstractDaoSession*/public class DaoSession extends AbstractDaoSession {private final DaoConfig userDaoConfig;private final UserDao userDao;public DaoSession(SQLiteDatabasedb, IdentityScopeType type, Map<Class<? extends AbstractDao<?, ?>>, DaoConfig>daoConfigMap) {super(db);userDaoConfig= daoConfigMap.get(UserDao.class).clone();userDaoConfig.initIdentityScope(type);userDao= new UserDao(userDaoConfig, this);registerDao(User.class, userDao);}public void clear() {userDaoConfig.getIdentityScope().clear();}public UserDaogetUserDao() {return userDao;}}User:自动生成的用户实体类,与自己写的实体类差不多package cn.myregent.www.greendaotext.db;// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT. Enable "keep" sections if you want to edit./*** Entity mapped to table "USER".*/public class User {private Long id;/** Not-null value. */private String userId;private String username;private Integer age;private String phone;public User() {}public User(Long id) {this.id = id;}public User(Long id, String userId, String username, Integer age, String phone) { this.id = id;erId= userId;ername= username;this.age= age;this.phone= phone;}public Long getId() {return id;}public void setId(Long id) {this.id = id;}/** Not-null value. */public String getUserId() {return userId;}/** Not-null value; ensure this value is available before it is saved to the database. */public void setUserId(String userId) {erId= userId;}public String getUsername() {return username;}public void setUsername(String username) {ername= username;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age= age;}public String getPhone() {return phone;}public void setPhone(String phone) {this.phone= phone;}}UserDao:数据库表的操作类,可以把它看做是一个表,里面有一些createTable(),dropTable()等方法package cn.myregent.www.greendaotext.db;import android.database.Cursor;import android.database.sqlite.SQLiteDatabase;import android.database.sqlite.SQLiteStatement;import de.greenrobot.dao.AbstractDao;import de.greenrobot.dao.Property;import de.greenrobot.dao.internal.DaoConfig;import er;// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT./*** DAO for table "USER".*/public class UserDao extends AbstractDao<User, Long> {public static final String TABLENAME = "USER";/*** Properties of entity User.<br/>* Can be used for QueryBuilder and for referencing column names.*///参数分别是(列数,类型,Java实体类的变量名,是否主键,数据库列名)//因为上面entity.addIdProperty()自动生成了主键'_id'public static class Properties {public final static Property Id = new Property(0, Long.class, "id", true, "_id"); public final static Property UserId= new Property(1, String.class, "userId", false, "USER_ID");public final static Property Username = new Property(2, String.class, "username", false, "USERNAME");public final static Property Age = new Property(3, Integer.class, "age", false, "AGE");public final static Property Phone = new Property(4, String.class, "phone", false, "PHONE");};public UserDao(DaoConfigconfig) {super(config);}public UserDao(DaoConfigconfig, DaoSessiondaoSession) {super(config, daoSession);}/** Creates the underlying database table. */public static void createTable(SQLiteDatabasedb, boolean ifNotExists) {String constraint = ifNotExists? "IF NOT EXISTS ": "";db.execSQL("CREATE TABLE " + constraint + "\"USER\" (" + //"\"_id\" INTEGER PRIMARY KEY ," + // 0: id"\"USER_ID\" TEXT NOT NULL ," + // 1: userId"\"USERNAME\" TEXT," + // 2: username"\"AGE\" INTEGER," + // 3: age"\"PHONE\" TEXT);"); // 4: phone}/** Drops the underlying database table. */public static void dropTable(SQLiteDatabasedb, boolean ifExists) {String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"USER\""; db.execSQL(sql);}/** @inheritdoc*/@Overrideprotected void bindValues(SQLiteStatementstmt, User entity) {stmt.clearBindings();Long id = entity.getId();if (id != null) {stmt.bindLong(1, id);}stmt.bindString(2, entity.getUserId());String username = entity.getUsername();if (username != null) {stmt.bindString(3, username);}Integer age = entity.getAge();if (age != null) {stmt.bindLong(4, age);}String phone = entity.getPhone();if (phone != null) {stmt.bindString(5, phone);}}/** @inheritdoc*/@Overridepublic Long readKey(Cursor cursor, int offset) {return cursor.isNull(offset + 0) ? null : cursor.getLong(offset + 0);}/** @inheritdoc*/@Overridepublic User readEntity(Cursor cursor, int offset) {User entity = new User( //cursor.isNull(offset + 0) ? null : cursor.getLong(offset + 0), // id cursor.getString(offset + 1), // userIdcursor.isNull(offset + 2) ? null : cursor.getString(offset + 2), // username cursor.isNull(offset + 3) ? null : cursor.getInt(offset + 3), // age cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4) // phone );return entity;}/** @inheritdoc*/@Overridepublic void readEntity(Cursor cursor, User entity, int offset) {entity.setId(cursor.isNull(offset + 0) ? null : cursor.getLong(offset + 0)); entity.setUserId(cursor.getString(offset + 1));entity.setUsername(cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2));entity.setAge(cursor.isNull(offset + 3) ? null : cursor.getInt(offset + 3)); entity.setPhone(cursor.isNull(offset + 4) ? null : cursor.getString(offset + 4)); }/** @inheritdoc*/@Overrideprotected Long updateKeyAfterInsert(User entity, long rowId) {entity.setId(rowId);return rowId;}/** @inheritdoc*/@Overridepublic Long getKey(User entity) {if(entity != null) {return entity.getId();} else {return null;}}/** @inheritdoc*/@Overrideprotected boolean isEntityUpdateable() {return true;}}三、实际运用建一个MyApplication 继承Application做一个全局的初始化,在AndroidManifest.xml 文件中添加android:name=”.MyApplication”,主要是为了方便实例化DaoMaster和DaoSession,也可以不创建MyApplication,就直接自己建一个服务类实例化也可以package cn.myregent.www.optimizationsqlitedemo;import android.app.Application;import android.database.sqlite.SQLiteDatabase;import cn.myregent.www.optimizationsqlitedemo.db.DaoMaster;import cn.myregent.www.optimizationsqlitedemo.db.DaoSession;/*** Created by Administrator on 2016/5/13.*/public class MyApplication extends Application {private DaoMaster daoMaster;private DaoSession daoSession;private SQLiteDatabase sqLiteDatabase;private SQLiteDatabase db;@Overridepublic void onCreate() {super.onCreate();setupDataBase();}private void setupDataBase() {DaoMaster.DevOpenHelperopenHelper = newDaoMaster.DevOpenHelper(getApplicationContext(), DbConstant.DNNAME, null); db= openHelper.getReadableDatabase();daoMaster= new DaoMaster(db);daoSession= daoMaster.newSession();}public DaoSessiongetDaoSession(){return daoSession;}}创建DBHelper 数据库帮助类,进一步封装,操作数据库package cn.myregent.www.optimizationsqlitedemo;import android.content.Context;import java.util.List;import cn.myregent.www.optimizationsqlitedemo.db.DaoSession; import er;import erDao;import de.greenrobot.dao.query.Query;import de.greenrobot.dao.query.QueryBuilder;/*** Created by Administrator on 2016/5/13.*/public class DBHelper {//表private UserDao userDao;private static DBHelper dbHelper;private static Context mContext;private DBHelper() {}//单例模式得到DBHelperpublic static synchronized DBHelpergetDbHelper(Context context) { if (dbHelper== null) {dbHelper= new DBHelper();if (mContext== null) {mContext= context;//上下文赋值}//拿到DaoSession对象DaoSessiondaoSession = ((MyApplication)mContext.getApplicationContext()).getDaoSession();//拿到表对象erDao= daoSession.getUserDao();}return dbHelper;}/*** 查询比较* 根据username这一列,查询是否已经存在此name* 也可以根据其它列来查询,只要修改where中的代码就ok了* @param name* @return*/public boolean isSaveByName(String name) {//拿到查询构造器QueryBuilder<User>queryBuilder = userDao.queryBuilder();//构造器构造where语句 -->UserDao表中属性(Properties)-->那个属性(Username)-->eq(equal) 等于那个name的queryBuilder.where(ername.eq(name));//拿到查询到的位置行数-->idlong count = queryBuilder.buildCount().count();//大于0 代表存在return count >0 ? true : false;}/*** 添加数据* @param user 用户实体类*/public void insertUser(User user) {//判断如果不存在用户名则添加if (!isSaveByName(user.getUsername())){userDao.insert(user);//添加}}/*** 修改数据-->是根据主键来修改,即要修改数据先查询到要修改数据的主键_id * @param user 用户实体类*/public void updateUser(User user){//当修改数据时,每列的值必须要有,且主键不能改动,userDao.update(user);}/*** 查询所有数据* @return 返回User集合*/public List<User>selectAll(){List<User> users = userDao.loadAll();return users;}/*** 条件查询* 根据用户名字查询年龄* @param name 用户名字* @return 年龄*/public int getUserAge(String name){//构建查询构造器QueryBuilder<User>qb = userDao.queryBuilder();//条件查询qb.where(ername.eq(name));//查询到的结果在 qb 中的 list 里面if (qb.list().size()>0){//当qb中list不为空证明查询成功,返回年龄Integer age = qb.list().get(0).getAge();return age;}else {//否则查询失败返回-1return -1;}}/*** 多个条件查询* 根据用户名以及年龄查询* @param name 用户名* @param age 年龄* @return 符合条件全部*/public List<User>getMessage(String name,int age){QueryBuilder<User>qb = userDao.queryBuilder();qb.where(ername.eq(name),UserDao.Properties.Age.eq(age)); if (qb.list().size()>0){return qb.list();}else {return null;}}public void deleteUser(User user){userDao.deleteAll();//删除所有/*userDao.delete(user);//根据id主键删除最终调用deleteByKey() userDao.deleteByKey(0L);//根据id主键删除,*/}}。
greenDao使用指南-1

greenDao使用指南-1GreenDaoGreenDao是一个高效的数据库访问ORM框架,节省了自己编写SQL的时间,快速的增删查改等操作。
配置GreenDao// In your root build.gradle file:buildscript {repositories {jcenter()mavenCentral() // add repository}dependencies {classpath 'com.android.tools.build:gradle:2.3.0'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 plugindependencies {compile 'org.greenrobot:greendao:3.2.2' // add library}注意咯,一个是添加在工程的build.gradle,一个是添加到module的build.gradle文件中.build.gradlel里面对greenDao进行配置。
配置之后就搭建好了greenDao的环境,可以自动生成相关的类。
然后你需要配置greenDao的数据库版本号以及自动生成的包名的路径,当然路径可选择性的配置。
android{...}greendao{schemaVersion 2 // 数据库版本号daoPackage 'com.doris.sample.greendao'//greenDao 自动生成的代码保存的包名targetGenDir 'src/main/java' //自动生成的代码存储的路径,默认是 build/generated/source/greendao.generateTests false //true的时候自动生成测试单元targetGenDirTests: 测试单元的生成目录默认是 src/androidTest/java}接下来你定义自己的entity并且make project就可以开始对数据库进行操作啦。
greendao 用法

greendao 用法GreenDao 是一个用于 Android 平台的开源对象关系映射(ORM)库,它可以帮助开发者更加方便地将数据存储到 SQLite 数据库中。
GreenDao 利用代码生成器根据实体类创建对应的数据访问对象(DAO),并提供了简洁直观的 API 来操作数据库。
使用 GreenDao 有以下几个步骤:1. 引入 GreenDao:在项目的 build.gradle 文件中添加 GreenDao 的依赖。
2. 定义实体类:在 Android 项目中,使用 Java 实体类来表示数据模型。
通过在实体类中添加注解,可以指定属性的类型、名称、索引等信息。
3. 配置数据模型:使用 GreenDao 的代码生成器生成对应的 DAO 类。
可以通过配置生成器来指定生成的包名、目录等信息。
4. 初始化数据库:在应用程序的入口点(如 Application 类的 onCreate 方法)中初始化数据库。
这一步会创建数据库、数据表等必要的结构。
5. 使用 DAO 操作数据:通过 GreenDao 自动生成的 DAO 类,可以使用简洁的API 进行数据库的增删改查操作。
6. 查询数据:使用 GreenDao 提供的 QueryBuilder 类,可以进行复杂的查询操作,如条件查询、排序、分页等。
7. 数据库升级:当应用程序需要更新数据库结构时,可以通过修改实体类、重新生成 DAO 类,并添加数据库升级的代码来实现。
GreenDao 提供了许多优点,包括高性能、内存小、对 Android 平台进行了优化。
通过使用 GreenDao,开发者可以轻松管理和操作 Android 应用程序中的数据库,提高开发效率。
总之,GreenDao 是一个简单易用的 Android ORM 框架,它提供了方便的数据访问和操作功能,能够帮助开发者优化 Android 应用程序中的数据库管理工作。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Android数据存储框架GreenDao 3.0使用详解
GreenDao 3.0 的使用
1.简介
简单的讲,GreenDao是一个将对象映射到SQLite数据库中的轻量且快速的ORM 解决方案。
(GreenDaois a light & fast ORM solution that maps objects to SQLite databases.)
2.使用
2-1.导入相关的包
compile 'org.greenrobot:greendao:3.2.0'
2.2.配置(Module)
greendao {
schemaVersion 1 //数据库版本
daoPackage 'com.lee.codeplus.db' //默认生成的包名
targetGenDir 'src/main/java' //根目录
}
2.3.在build.gradle(Project)中进行配置
buildscript {
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.3.3'
classpath 'org.greenrobot:greendao-gradle-plugin:3.2.1'
}
}
3.使用
3.1 实体类的创建
@Entity
public class ArticleFile {
@Id
private Long id;
private String Category;
private String author;
private String createdAt;
private String objectId;
private String postType;
private String textContent;
private String updatedAt;
private String webUrl;
}
注:
(一) @Entity 定义实体
@nameInDb在数据库中的名字,如不写则为实体中类名@indexes 索引
@createInDb是否创建表,默认为true,false时不创建@schema 指定架构名称为实体
@active 无论是更新生成都刷新
(二) @Id
(三) @NotNull不为null
(四) @Unique 唯一约束
(五) @ToMany一对多
(六) @OrderBy排序
(七) @ToOne一对一
(八) @Transient 不存储在数据库中
(九) @generated 由greendao产生的构造函数或方法
3.2 Make Project自动生成Dao类等
图上3个选中的类就是生成的。
3.3 在Application中初始化
private DaoMastermDaoMaster;
private DaoSessionmDaoSession;
private DaoMaster.DevOpenHelpermHelper;
private SQLiteDatabasedb;
public static BaseApplication instances;
@Override
public voidonCreate() {
super.onCreate();
instances=this;
initDataBase();
}
public static BaseApplication getInstances() {
return instances;
}
private void initDataBase() {
// 注意:默认的DaoMaster.DevOpenHelper会在数据库升级时,删除所有的表,意味着这将导致数据的丢失。
mHelper=newDaoMaster.DevOpenHelper(this,"Code-db", null);
db=mHelper.getWritableDatabase();
// 注意:该数据库连接属于DaoMaster,所以多个Session 指的是相同的数据库连接。
mDaoMaster=newDaoMaster(db);
mDaoSession=mDaoMaster.newSession();
}
public DaoSessiongetDaoSession() {
return mDaoSession;
}
public SQLiteDatabasegetDb() {
return db;
}
3.4 增加数据
ArticleFileDaodao =BaseApplication.getInstances().getDaoSession().getArticleFileDao();
dao.insert(article);
3.5.删除数据
ArticleFileDaodao = BaseApplication.getInstances().getDaoSession().getArticleFileDao(); ArticleFileDaodao.queryBuilder().where(ArticleFileDao.Properties.ObjectId.eq(article.getObjectId())).buil d().unique();
dao.deleteByKey(article.getId())
3.6.修改数据
ArticleFile article = dao.queryBuilder().where(ArticleFileDao.Properties.ObjectId.eq(article.getObjectId ())).build().unique();
if(atricle !=null){
article.setAuthor("修改");
dao.updata(article)
}
3.7.查询数据
List <ArticleFile>articles= dao.loadAll() 。