GreenDao 3.X之基本使用

        在 GreenDao 3.X之注解已经了解到GreenDao 3.0的改动及注解。对于数据库的操作,无异于增删改查等四个操作。下面我们将了解GreenDao 3.X如何使用?

AbstractDao

    所有的自动生成的XXDao都是继承于AbstractDao,此类中基本上封装了所有的增删改操作,包括数据库的事务操作。常用的API如下:

	void 	attachEntity(T entity):
	
	long 	count():获取数据库中数据的数量
	
	// 数据删除相关
	void 	delete(T entity):从数据库中删除给定的实体
	void 	deleteAll() :删除数据库中全部数据
	void 	deleteByKey(K key):从数据库中删除给定Key所对应的实体
	void 	deleteByKeyInTx(java.lang.Iterable<K> keys):使用事务操作删除数据库中给定的所有key所对应的实体
	void 	deleteByKeyInTx(K... keys):使用事务操作删除数据库中给定的所有key所对应的实体
	void 	deleteInTx(java.lang.Iterable<T> entities):使用事务操作删除数据库中给定实体集合中的实体
	void 	deleteInTx(T... entities):使用事务操作删除数据库中给定的实体
	
	// 数据插入相关
	long 	insert(T entity):将给定的实体插入数据库
	void 	insertInTx(java.lang.Iterable<T> entities):使用事务操作,将给定的实体集合插入数据库
	void 	insertInTx(java.lang.Iterable<T> entities, boolean setPrimaryKey):使用事务操作,将给定的实体集合插入数据库,
																													并设置是否设定主键
	void 	insertInTx(T... entities):将给定的实体插入数据库
	long 	insertOrReplace(T entity):将给定的实体插入数据库,若此实体类存在,则覆盖
	void 	insertOrReplaceInTx(java.lang.Iterable<T> entities):使用事务操作,将给定的实体插入数据库,若此实体类存在,则覆盖
	void 	insertOrReplaceInTx(java.lang.Iterable<T> entities, boolean setPrimaryKey):使用事务操作,将给定的实体插入数据库,若此实体类存在,则覆盖
																																并设置是否设定主键
	void 	insertOrReplaceInTx(T... entities):使用事务操作,将给定的实体插入数据库,若此实体类存在,则覆盖
	long 	insertWithoutSettingPk(T entity):将给定的实体插入数据库,但不设定主键
	
	// 新增数据插入相关API
	void 	save(T entity):将给定的实体插入数据库,若此实体类存在,则更新
	void 	saveInTx(java.lang.Iterable<T> entities):将给定的实体插入数据库,若此实体类存在,则更新
	void 	saveInTx(T... entities):使用事务操作,将给定的实体插入数据库,若此实体类存在,则更新
	
	// 加载相关
	T 	load(K key):加载给定主键的实体
	java.util.List<T> 	loadAll():加载数据库中所有的实体
	protected java.util.List<T> 	loadAllAndCloseCursor(android.database.Cursor cursor) :从cursor中读取、返回实体的列表,并关闭该cursor
	protected java.util.List<T> 	loadAllFromCursor(android.database.Cursor cursor):从cursor中读取、返回实体的列表
	T 	loadByRowId(long rowId) :加载某一行并返回该行的实体
	protected T 	loadUnique(android.database.Cursor cursor) :从cursor中读取、返回唯一实体
	protected T 	loadUniqueAndCloseCursor(android.database.Cursor cursor) :从cursor中读取、返回唯一实体,并关闭该cursor

	//更新数据
	void 	update(T entity) :更新给定的实体
	protected void 	updateInsideSynchronized(T entity, DatabaseStatement stmt, boolean lock) 
	protected void 	updateInsideSynchronized(T entity, android.database.sqlite.SQLiteStatement stmt, boolean lock) 
	void 	updateInTx(java.lang.Iterable<T> entities) :使用事务操作,更新给定的实体
	void 	updateInTx(T... entities):使用事务操作,更新给定的实体

QueryBuilder、Query

