GreenDao讲解与使用

学习参考资料：https://blog.csdn.net/speedystone/article/details/72769793

“GreenDAO 是一款开源的面向 Android 的轻便、快捷的 ORM 框架，将 Java 对象映射到 SQLite 数据库中，我们操作数据库的时候，不在需要编写复杂的 SQL语句， 在性能方面，GreenDAO 针对 Android 进行了高度优化， 最小的内存开销 、依赖体积小 同时还是支持数据库加密。”

优点：

官网中明确指明了其首要设计目标:
Maximum performance (probably the fastest ORM for Android):系能最大化
Easy to use APIs：便于使用
Highly optimized for Android：对于Android高度优化
Minimal memory consumption：最小化内存开销
Small library size, focus on the essentials：较小的文件体积，只集中在必要的部分上。

1.ORM（Object Relational Mapping）对象关系映射，可以非常便捷的将Java 对象映射到 SQLite 数据库中保存。

2.高性能：官网测试结果：插入和更新的速度是sqlite的2倍，加载实体的速度是ormlite的4.5倍

image.png

3.支持加密

4.轻量级：GreenDao 核心库小于100k ，所以我们并不会担心添加 GreenDao 后 APK 大小会变的是否庞大。

5.支持 protocol buffer(protobuf) 协议：GreenDao 支持 protocol buffer(protobuf) 协议数据的直接存储，如果你通过 protobuf 协议与服务器交互，将不需要任何的映射。

6.代码生成：greenDAO 会根据配置信息自动生成核心管理类以及 DAO 对象

7.开源

核心关系：

image.png

集成：
a、设置仓库与插件（Project： build.gradle）

buildscript {
    repositories {
        jcenter()
        mavenCentral() // add repository
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.3.2'
        classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' // add plugin
    }
}

b、 配置依赖 ( Module:app build.gradle )

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

dependencies {
    compile 'org.greenrobot:greendao:3.2.2' // add library

    // This is only needed if you want to use encrypted databases
    compile 'net.zetetic:android-database-sqlcipher:3.5.6'//加密库依赖（可选项）
}

c、 配置数据库相关信息 ( Module:app build.gradle )

greendao {
    schemaVersion 1 //数据库版本号
    daoPackage 'com.speedystone.greendaodemo.db'// 设置DaoMaster、DaoSession、Dao 包名
    targetGenDir 'src/main/java'//设置DaoMaster、DaoSession、Dao目录
}

d、点击 ： Sync Project with Gradle Files 按钮，同步一下工程 ， 配置完成

使用方法：

@Entity
public class User {
    @Id(autoincrement = true)
    private Long id;
    //这里设置Long并自增，这在创建对象时，id设置为null可以交给数据库自己去自增
    //如果设置为long则需要传值，并不能自增了

    @Unique
    //该属性数据库里只能有唯一值
    private String name;

    @Property(nameInDb = "age")
    //这里表示此参数在数据库中的表结构名称为“age”,否则默认为“AGE”大写
    private int age;
    
    ... ...
}

点击 Make Project（或者 Make Moudle ‘App’） 编译一下工程 。如果配置正确，会在配置的包目录下自动会生成 DaoMaster，DaoSession 和 UserDao 类 。

初始化：

public class MyApp extends Application {

    private DaoSession daoSession;

    @Override
    public void onCreate() {
        super.onCreate();
        initGreenDao();
    }

    /**
     * 初始化Dao
     */
    private void initGreenDao() {
        //这里采用自定义的OpenHelper
        DbHelper helper = new DbHelper(this, "test,db");
//        DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "test.db");
        SQLiteDatabase db = helper.getWritableDatabase();
//        加密数据库
//        Database db = helper.getEncryptedReadableDb("123456");
        DaoMaster daoMaster = new DaoMaster(db);
        daoSession = daoMaster.newSession();


    }

    /**
     * 获取dao实例
     * @return
     */
    public DaoSession getDaoSession(){
        return daoSession;
    }
}

自定义OpenHelper

public class DbHelper extends DaoMaster.DevOpenHelper {
    public DbHelper(Context context, String name) {
        super(context, name);
    }

    public DbHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
        super(context, name, factory);
    }

    @Override
    public void onUpgrade(Database db, int oldVersion, int newVersion) {
        super.onUpgrade(db, oldVersion, newVersion);
        Log.i("greenDAO", "Upgrading schema from version " + oldVersion + " to " + newVersion );
        if(newVersion == 2){
            // 修改 USER 表
            //这里添加升级数据库后修改的表结构
            db.execSQL("ALTER TABLE 'USER' ADD  'NICKNAME' String");
        }
    }
}

操作方法：

