GreenDao

最新推荐文章于 2024-08-15 09:41:08 发布
最新推荐文章于 2024-08-15 09:41:08 发布
阅读量1k 收藏 1
点赞数
分类专栏： Android 数据库 文章标签： greendao
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feather_wch/article/details/81503652
版权

转载请注明链接：https://blog.csdn.net/feather_wch/article/details/81503652

GreenDao

GreenDao的作用

1、GreenDao的作用

  1. GreenDAO 是一个将对象映射到 SQLite 数据库中的轻量且快速的 ORM解决方案。
    GreenDao

2、ORM是什么

通过将Java对象映射到数据库表（称为ORM“对象/关系映射”）。

GreenDao的优缺点

3、GreenDao的优点

  1. 目前为止性能最高、内存消耗最小
  2. 使用人数众多，开发者长期维护。
  3. 使用简单：简洁直观的API
  4. 轻量：库<150K，它只是纯Java jar（没有CPU依赖的本机部分）
  5. 快速：可能是由智能代码生成驱动的Android中最快的ORM
  6. 安全和表达式的查询API：QueryBuilder使用属性常量来避免打字错误
  7. 强大的连接：跨实体查询，甚至链接复杂关系
  8. 灵活的属性类型：使用自定义类或枚举来表示实体中的数据
  9. 支持数据库加密：支持SQLCipher加密数据库
  10. 代码自动生成
  11. 开源
  12. 支持缓存

4、GreenDao的速度对比
GreenDao的速度对比

GreenDao离线导入

libs中导入GreenDao函数库

  1. libs 中的文件 拷入到 androidStudio的libs中 并 Add as Library；
  2. 在modle的build.gradle中第一行 添加
apply plugin: 'org.greenrobot.greendao'
  1. 在modle的build.gradle中的android{ }函数中添加
greendao {
        schemaVersion 1
        targetGenDir 'src/main/java'
        daoPackage '包名.greendao' //  
    }
  1. 最终实例
apply plugin: 'com.android.application'
apply plugin: 'org.greenrobot.greendao'
android {
    xxx
    greendao {
        schemaVersion 1
        targetGenDir 'src'
        daoPackage '包名.greendao'
    }
}

dependencies {
    xxx
    compile files('libs/greendao-3.2.2.jar')
    compile files('libs/greendao-api-3.2.2.jar')
}

导入GreenDao gradle插件的离线包

  1. 将greenDaoPlugin文件复制到 项目的根目录中(最外层build.gradle的同级目录中)
  2. 在项目根目录的build.gradle中添加 classpath
fileTree(includes:['*.jar'],dir:'greendaoPlugin')
  1. 最终实例
buildscript {
    repositories {
        xxx
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.3.0'
        classpath fileTree(includes:['*.jar'],dir:'greenDaoPlugin')
    }
}
xxx
    // in the individual module build.gradle files
}

}

GreenDao的使用

自定义GreenDaoManager

1、GreenDaoManager的作用

随时随地可以获取操作所需要的DaoSession且只创建一次

2、GreenDaoManager的作用

1-GreenDaoManager.java

public class GreenDaoManager {
    // 数据库名称
    private static final String DB_NAME="greendao";
    private static GreenDaoManager mInstance;
    // DaoMaster
    private DaoMaster daoMaster;
    // DaoSession
    private DaoSession daoSession;
    // 开启日志输出

    public static GreenDaoManager getInstance(){
        if(mInstance==null){
            synchronized (GreenDaoManager.class){
                if(mInstance==null){
                    mInstance =new GreenDaoManager();
                }
            }
        }
        return mInstance;
    }
    private GreenDaoManager(){
        if(mInstance==null){
            DaoMaster.DevOpenHelper devOpenHelper = new DaoMaster.DevOpenHelper(BaseApplication.getContext(), DB_NAME, null);
            daoMaster = new DaoMaster(devOpenHelper.getWritableDatabase());
            daoSession = daoMaster.newSession();
            // 开启日志输出
            QueryBuilder.LOG_SQL = true;
            QueryBuilder.LOG_VALUES = true;
        }
    }
    public DaoSession getDaoSession(){
        return daoSession;
    }
    public DaoMaster getDaoMaster(){
        return daoMaster;
    }
}

2-BaseApplication(用于获得Context)

public class  BaseApplication extends  Application
{
    private static Context mContext;

    public static Context getContext(){
        return mContext;
    }

    @Override
    public void onCreate()
    {
        mContext = getApplicationContext();
        super.onCreate();
    }

}

实体类Bean