基本查询

        GreenDao中,使用QueryBuilder自定义查询实体,而不是再写繁琐的SQL语句,避免了SQL语句的出错率。大家都知道写SQL语句时,非常容易出错,出错后又十分的难查。QueryBuilder真是帮忙解决了一个大麻烦。具体该如何使用呢?

    List joes = userDao.queryBuilder()
                       // 查询的条件
                       .where(Properties.FirstName.eq("Joe"))
                       // 返回实体集合升序排列
                       .orderAsc(Properties.LastName)
                       .list();
    QueryBuilder qb = userDao.queryBuilder();
    // 查询的条件
    qb.where(Properties.FirstName.eq("Joe"),
    qb.or(Properties.YearOfBirth.gt(1970),
    qb.and(Properties.YearOfBirth.eq(1970), Properties.MonthOfBirth.ge(10))));
    List youngJoes = qb.list();    </span>
        上面是官方给出的两个列子,不仅满足了查询语句的易写,同时使用了流式写法,提高了代码的可阅读性。

Limit、Offset、Pagination

        在实际开发过程中,大家肯定碰到这样的问题,当数据过多在一页显示不出来的时候,要么选择前面十条显示,要么分页显示,但是数据总是获取全部的。其实,刚接触GreenDao的时候,也是这么干,获取全部的实体集合,然后再根据实际情况截取。看了API以后,豁然开朗,大神们已经帮我们解决了这件事。此时不得不说,QueryBuilder
中的Limit(限制)、Offset(偏移),limit(int)和offset(int)协同设置,可以完美解决分页显示。

        limit(int):限制查询返回结果的数目
        offset(int):设置查询结果的偏移量,此查询需与limit(int)结合使用,而不能够脱离limit(int)单独使用

Query

        当执行多次查询时,实际是QueryBuilder多次调用Query类。如果执行多次相同的查询,应使用QueryBuilder的build()方法来创建Query,而不是直接使用Query类。如果查询返回的结果是唯一性的,可以使用操作符方法,如果不希望此唯一性不返回 null,此时可调用uniqOrThrow()方法。如果查询返回的结果是多个,可以使返回的结果是一个集合,有如下方法:

    list():所有实体加载至内存,结果通常是一个ArrayList
    listLazy():实体在需要时,加载至内存,表中的第一个元素被第一次访问时会被缓存,下次访问时,使用缓存
    listLazyUncached():任何对列表实体的访问懂事从数据库中加载
    listIterator():以按需加载的方式来遍历结果,数据没有被缓存
         一旦使用QueryBuilder创建了一个query,那么这个Query对象就可以就可以被复用来执行查询显然这种方式逼重新创建一次Query效率要高。
        具体来说:

        如果Query的参数没有变更,你只需要再次调用List/unuque方法即可
        如果参数发生了变化,那么就需要通过setParameter方法来处理每一个发生改变的参数
        举例:
    Query query = userDao.queryBuilder().where(Properties.FirstName.eq("Joe"), Properties.YearOfBirth.eq(1970)).build();
    List joesOf1970 = query.list();

        现在复用该Query对象:

    query.setParameter(0, "Maria");
    query.setParameter(1, 1977);
    List mariasOf1977 = query.list();

        由此可见,Query在执行一次build之后会将查询结果进行缓存,方便下次继续使用。

