Android数据存储框架GreenDao 3.0使用详解

合集下载

greendao 在kotlin中的使用-概述说明以及解释

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的使用教程

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数据库的简单使用

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的使用

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?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 的使用

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使用指南-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 用法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 应用程序中的数据库管理工作。

android dao 数据库简单用法

android dao 数据库简单用法

android dao 数据库简单用法Android DAO 数据库简单用法在Android开发中,使用数据库是非常常见的操作之一。

数据库的使用可以帮助我们持久化数据,并允许我们在应用程序中进行数据的查询、插入、更新和删除操作。

在本文中,我们将重点讨论Android中的DAO模式,并介绍如何在Android应用程序中实现简单的数据库操作。

一、什么是DAO模式?DAO(Data Access Object)模式是一种设计模式,它的主要目的是将数据访问逻辑与业务逻辑分离。

在Android中,DAO模式通常用于封装数据库操作,将数据库的增删改查等操作封装在DAO类中,使业务逻辑模块与数据访问模块解耦,提高代码的可维护性和可测试性。

二、创建数据库首先,我们需要创建一个数据库。

Android提供了SQLite数据库,可以用于存储应用程序的数据。

要创建一个数据库,我们需要继承SQLiteOpenHelper类,并实现onCreate()和onUpgrade()方法。

1. 创建一个名为DatabaseHelper的类,继承自SQLiteOpenHelper。

javapublic class DatabaseHelper extends SQLiteOpenHelper { 数据库名和版本号private static final String DATABASE_NAME = "my_database";private static final int DATABASE_VERSION = 1;表名和列名private static final String TABLE_NAME = "my_table";private static final String COLUMN_ID = "id";private static final String COLUMN_NAME = "name";...public DatabaseHelper(Context context) {super(context, DATABASE_NAME, null,DATABASE_VERSION);}@Overridepublic void onCreate(SQLiteDatabase db) {创建表的SQL语句String CREATE_TABLE_SQL = "CREATE TABLE " + TABLE_NAME + " (" +COLUMN_ID + " INTEGER PRIMARY KEYAUTOINCREMENT, " +COLUMN_NAME + " TEXT)";执行创建表的操作db.execSQL(CREATE_TABLE_SQL);}@Overridepublic void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {备份数据并删除原表String BACKUP_TABLE_SQL = "ALTER TABLE " +TABLE_NAME + " RENAME TO temp_"+ TABLE_NAME;db.execSQL(BACKUP_TABLE_SQL);db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);创建新表onCreate(db);将备份数据恢复到新表String RESTORE_TABLE_SQL = "INSERT INTO " + TABLE_NAME + " SELECT * FROM temp_"+ TABLE_NAME;db.execSQL(RESTORE_TABLE_SQL);删除备份表db.execSQL("DROP TABLE IF EXISTS temp_" +TABLE_NAME);}}2. 在需要使用数据库的地方,创建DatabaseHelper对象,并获取可写数据库。

GreenDao使用解析

GreenDao使用解析