注解
@Entity注解

  1. @Entity的作用

    1. @Entity注解标记了一个Java类作为greenDAO一个presistable实体。
    2. 简单理解为，他告诉GreenDao，要根据这个实体类去生成相应的Dao，方便我们去操作，
    3. 同样也相当于将我们的实体类和表做了关联。

  2. @Entity配置信息如下：

    @Entity(
    // 如果你有一个以上的模式，你可以告诉greendao实体属于哪个模式（选择任何字符串作为名称）。
    schema = "myschema",

    // 标志允许实体类可有更新，删除，刷新方法
    active = true,

    // 指定数据库中表的名称。默认情况下，该名称基于实体类名。
    nameInDb = "AWESOME_USERS",

    // 在这里定义多个列的索引
    indexes = {
            @Index(value = "name DESC", unique = true)
    },

    // 如果DAO创建数据库表(默认为true)，则设置标记去标识。如果有多个实体映射到一个表，或者在greenDAO之外创建表创建，将此设置为false。
    createInDb = false,

    // 是否应该生成所有的属性构造函数。一个无args构造函数总是需要的
    generateConstructors = true,

    // 是否生成属性的getter和setter
    generateGettersSetters = true
)
@Id注解
  1. @Id注解的作用
    1. 选择long / Long属性作为实体ID。
    2. 在数据库方面，它是主要的关键参数autoincrement 是使ID值不断增加的标志（不重复使用旧值-自增长）。

@Property
  1. @Property的作用
    1. 允许您定义属性映射到的非默认列名称。
    2. 如果缺少，greenDAO将以SQL-ish方式使用字段名称（大写字母，下划线而不是驼峰命名法，例如 customName将成为 CUSTOM_NAME）。注意：当前只能使用内联常量来指定列名。

@NotNull
  1. @NotNull的作用
    1. 该属性在数据库端成为“NOT NULL”列。
    2. 通常使用@NotNull标记原始类型（long，int，short，byte）是有意义的，而具有包装类（Long，Integer，Short，Byte））的可空值。

@Transient
  1. @Transient的作用
    1. 标记要从持久性排除的属性，使用这些临时状态等。或者，也可以使用来自Java 的transient关键字。

@Index

  1. @Index的作用

    1. 为相应的数据库列创建数据库索引
    2. 名称：如果不喜欢greenDAO为索引生成的默认名称，则可以在此处指定。
    3. 唯一：向索引添加UNIQUE约束，强制所有值都是唯一的。

  2. @Index的使用

    @Entity
public class User {
    @Id private Long id;
    @Index(unique = true)
    private String name;
}
@Unique

  1. @Unique的作用

    向数据库列添加了一个UNIQUE约束。请注意，SQLite还会隐式地为其创建索引。例子如下：

  2. @Unique的使用

    @Entity
public class User {
    @Id private Long id;
    @Unique private String name;
}
使用@Entity生成Bean
@Entity
public class VodInfoItemDBBean {
    @Id(autoincrement = true) private Long id;
    @Index(unique = true)
    private String programcode;
    private String programname;
    private String programtype;
    private String contentcode;
    private String seriesprogramcode;
    private String mediaservices;

    //XXX
    @Convert(columnType = String.class,converter = VideoInfoBeanConverter.class)
    private List<VideoInfoBean> videoInfo;

    public static class VideoInfoBeanConverter
            implements PropertyConverter<List<VideoInfoBean>, String>{

        @Override
        public List<VideoInfoBean> convertToEntityProperty(String s) {
            if(s == null){
                return null;
            }else{
                Gson gson = new Gson();
                Log.d("feather", "#convertToEntityProperty = " + s);
                List<String> jsonList = Arrays.asList(s.split("\\|"));
                List<VideoInfoBean> videoInfos = new ArrayList<>();
                for (String json : jsonList) {
                    VideoInfoBean infoBean = gson.fromJson(json, VideoInfoBean.class);
                    videoInfos.add(infoBean);
                }
                return videoInfos;
            }
        }

        @Override
        public String convertToDatabaseValue(List<VideoInfoBean> videoInfoBeen) {
            if (videoInfoBeen == null){
                return null;
            }else{
                Gson gson = new Gson();
                StringBuffer stringBuffer = new StringBuffer();
                for (VideoInfoBean infoBean : videoInfoBeen) {
                    String json = gson.toJson(infoBean);
                    stringBuffer.append(json);
                    stringBuffer.append("|");
                }
                String result = stringBuffer.toString();
                if(result.length() > 0){
                    Log.d("feather", "#convertToDatabaseValue = " + result.substring(0, result.length() - 1));
                    return result.substring(0, result.length() - 1);
                }else{
                    Log.d("feather", "#convertToDatabaseValue = " + result);
                    return result;
                }
            }
        }
    }