执行原生SQL语句


    两种方法:

    Query query = userDao.queryBuilder().where(
    new StringCondition("_ID IN " +
    "(SELECT USER_ID FROM USER_MESSAGE WHERE READ_FLAG = 0)").build();
        如果这里的QueryBuilder没有提供你想要的特性,可以使用原始的queryRaw或queryRawCreate方法。

    Query query = userDao.queryRawCreate(  ", GROUP G WHERE G.NAME=? AND T.GROUP_ID=G._ID", "admin");
        注:写SQL语句时推荐定义常量来表示表名或者表项,这样可以防止出错,因为编译器会检查

基本使用

创建实体类

@Entity(generateConstructors = false)
public class Student {
    @Id
    private Long id;
    private String name;
    private int age;

    public Student() {
    }

    @Keep
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }


    public Student(Long id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    @Keep
    public Long getId() {
        return id;
    }

    @Keep
    public void setId(Long id) {
        this.id = id;
    }

    @Keep
    public String getName() {
        return name;
    }

    @Keep
    public void setName(String name) {
        this.name = name;
    }

    @Keep
    public int getAge() {
        return age;
    }

    @Keep
    public void setAge(int age) {
        this.age = age;
    }

    @Keep
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;

        Student student = (Student) o;

        return name.equals(student.name);

    }

    @Keep
    @Override
    public int hashCode() {
        return (int) (id ^ (id >>> 32));
    }

    @Keep
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
        创建完实体类后,Rebuild Project生成DaoMaster、DaoSession。DaoMaster、DaoSession位于在Gradle设置的目录及文件夹里。



创建Database管理类

public class DbManager {

    // 是否加密
    public static final boolean ENCRYPTED = true;

    private static final String DB_NAME = "tea.db";
    private static DbManager mDbManager;
    private static DaoMaster.DevOpenHelper mDevOpenHelper;
    private static DaoMaster mDaoMaster;
    private static DaoSession mDaoSession;

    private Context mContext;

    private DbManager(Context context) {
        this.mContext = context;
        // 初始化数据库信息
        mDevOpenHelper = new DaoMaster.DevOpenHelper(context, DB_NAME);
        getDaoMaster(context);
        getDaoSession(context);
    }

    public static DbManager getInstance(Context context) {
        if (null == mDbManager) {
            synchronized (DbManager.class) {
                if (null == mDbManager) {
                    mDbManager = new DbManager(context);
                }
            }
        }
        return mDbManager;
    }

    /**
     * @desc 获取可读数据库
     * @autor Tiany
     * @time 2016/8/13
     **/
    public static SQLiteDatabase getReadableDatabase(Context context) {
        if (null == mDevOpenHelper) {
            getInstance(context);
        }
        return mDevOpenHelper.getReadableDatabase();
    }

    /**
     * @desc 获取可写数据库
     * @autor Tiany
     * @time 2016/8/13
     **/
    public static SQLiteDatabase getWritableDatabase(Context context) {
        if (null == mDevOpenHelper) {
            getInstance(context);
        }
        return mDevOpenHelper.getWritableDatabase();
    }

    /**
     * @desc 获取DaoMaster
     * @autor Tiany
     * @time 2016/8/13
     **/
    public static DaoMaster getDaoMaster(Context context) {
        if (null == mDaoMaster) {
            synchronized (DbManager.class) {
                if (null == mDaoMaster) {
                    mDaoMaster = new DaoMaster(getWritableDatabase(context));
                }
            }
        }
        return mDaoMaster;
    }

    /**
     * @desc 获取DaoSession
     * @autor Tiany
     * @time 2016/8/13
     **/
    public static DaoSession getDaoSession(Context context) {
        if (null == mDaoSession) {
            synchronized (DbManager.class) {
                mDaoSession = getDaoMaster(context).newSession();
            }
        }

        return mDaoSession;
    }
}

数据库操作类

public class StudentDaoOpe {

    /**
     * @desc 添加数据至数据库
     * @autor Tiany
     * @time 2016/8/13
     **/
    public static void insertData(Context context, Student stu) {

        DbManager.getDaoSession(context).getStudentDao().insert(stu);
    }

    /**
     * @desc 将数据实体通过事务添加至数据库
     * @autor Tiany
     * @time 2016/8/13
     **/
    public static void insertData(Context context, List<Student> list) {
        if (null == list || list.size() <= 0) {
            return;
        }
        DbManager.getDaoSession(context).getStudentDao().insertInTx(list);
    }

    /**
     * @desc 添加数据至数据库,如果存在,将原来的数据覆盖
     * @autor Tiany
     * @time 2016/8/15
     **/
    public static void saveData(Context context, Student student) {
        DbManager.getDaoSession(context).getStudentDao().save(student);
    }

    /**
     * @desc 查询所有数据
     * @autor Tiany
     * @time 2016/8/15
     **/
    public static List<Student> queryAll(Context context) {
        QueryBuilder<Student> builder = DbManager.getDaoSession(context).getStudentDao().queryBuilder();

        return builder.build().list();
    }
}

        到此为止,数据库的基本操作已完成,根据实际需求笤俑数据库操作类相应的操作即可。

       现流行RxJava异步及流式开发,GreenDao已将RxJava集成,具体的使用见

参考文档

        1、官方文档

        2.、GreenDAO 3.0 初次使用


评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值