GreenDao使⽤解析GreenDao是⼀个轻量级的数据库框架,相⽐Xutils 等他的速度和效率会更快更好这⾥展⽰GreenDao 的使⽤⽅法①建⽴compile 'org.greenrobot:greendao:3.2.0' 基于Android Studio 的集成⾮常简单,你需要现在Build Gradle⾥依赖此GreenDao库除此之外,你还需要在Build Gradle⾥使⽤插件的形式声明//使⽤greendaoapply plugin: 'org.greenrobot.greendao' 还应该在build.gradle⾥配置dao 的package和targetGenDir 和 version,此配置应是在android{ }内声明//greendao配置greendao {//版本号,升级时可配置schemaVersion 1daoPackage 'arcturis.greendao'targetGenDir 'src/main/java'} 补充⼀句,数据库的使⽤是需要SD卡的读写权限的所以别忘了添加权限<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/><uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/> tips!还需要再⼯程的build.gradle⾥声明,此处位于dependencies{ }内//GreenDao3依赖classpath 'org.greenrobot:greendao-gradle-plugin:3.2.1'②代码⾃动⽣成机制GreenDao 的数据基类⽣成⽅式和xutils不⼀样,Xutils你需要⼿动去写bean类,然后和他的⼀些get Set⽅法,虽然Green也需要你去写,但是他更多亮点的东西是⾃动⽣成这些相关⽅法,包括他的数据库声明以及控制⽂件⽐如我们需要⼀个列表购物的清单⽂件这个商品我们需要保存于数据库中类似于这个是开始的bean基类@Entitypublic class Shop {//表⽰为购物车列表public static final int TYPE_CART = 0x01;//表⽰为收藏列表public static final int TYPE_LOVE = 0x02;//不能⽤int@Id(autoincrement = true)private Long id;//商品名称 Unique 该属性值必须在数据库中是唯⼀值@Uniqueprivate String name;//商品价格 Property 可以⾃定义字段名,注意外键不能使⽤该属性@Property(nameInDb = "price")private String price;//已售数量private int sell_num;//图标urlprivate String image_url;//商家地址private String address;//商品列表类型private int type;} 这⾥就是⼀个基本的bean基类,我们需要注解,这样GreenDao才会知道这个是我们的bean基类,才会有后⾯的⾃动⽣成代码的部分,然后我们看下各个注解的意思@Entity 这个是⼀个Bean基类Entity@Id(autoincrement = true) ID 可以设置是否⾃增涨,开启⾃增长之后就算初始化你传⼊null也没有关系,类型为Long型@Unique 由此标识标识在数据库中此字段为唯⼀@Property:设置⼀个⾮默认关系映射所对应的列名,默认是使⽤字段名,例如:@Property(nameInDb = "name")之后点击编译按钮,然后如果各项设置均准确设置成功,GreenDao就会帮助我们⽣成以下⽂件就是标红的三个⽂件DaoMasterDaoSessionShopDao(这个名字是根据我们定义的bean类类名字来定义的)然后我们就可以在Application⾥进⾏初始化⼯作private void steupDataBase(){DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this,"shop.db",null);//获取可写DataBaseSQLiteDatabase db = helper.getWritableDatabase();//获取数据库对象DaoMaster daoMaster = new DaoMaster(db);//获取Dao对象管理者daoSession = daoMaster.newSession();}DaoMaster:使⽤ greenDAO 的⼊⼝点。

在Android中使用GreenDao进行数据库操作

在Android中使用GreenDao进行数据库操作

在Android中使用GreenDao进行数据库操作在Android应用开发中,数据存储和管理是一个重要的环节。

为了便捷地进行数据库操作,Android开发者可以选择使用GreenDao这一数据库操作框架。

本文将介绍如何在Android中使用GreenDao进行数据库操作。

一、GreenDao简介GreenDao是一个针对Android平台的轻量级对象关系映射(ORM)框架。

它提供了简洁的API和高效的性能,可以帮助开发者简化数据库操作的过程。

GreenDao通过将Java对象映射到SQLite数据库中的表,实现了数据的持久化存储和读取。

二、安装GreenDao首先,我们需要在项目的build.gradle文件中添加GreenDao的依赖。

在dependencies中添加如下代码:```implementation 'org.greenrobot:greendao:3.2.2'```接下来,我们需要在主项目中的build.gradle文件中,添加对于greendao-generator的依赖。

在dependencies中添加如下代码:```implementation 'org.greenrobot:greendao-generator:3.2.2'```然后,我们需要在AndroidManifest.xml文件中添加如下代码:```<meta-data android:name="DB_NAME"android:value="your_db_name" />```这里的"your_db_name"是你想要设置的数据库名称。

完成以上步骤后,我们就成功安装了GreenDao。

三、创建实体类在使用GreenDao之前,我们需要创建相应的实体类来映射数据库中的表。

例如,我们可以创建一个名为"User"的实体类,包含id、name和age等属性。

Android数据存储之GreenDao3.0详解

Android数据存储之GreenDao3.0详解

Android数据存储之GreenDao3.0详解前⾔:今天⼀⼤早收到GreenDao 3.0 正式发布的消息,⾃从2014年接触GreenDao⾄今,项⽬中⼀直使⽤GreenDao框架处理数据库操作,本⼈使⽤数据库路线 Sqlite---->OrmLite---->GreenDao。

今天⽩天⼀直在忙着公司的项⽬需求,只能晚上加班来学习最新的GreenDao 3.0使⽤⽅式了。

GreenDao 介绍:greenDAO是⼀个对象关系映射(ORM)的框架,能够提供⼀个接⼝通过操作对象的⽅式去操作关系型数据库,它能够让你操作数据库时更简单、更⽅便。