    public static class VideoInfoBean {
        /**
         * videocode : 00000050280000001985
         * mediaservice : 2
         * videotype : 28
         * definition : 2
         * videoelapsedtime :
         * encrypttype : 0
         */

        private String videocode;
        private String mediaservice;
        private String videotype;
        private String definition;
        private String videoelapsedtime;
        private String encrypttype;
    }
}
Bean的成员变量为List时该如何处理

  1. Bean的成员变量为List时该如何处理

    1. 使用@Convert注解
    2. 自定义PropertyConverter进行转换，将List转换为可以存储的如String等内容。

  2. 使用@Convert注解

      @Convert(columnType = String.class,converter = VideoInfoBeanConverter.class)
  private List<VideoInfoBean> videoInfo;

  3. 自定义PropertyConverter

    public static class VideoInfoBeanConverter
    implements PropertyConverter<List<VideoInfoBean>, String>{

  @Override
  public List<VideoInfoBean> convertToEntityProperty(String s) {
    if(s == null){
        return null;
    }else{
        Gson gson = new Gson();
        Log.d("feather", "#convertToEntityProperty = " + s);
        List<String> jsonList = Arrays.asList(s.split("~I"));
        List<VideoInfoBean> videoInfos = new ArrayList<>();
        for (String json : jsonList) {
            VideoInfoBean infoBean = gson.fromJson(json, VideoInfoBean.class);
            videoInfos.add(infoBean);
        }
        return videoInfos;
    }
  }

  @Override
  public String convertToDatabaseValue(List<VideoInfoBean> videoInfoBeen) {
    if (videoInfoBeen == null){
        return null;
    }else{
        Gson gson = new Gson();
        StringBuffer stringBuffer = new StringBuffer();
        for (VideoInfoBean infoBean : videoInfoBeen) {
            String json = gson.toJson(infoBean);
            stringBuffer.append(json);
            stringBuffer.append("|");
        }
        String result = stringBuffer.toString();
        if(result.length() > 0){
            Log.d("feather", "#convertToDatabaseValue = " + result.substring(0, result.length() - 1));
            return result.substring(0, result.length() - 1);
        }else{
            Log.d("feather", "#convertToDatabaseValue = " + result);
            return result;
        }
    }
  }
}
基本操作

1、获取操作的Dao(用于增删改查)

 VodInfoItemDBBeanDao vodInfoDao = GreenDaoManager.getInstance().getDaoSession().getVodInfoItemDBBeanDao();
插入
// 1. 直接插入
vodInfoDao.insert(infoItemDBBean);
// 2. 不存在就插入，存在则替换
vodInfoDao.insertOrReplace(infoItemDBBean);
删除
vodInfoDao.delete(infoItemDBBean);
更新
vodInfoDao.update(infoItemDBBean);
查询
// 1、查询单个数据
VodInfoItemDBBean bean
        = vodInfoDao.queryBuilder()
        .where(VodInfoItemDBBeanDao.Properties.Programcode.eq(infoItemDBBean.getProgramcode()))
        .unique();

// 2、查询一组数据
List<VodInfoItemDBBean> tempQueryList
        = vodInfoDao.queryBuilder()
        .where(VodInfoItemDBBeanDao.Properties.Programcode.eq(infoItemDBBean.getProgramcode()))
        .list();

数据库升级

1、什么时候需要版本升级更新？

当数据库需要新增一个字段或者改变某些字段的属性时，就会需要更新。

2、数据更新的实现思路

  1. 首先创建临时表（数据格式和原表一模一样）。
  2. 把当前表的数据插入到临时表中去。
  3. 删除掉原表，创建新表。
  4. 把临时表数据插入到新表中去，然后删除临时表。
数据库升级的具体方法

3、数据库升级的实例

1-使用升级辅助类-MigrationHelper

import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.support.annotation.NonNull;
import android.text.TextUtils;
import android.util.Log;