public class MainActivity extends AppCompatActivity
        implements NavigationView.OnNavigationItemSelectedListener {

    private  UserDao userDao;
    private  String  TAG = "greenDaoDemo";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initView();
        initDao();
        initData();
        QueryBuilder.LOG_SQL = true;
        QueryBuilder.LOG_VALUES = true;
    }

    /**
     * 懒加载
     */
    public void lazyInit(){
        LazyList<User> users = userDao.queryBuilder().listLazy();
        for(User u :users){
            Log.i(TAG,"用户名："+u.getName());
        }
    }

    /**
     * 分页查询
     * @return
     */
    public List<User> pageQuery(){
//        从第二条数据开始查5条
        return userDao.queryBuilder().offset(2).limit(5).list();
    }

    public void insertOrResplace(User user){
        userDao.insertOrReplace(user);
    }

    public void delete(User user){
        userDao.delete(user);
    }

    public void deleteByUserId(long id){
        userDao.deleteByKey(id);
    }

    public void updata(User user){
        userDao.update(user);
    }

    public List<User> queryAll(){
        return userDao.loadAll();//查询所有记录
    }

    public User queryById(long id){
        return userDao.loadByRowId(id);
    }

    public List<User> query10(){
        return  userDao.queryRaw("AEG>?","10");
    }

    public List<User> query102(){
        QueryBuilder<User> builder = userDao.queryBuilder();
        return  builder.where(UserDao.Properties.Age.gt(10)).build().list();
    }

    private void initData() {
        User user = new User(null,"小明",16);
//        user.setId(Null);
//        user.setName("小明");
//        user.setAge(16);
        userDao.insert(user);
    }

    private void initDao() {
        MyApp application = (MyApp) getApplication();
        DaoSession daoSession = application.getDaoSession();
        userDao = daoSession.getUserDao();
    }

    ... ...

注解：
@Entity
表明这个实体类会在数据库中生成一个与之相对应的表

属性：

schema：告知GreenDao当前实体属于哪个 schema
schema active：标记一个实体处于活跃状态，活动实体有更新、删除和刷新方法
nameInDb：在数据库中使用的别名，默认使用的是实体的类名，
indexes：定义索引，可以跨越多个列
createInDb：标记创建数据库表（默认：true）
generateConstructors 自动创建全参构造方法（同时会生成一个无参构造方法）（默认：true）
generateGettersSetters 自动生成 getters and setters 方法（默认：true）

@Entity(
        schema = "myschema",
        active = true,
        nameInDb = "AWESOME_USERS"，
        indexes = {
                @Index(value = "name DESC", unique = true)
        },
        createInDb = true,
        generateConstructors = false,
        generateGettersSetters = true
)
public class User {
  ...
}

@Id

对应数据表中的 Id 字段

@Index

使用@Index作为一个属性来创建一个索引，默认是使用字段名
@Property

设置一个非默认关系映射所对应的列名，默认是使用字段名,例如：@Property(nameInDb = “userName”)

@NotNull

设置数据库表当前列不能为空

@Transient

添加此标记后不会生成数据库表的列

@Unique

表名该属性在数据库中只能有唯一值

@ToOne

表示一对一关系

@Entity
public class Order {

    @Id
    private long id;

    private long customerId;

    @ToOne(joinProperty = "customerId")
    //一对一关系
    private Customer customer;

    ... ...

@OrderBy

更加某一字段排序 ，例如：@OrderBy(“date ASC”)

@ToMany

定义一对多个实体对象的关系

@Entity
public class Customer {
    @Id private Long id;

    @ToMany(referencedJoinProperty = "customerId")
    @OrderBy("date ASC")
    private List<Order> orders;
}

@Entity
public class Order {
    @Id private Long id;
    private Date date;
    private long customerId;
}

通过 @Convert 注解转换数据类型
例如：将枚举类型转换成整形

@Entity
public class User {
    @Id
    private Long id;

    @Convert(converter = RoleConverter.class, columnType = Integer.class)
    private Role role;

    public enum Role {
        DEFAULT(0), AUTHOR(1), ADMIN(2);

        final int id;

        Role(int id) {
            this.id = id;
        }
    }

    public static class RoleConverter implements PropertyConverter<Role, Integer> {
        @Override
        public Role convertToEntityProperty(Integer databaseValue) {
            if (databaseValue == null) {
                return null;
            }
            for (Role role : Role.values()) {
                if (role.id == databaseValue) {
                    return role;
                }
            }
            return Role.DEFAULT;
        }

        @Override
        public Integer convertToDatabaseValue(Role entityProperty) {
            return entityProperty == null ? null : entityProperty.id;
        }
    }

混淆配置：

### greenDAO 3
-keepclassmembers class * extends org.greenrobot.greendao.AbstractDao {
public static java.lang.String TABLENAME;
}
-keep class **$Properties

# If you do not use SQLCipher:
-dontwarn org.greenrobot.greendao.database.**
# If you do not use RxJava:
-dontwarn rx.**

### greenDAO 2
-keepclassmembers class * extends de.greenrobot.dao.AbstractDao {
public static java.lang.String TABLENAME;
}
-keep class **$Properties