如下图所⽰:GreenDao 优点:性能⾼,号称Android最快的关系型数据库内存占⽤⼩库⽂件⽐较⼩,⼩于100K,编译时间低,⽽且可以避免65K⽅法限制⽀持数据库加密 greendao⽀持SQLCipher进⾏数据库加密有关SQLCipher可以参考这篇博客简洁易⽤的APIGreenDao 3.0改动:使⽤过GreenDao的同学都知道,3.0之前需要通过新建GreenDaoGenerator⼯程⽣成Java数据对象(实体)和DAO对象,⾮常的繁琐⽽且也加⼤了使⽤成本。

GreenDao 3.0最⼤的变化就是采⽤注解的⽅式通过编译⽅式⽣成Java数据对象和DAO对象。

GreenDao 3.0使⽤⽅式:1.)在build.gradle添加如下配置buildscript {repositories {mavenCentral()}dependencies {classpath 'org.greenrobot:greendao-gradle-plugin:3.0.0'}}apply plugin: 'org.greenrobot.greendao'dependencies {compile 'org.greenrobot:greendao:3.0.1'}2.)新建实体@Entitypublic class User {@Idprivate Long id;private String name;private int age;//下⾯省去了 setter/getter}此时编译⼀下⾃动⽣成DaoMaster 、DaoSession、Dao,如图所⽰默认位置:3.)Gradle 插件配置⽐如上⾯想指定⽣成DaoMaster 、DaoSession、Dao位置}schemaVersion:数据库schema版本,也可以理解为数据库版本号daoPackage:设置DaoMaster 、DaoSession、Dao包名targetGenDir:设置DaoMaster 、DaoSession、Dao⽬录targetGenDirTest:设置⽣成单元测试⽬录generateTests:设置⾃动⽣成单元测试⽤例4.)实体@Entity注解schema:告知GreenDao当前实体属于哪个schemaactive:标记⼀个实体处于活动状态,活动实体有更新、删除和刷新⽅法nameInDb:在数据中使⽤的别名,默认使⽤的是实体的类名indexes:定义索引,可以跨越多个列createInDb:标记创建数据库表5.)基础属性注解@Id :主键 Long型,可以通过@Id(autoincrement = true)设置⾃增长@Property:设置⼀个⾮默认关系映射所对应的列名,默认是的使⽤字段名举例:@Property (nameInDb="name") @NotNul:设置数据库表当前列不能为空@Transient :添加次标记之后不会⽣成数据库表的列6.)索引注解@Index:使⽤@Index作为⼀个属性来创建⼀个索引,通过name设置索引别名,也可以通过unique给索引添加约束@Unique:向数据库列添加了⼀个唯⼀的约束7.)关系注解@ToOne:定义与另⼀个实体(⼀个实体对象)的关系@ToMany:定义与多个实体对象的关系GreenDao 3.0简单实战:1.)通过上⾯使⽤⽅式我们可以获取DaoMaster 、DaoSession、Dao类这⾥声明⼀个数据库管理者单例public class DBManager {private final static String dbName = "test_db";private static DBManager mInstance;private DaoMaster.DevOpenHelper openHelper;private Context context;public DBManager(Context context) {this.context = context;openHelper = new DaoMaster.DevOpenHelper(context, dbName, null);}/*** 获取单例引⽤** @param context* @return*/public static DBManager getInstance(Context context) {if (mInstance == null) {synchronized (DBManager.class) {if (mInstance == null) {mInstance = new DBManager(context);}}}return mInstance;}}2.)获取可读可写数据库可读数据库/*** 获取可读数据库private SQLiteDatabase getReadableDatabase() {if (openHelper == null) {openHelper = new DaoMaster.DevOpenHelper(context, dbName, null); }SQLiteDatabase db = openHelper.getReadableDatabase();return db;}可写数据库/*** 获取可写数据库*/private SQLiteDatabase getWritableDatabase() {if (openHelper == null) {openHelper = new DaoMaster.DevOpenHelper(context, dbName, null); }SQLiteDatabase db = openHelper.getWritableDatabase();return db;}3.)插⼊数据/*** 插⼊⼀条记录** @param user*/public void insertUser(User user) {DaoMaster daoMaster = new DaoMaster(getWritableDatabase());DaoSession daoSession = daoMaster.newSession();UserDao userDao = daoSession.getUserDao();userDao.insert(user);}/*** 插⼊⽤户集合** @param users*/public void insertUserList(List<User> users) {if (users == null || users.isEmpty()) {return;}DaoMaster daoMaster = new DaoMaster(getWritableDatabase());DaoSession daoSession = daoMaster.newSession();UserDao userDao = daoSession.getUserDao();userDao.insertInTx(users);}4.)删除数据/*** 删除⼀条记录** @param user*/public void deleteUser(User user) {DaoMaster daoMaster = new DaoMaster(getWritableDatabase());DaoSession daoSession = daoMaster.newSession();UserDao userDao = daoSession.getUserDao();userDao.delete(user);}5.)更新数据/*** 更新⼀条记录** @param user*/public void updateUser(User user) {DaoMaster daoMaster = new DaoMaster(getWritableDatabase());DaoSession daoSession = daoMaster.newSession();UserDao userDao = daoSession.getUserDao();userDao.update(user);}6.)查询数据* 查询⽤户列表*/public List<User> queryUserList() {DaoMaster daoMaster = new DaoMaster(getReadableDatabase());DaoSession daoSession = daoMaster.newSession();UserDao userDao = daoSession.getUserDao();QueryBuilder<User> qb = userDao.queryBuilder();List<User> list = qb.list();return list;}/*** 查询⽤户列表*/public List<User> queryUserList(int age) {DaoMaster daoMaster = new DaoMaster(getReadableDatabase());DaoSession daoSession = daoMaster.newSession();UserDao userDao = daoSession.getUserDao();QueryBuilder<User> qb = userDao.queryBuilder();qb.where(UserDao.Properties.Age.gt(age)).orderAsc(UserDao.Properties.Age);List<User> list = qb.list();return list;}7.)测试程序DBManager dbManager = DBManager.getInstance(this);for (int i = 0; i < 5; i++) {User user = new User();user.setId(i);user.setAge(i * 3);user.setName("第" + i + "⼈");dbManager.insertUser(user);}List<User> userList = dbManager.queryUserList();for (User user : userList) {Log.e("TAG", "queryUserList--before-->" + user.getId() + "--" + user.getName() +"--"+user.getAge());if (user.getId() == 0) {dbManager.deleteUser(user);}if (user.getId() == 3) {user.setAge(10);dbManager.updateUser(user);}}userList = dbManager.queryUserList();for (User user : userList) {Log.e("TAG", "queryUserList--after--->" + user.getId() + "---" + user.getName()+"--"+user.getAge());}运⾏结果总结:本⽂主要介绍了GreenDao 3.0使⽤注解的情况,以及实现了简单的增删改查,接下来会更⼀步学习GreenDao更为复杂的使⽤的⽅式。

Android SQLite第三方数据库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用法

greendao用法

greendao用法Greendao是一种流行的Android ORM(对象关系映射)框架,用于通过简单的Java注解将Java对象映射到SQLite数据库中。

在本文中,我将一步一步地介绍Greendao的用法,以帮助你更好地理解和使用这个强大的数据库框架。

1. 引入Greendao库首先,你需要在Android Studio的build.gradle文件中添加Greendao库的依赖。

在dependencies块中添加以下代码:implementation 'org.greenrobot:greendao:3.3.0'然后,点击“Sync Now”按钮,让Android Studio下载并安装Greendao库。

2. 创建实体类在使用Greendao之前,你需要先创建一个实体类。

实体类可以具有任何你需要存储在数据库中的属性。

例如,如果你想创建一个存储用户信息的实体类,可以创建一个名为User的Java类,并在其中定义名称、年龄和性别等属性。

java@Entitypublic class User {@Id(autoincrement = true)private Long id;private String name;private int age;private String gender;必须包含无参构造函数public User() {}Getters and Setters...}在上面的代码中,@Entity注解表示这是一个Greendao实体类。

@Id注解表示id属性是一个主键,autoincrement属性表示id将自动递增。

3. 创建数据库接下来,你需要使用GreenDaoGenerator创建数据库。

首先,创建一个名为greendao-generator的模块,并在其中创建一个GreenDaoGenerator类,并添加以下代码:javapublic class GreenDaoGenerator {public static void main(String[] args) throws Exception {Schema schema = new Schema(1,"com.example.greendaoexample.db");添加实体类Entity user = schema.addEntity("User");user.addIdProperty().autoincrement();user.addStringProperty("name");user.addIntProperty("age");user.addStringProperty("gender");指定生成目录new DaoGenerator().generateAll(schema, "app/src/main/java");}}在上面的代码中,首先创建了一个Schema对象,用于指定数据库版本和包名。

greendao用法

greendao用法

greendao用法GreenDao是一个用于Android平台的对象关系映射(ORM)库,可以在Android应用程序中以简单、快速和高效的方式访问和管理数据库。

它提供了一个面向对象的接口,允许开发人员将Java对象映射到SQLite数据库表中,从而使得数据的持久化变得非常容易。

GreenDao的用法主要包括三个方面:定义实体类、创建数据库和执行CRUD操作。

1.定义实体类在使用GreenDao之前,需要先定义实体类,通过注解的方式添加一些额外的信息来帮助GreenDao生成相关的数据库表和代码。

每个实体类对应一个数据库表。

以下是一个示例实体类的定义:```javapublic class Userprivate Long id;private String name;private int age;// 构造函数、getter和setter等方法省略```2.创建数据库创建数据库是使用GreenDao的第一步。

可以通过GreenDao提供的DaoMaster和DaoSession来管理数据库的创建、升级和访问。

```java//创建数据库DaoMaster.DevOpenHelper helper = newDaoMaster.DevOpenHelper(context, "mydb");Database db = helper.getWritableDb(;// 创建DaoMaster和DaoSessionDaoMaster daoMaster = new DaoMaster(db);DaoSession daoSession = daoMaster.newSession(;```在上面的例子中,使用DaoMaster.DevOpenHelper来创建数据库,传入数据库名称"mydb"。

然后通过getWritableDb(方法获取可写的数据库对象。

接着使用DaoMaster和DaoSession来得到一个可用的DaoSession对象。

greendao in()的用法

greendao in()的用法

greendao in()的用法GreenDao是一个快速和轻量级的Android ORM框架。

它的设计目标是快速、高效和易于使用。

GreenDao的主要特点是提供了高性能的数据库访问,以及自动生成Java类。

它支持面向对象编程的方法,这使得它在处理复杂对象关系时特别有用。

本文将介绍GreenDao中in()方法的用法。

在GreenDao中,in()方法是一种非常有用的查询方法。

它可以将多个数据项作为参数,并返回匹配这些数据项的所有记录。

例如,如果想要查找数据库中所有名称为“John”、“Mike”和“Sarah”的人,您可以使用以下查询:QueryBuilder qb = userDao.queryBuilder();qb.where(.in("John", "Mike", "Sarah"));List<User> userList = qb.list();在上面的代码中,我们使用了QueryBuilder来创建查询。

这是GreenDao用于构建查询语句的主要工具。

在此代码中,我们使用in()方法来查找名称在“John”、“Mike”和“Sarah”的所有用户。

in()方法还可以与其他查询条件组合使用。

例如,如果我们想查找名字在“John”、“Mike”和“Sarah”之间的所有用户,并且他们的年龄在20岁以上,我们可以这样做:总之,in()方法是GreenDao中非常有用的查询方法之一。

它允许我们轻松地查找多个匹配条件的记录,并与其他查询条件组合使用。

在使用GreenDao处理复杂数据库查询时,in()方法非常有用。

【推荐下载】Android greenDao 数据库的使用(二)

【推荐下载】Android greenDao 数据库的使用(二)

Android greenDao 数据库的使用(二)2015/10/12 0 greenDao 是什么?哈哈,自己百度下吧。

这里主要讲下在android 开发中,如何使用greenDao 这个第三方的数据库。

greenDao 使用主要步骤可分为3:一、利用一个java 项目生成数据库实体类,Dao 类(代码)等;二、Android 项目中引用步骤一中生成的类,以及初始化(本文章主要讲解内容);三、android 中具体的使用方式(增删改查),以及greenDao如何做数据库升级。

对于步骤一,可以查看下面博客:blog.csdn/u013067184/article/details/48751979 下面主要讲下步骤二。

1、在步骤一的时候,我们已经在DaoResult 该文件夹下生成了greenDao 第三方库所需要的实体类以及dao 类等代码。

将其拷贝到我们的android 项目中,并且引用进来,如下图:可以看到,在我们的android 项目中,多了一个src-gen 文件目录。

当然,这里面src-gen 还会报错。

还需我们在lib 中加入greenDao 的jar 包。

下载地址如下:download.csdn/detail/u013067184/9174655jar 包导入之后,还会报错,因为里面的实体类,比如Player,我们在生成的时候,将其进行了序列化,此时只要导入相对应的包,做下序列化所需的代码操作就可以了,如图:这里再说明下,当我们随意打开一个src-gen 中的一个实体类时,在类文件的头部,我们会发现有着一些注释说明,如图:也就是说greenDao 它本身不允许我们在它自动生成的这些实体类,或者dao 类的代码中随意修改或者添加任何代码。

如果你想添加你的代码,它也指定了位置让你添加。

2、在我们android 项目的全局Application 中,对greenDao 进行初始化(官方推荐将取得DaoMaster 对象的方法放到Application 层这样避免多次创建生成Session对象)。

greenDAO优点及使用详解

greenDAO优点及使用详解

greenDAO优点及使⽤详解⼀、关于greenDAOgreenDAO是⼀个开源的Android ORM,它让SQLite数据库的开发再次变得有趣。

它使开发⼈员免于处理低级数据库要求,同时节省了开发时间。

SQLite是⼀个很棒的嵌⼊式关系数据库。

尽管如此,编写SQL和解析查询结果仍然是⾮常繁琐且耗时的任务。

通过将Java对象映射到数据库表(称为ORM,“对象/关系映射”),greenDAO使您摆脱了这些⿇烦。

这样,您可以使⽤简单的⾯向对象的API来存储,更新,删除和查询Java对象。

⼆、greenDAO优点最佳性能 (可能是 Android 中最快的 ORM) ,基准测试也是开源的;易于使⽤的功能强⼤的 api,涵盖关系和连接;最⼩的内存消耗;⼩型库⼤⼩(< 100KB) ,以保持较低的构建时间,并避免65k ⽅法限制;数据库加密:greenDAO ⽀持 SQLCipher 来保证⽤户数据的安全;强⼤⽽活跃的社区交流⽀持,相关资料⽐较完善;许多顶级的Android应⽤程序都依赖greenDAO,其中⼀些应⽤程序的安装量超过1000万,更证明了其可靠性。

三、引⼊greenDAO⾸先在项⽬⽬录下的build.gradle中配置repositories {// GreenDao仓库mavenCentral()}dependencies {// GreenDao插件classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'}然后在app⽬录下的build.gradle中配置//GreenDao插件apply plugin: 'org.greenrobot.greendao'dependencies {implementation 'org.greenrobot:greendao:3.2.2'}android {greendao {schemaVersion 1//数据库版本号每次升级数据库都需要改变版本,只能增加daoPackage 'com...green'//设置DaoMaster、 DaoSession、Dao包名targetGenDir 'src/main/java'//设置DaoMaster、DaoSession、Dao⽬录}}四、创建数据库及增删改查操作先创建⼀个实体类@Entitypublic class UserIm {@Idprivate Long id;private String userId;private String name;private String url;}其中Long id对应数据表中的主键,是⼀条数据的唯⼀标识。

greendao原理

greendao原理

greendao原理
GreenDAO 是一个 Android ORM (对象-关系映射)框架,用
于对 SQLite 数据库进行操作。

GreenDAO 的原理是将数据库
表映射为 Java 对象,提供了一种便捷的方式来进行数据库的
增删改查操作。

GreenDAO 的核心是生成和管理实体类和 DAO 类。

通过使用GreenDAO 的代码生成器,可以根据实体类的定义自动生成对
应的 DAO 类,以及一些其他相关类。

生成的 DAO 类提供了
对数据库的增删改查的方法,还可以自定义查询语句以满足各种需求。

在使用 GreenDAO 进行数据库操作时,首先需要创建一个全
局的 DaoSession 对象,该对象可通过 DaoMaster 类的静态方
法创建。

DaoSession 对象提供了一系列的 DAO 对象,用于进
行数据库操作。

通过调用DAO 对象的相应方法,可以进行数据的插入、删除、更新、查询等操作。

GreenDAO 通过使用 SQLiteOpenHelper
来创建和管理数据库,提供了一种高效和可靠的方式来进行数据库操作。

GreenDAO 还提供了一些高级特性,如数据库升级、事务管理、查询缓存等,可以进一步提高数据库操作的效率和灵活性。

总结起来,GreenDAO 的原理是通过将数据库表映射为 Java
对象,提供一种方便的方式来进行数据库操作。

它通过代码生成器生成 DAO 类,提供了一系列的方法来进行数据库的增删
改查操作。

同时,GreenDAO 还提供了一些高级特性来提高数据库操作的效率和灵活性。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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() 。

相关文档
最新文档