import org.greenrobot.greendao.AbstractDao;
import org.greenrobot.greendao.database.Database;
import org.greenrobot.greendao.database.StandardDatabase;
import org.greenrobot.greendao.internal.DaoConfig;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MigrationHelper {
    public static boolean DEBUG = false;
    private static String TAG = "MigrationHelper2";
    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) {
        printLog("【The Old Database Version】" + db.getVersion());
        Database database = new StandardDatabase(db);
        migrate(database, daoClasses);
    }

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

        dropAllTables(database, true, daoClasses);
        createAllTables(database, false, daoClasses);

        printLog("【Restore data】start");
        restoreData(database, daoClasses);
        printLog("【Restore data】complete");
    }

    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)) {
                printLog("【New Table】" + tableName);
                continue;
            }
            try {
                tempTableName = daoConfig.tablename.concat("_TEMP");
                StringBuilder dropTableStringBuilder = new StringBuilder();
                dropTableStringBuilder.append("DROP TABLE IF EXISTS ").append(tempTableName).append(";");
                db.execSQL(dropTableStringBuilder.toString());

                StringBuilder insertTableStringBuilder = new StringBuilder();
                insertTableStringBuilder.append("CREATE TEMPORARY TABLE ").append(tempTableName);
                insertTableStringBuilder.append(" AS SELECT * FROM ").append(tableName).append(";");
                db.execSQL(insertTableStringBuilder.toString());
                printLog("【Table】" + tableName +"\n ---Columns-->"+getColumnsStr(daoConfig));
                printLog("【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 dropAllTables(Database db, boolean ifExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
        reflectMethod(db, "dropTable", ifExists, daoClasses);
        printLog("【Drop all table】");
    }

    private static void createAllTables(Database db, boolean ifNotExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
        reflectMethod(db, "createTable", ifNotExists, daoClasses);
        printLog("【Create all table】");
    }

    /**
     * dao class already define the sql exec method, so just invoke it
     */
    private static void reflectMethod(Database db, String methodName, boolean isExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
        if (daoClasses.length < 1) {
            return;
        }
        try {
            for (Class cls : daoClasses) {
                Method method = cls.getDeclaredMethod(methodName, Database.class, boolean.class);
                method.invoke(null, db, isExists);
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    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(";");
                    db.execSQL(insertTableStringBuilder.toString());
                    printLog("【Restore data】 to " + tableName);
                }
                StringBuilder dropTableStringBuilder = new StringBuilder();
                dropTableStringBuilder.append("DROP TABLE ").append(tempTableName);
                db.execSQL(dropTableStringBuilder.toString());
                printLog("【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;
    }

    private static void printLog(String info){
        if(DEBUG){
            Log.d(TAG, info);
        }
    }

}

2-自定义类继承DaoMaster.OpenHelper-onUpgrade()会在数据库版本提升时调用。

/**
 *  1. 自定义  MySQLiteOpenHelper继承  DaoMaster.OpenHelper
 *  2. 重写更新数据库的方法
 *  3. 当app下的build.gradle  的schemaVersion数据库的版本号改变时，创建数据库会调用onUpgrade更细数据库的方法
 */
public class MySQLiteOpenHelper extends DaoMaster.OpenHelper {
    /**
     * @param context 上下文
     * @param name    原来定义的数据库的名字   新旧数据库一致
     * @param factory 可以null
     */
    public MySQLiteOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
        super(context, name, factory);
    }

    /**
     * @param db
     * @param oldVersion
     * @param newVersion 更新数据库的时候自己调用
     */
    @Override
    public void onUpgrade(Database db, int oldVersion, int newVersion) {
        Log.d("flag", "onUpgrade oldVersion=" + oldVersion+" newVersion="+newVersion);
        /**
         *  将db传入, 将目录下的所有的Dao.类传入
         */
        MigrationHelper.migrate(db, StudentDao.class, VodInfoItemDBBeanDao.class);
    }
}

3-更改Bean或者创建Bean
4-在build中make Project后将生成的Dao文件添加到MySQLiteOpenHelper的migrate(db, ..., NewBeanDao.class)中
5-更改app目录下build.gradle的数据库版本号

greendao {
    schemaVersion 2 //提升了版本号
    targetGenDir 'src'
    daoPackage 'com.zte.iptvclient.android.greendao' //
}

6-进行更新(需要新旧数据库的名称一致)

MySQLiteOpenHelper helper = new MySQLiteOpenHelper(this,"MyGreenDb.db",null);
DaoMaster daoMaster = new DaoMaster(helper.getWritableDatabase());
猎羽
关注
专栏目录
GreenDao保存实体类套实体类
02-26
GreenDao保存实体类套实体类仿照网上demo自己改动的，其实主要想获得点积分
Android ORM 框架 GreenDao 使用详解，android简历项目经验
m0_64382743的博客
12-04 785
写完上面实体类代码之后，接下来实体类代码的生成就交给 Android Studio 编译器就可以了，首先我们点击菜单栏中 Build 然后点击 Make Project，等待编译器编译完就可以了，编译完后实体类代码如下所示：(这里实现了 Parcelable 接口是为了在 Activity 之间传递实体类，实现接口的方法一直 Alt + Enter 就可以了) @Entity public class GoodsModel implements Parcelable { @Id(autoincrement
GreenDAO 使用教程
最新发布
gitblog_01174的博客
08-15 631
GreenDAO 使用教程 greenDAOGreenDAO是一个针对Android平台设计的轻量级ORM库，用来简化SQLite数据库的操作，提供了高效的对象关系映射功能，提高了Android应用的数据访问性能。项目地址:https://gitcode.com/gh_mirrors/gr/greenDAO 项目介绍 GreenDAO 是一个轻量级且快速的 ORM（对象/关系映射）解决方案，专门...
greendao3.0的引入
ljngya的博客
12-22 542
greenDao 3的引入
greendao
lishuaileibo的博客
01-26 365
在project里面导入 classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' 然后在module的gradle文件中添加greenDAO的插件，并引入相关类库， apply plugin: 'org.greenrobot.greendao' compile 'org.greenrobot:greenda
greenDAO
03-16
**greenDAO：Android ORM框架详解** 绿色DAO（greenDAO）是一个专门为Android平台设计的对象关系映射（ORM）框架，它简化了在SQLite数据库中存储和操作对象的过程。ORM框架允许开发者使用面向对象的方式处理数据库...
android 的Greendao使用demo，供初学者使用
03-03
Android的GreenDao是一个轻量级的对象关系映射（ORM）框架，专为移动开发而设计，使得在Android应用中操作数据库变得更为简单。这个“android的GreenDao使用demo”是为初学者准备的一个实例，旨在帮助理解并快速上手...
greenDAO的使用工具类封装
04-06
**绿色DAO（greenDAO）是Android平台上一个流行的ORM（对象关系映射）库，它允许开发者将数据库操作转换为面向对象的方式，简化了Android应用中的数据存储和查询工作。在这个项目“greenDAO的使用工具类封装”中，...
Android greenDAO 数据库 简单学习之基本使用
05-07
**Android greenDAO 数据库 简单学习之基本使用** 在Android开发中，数据库操作是不可或缺的一部分，而greenDAO作为一款高效、轻量级的对象关系映射（ORM）框架，可以简化我们对SQLite数据库的操作。它允许开发者...
GreenDao 3.0 使用详解之注解实体类
fengltxx的博客
12-17 8777
GreenDao 3.0 使用详解之注解实体类 ONE Goal , ONE Passion ! Modelling entities 实体模型To use greenDAO in a project you create an entity model representing the persistent data in your a
GreenDao打印SQL执行日志
weixin_37999256的博客
03-22 2951
在使用greendao的时候，SQL查询不是想要的结果，想看看执行的SQL是什么，只需要开启QueryBuilder的两个属性即可: QueryBuilder.LOG_SQL = true; QueryBuilder.LOG_VALUES = true; ...
Android ORM 框架之 greenDAO
是阿超
01-25 2636
Android ORM 框架之 greenDAO
greendao使用记录
haizhuo的博客
05-22 405
简介 greenDAO是Android的对象/关系映射（ORM）工具。 它为关系数据库SQLite提供了一个面向对象的接口。像greenDAO一类的ORM工具为你做很多重复性的任务，提供简单的数据接口。 添加依赖 工程目录下build.gradle buildscript { repositories { mavenCentral() } dependencies { classpath 'org.greenrobot:greendao-grad
使用GreenDao出现:unique constraint failed解
sgilec的专栏
04-01 7094
集成GreenDao,inserty一个Entity会出现greendao unique constraint failed错误. 1.首先entity中需要存在一个Long类型的主键(@Id(autoincrement = true) private long id;) 2.在entity的构造方法中置id = null.
AndriodGreenDao的使用
曾今一脸懵逼的萌新走向大神之路
07-10 274
一、修改build.gradle文件：    apply plugin: 'com.android.application'//配置GreenDao插件apply plugin: 'org.greenrobot.greendao'android {    compileSdkVersion 26    defaultConfig {        applicationId "com.liangx...
Greendao 不写入数据表 的字段加 ：@Transient
Jason_HD的博客
04-25 5006
Greendao 不写入数据表 的字段加 ：@Transient
Android数据库操作实践：使用GreenDao框架
资源摘要信息:"安卓GreenDao使用.rar" 知识点: 1. 安卓GreenDao介绍: GreenDao是一个开源的Android数据库框架，它基于SQLite数据库。它的主要优点是使用简单，性能高效，可以和ORM(Object-Relational Mapping，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猎羽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值