android：kotlin语言使用greendao3.0简解

先看效果

步骤一、在自己的build.gradle中加入这些配置

apply plugin: 'org.greenrobot.greendao'

greendao {
//数据库的schema版本，也可以理解为数据库版本号
schemaVersion 1
//设置DaoMaster、DaoSession、Dao包名，也就是要放置这些类的包的全路径。
daoPackage 'tsou.com.simple.greendaoforkotlin.greendao'
//设置DaoMaster、DaoSession、Dao目录
targetGenDir 'src/main/java'
}
dependencies

compile 'org.greenrobot:greendao:3.2.0'
}

buildscript {
ext.kotlin_version = '1.1.50'
repositories {
mavenCentral()
google()
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.0.0-beta7'
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
classpath 'org.greenrobot:greendao-gradle-plugin:3.2.0'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}

步骤二、创建Student实体类

package tsou.com.simple.greendaoforkotlin.bean;

import android.support.annotation.Keep;

import org.greenrobot.greendao.annotation.Entity;
import org.greenrobot.greendao.annotation.Id;
import org.greenrobot.greendao.annotation.Generated;

@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 +
'}';
}
}

步骤三、修复一下工程，自动生成greendao包下的类（就是点击一下小锤子），你会自动生成greendao包中的类。

步骤四、开始使用，创建管理类

package tsou.com.simple.greendaoforkotlin.manager

import android.content.Context
import android.database.sqlite.SQLiteDatabase
import tsou.com.simple.greendaoforkotlin.greendao.DaoMaster
import tsou.com.simple.greendaoforkotlin.greendao.DaoSession

class DbManager private constructor(mContext: Context) {

private val DB_NAME = "test.db"
private var mDevOpenHelper: DaoMaster.DevOpenHelper? = null
private var mDaoMaster: DaoMaster? = null
private var mDaoSession: DaoSession? = null

init {
// 初始化数据库信息
mDevOpenHelper = DaoMaster.DevOpenHelper(mContext, DB_NAME)
getDaoMaster(mContext)
getDaoSession(mContext)
}

companion object {
@Volatile
var instance: DbManager? = null

fun getInstance(mContext: Context): DbManager? {
if (instance == null) {
synchronized(DbManager::class) {
if (instance == null) {
instance = DbManager(mContext)
}
}
}
return instance
}
}

/**
* 获取可读数据库
*
* @param context
* @return
*/
fun getReadableDatabase(context: Context): SQLiteDatabase? {
if (null == mDevOpenHelper) {
getInstance(context)
}
return mDevOpenHelper?.getReadableDatabase()
}

/**
* 获取可写数据库
*
* @param context
* @return
*/
fun getWritableDatabase(context: Context): SQLiteDatabase? {
if (null == mDevOpenHelper) {
getInstance(context)
}

return mDevOpenHelper?.getWritableDatabase()
}

/**
* 获取DaoMaster
*
* @param context
* @return
*/
fun getDaoMaster(context: Context): DaoMaster? {
if (null == mDaoMaster) {
synchronized(DbManager::class.java) {
if (null == mDaoMaster) {
mDaoMaster = DaoMaster(getWritableDatabase(context))
}
}
}
return mDaoMaster
}

/**
* 获取DaoSession
*
* @param context
* @return
*/
fun getDaoSession(context: Context): DaoSession? {
if (null == mDaoSession) {
synchronized(DbManager::class.java) {
mDaoSession = getDaoMaster(context)?.newSession()
}
}

return mDaoSession
}
}

步骤五、增删改查，

package tsou.com.simple.greendaoforkotlin.dao

import android.content.Context
import tsou.com.simple.greendaoforkotlin.bean.Student
import tsou.com.simple.greendaoforkotlin.greendao.StudentDao
import tsou.com.simple.greendaoforkotlin.manager.DbManager

class StudentDaoOpe private constructor() {

private object mHolder {
val instance = StudentDaoOpe()
}

companion object {
fun getInstance(): StudentDaoOpe {
return mHolder.instance
}
}

/**
* 添加数据至数据库

* @param context
* *
* @param stu
*/
fun insertData(context: Context?, stu: Student) {

DbManager.getInstance(context!!)?.getDaoSession(context)?.getStudentDao()?.insert(stu)
}

/**
* 将数据实体通过事务添加至数据库

* @param context
* *
* @param list
*/
fun insertData(context: Context?, list: List<Student>?) {
if (null == list || list.size <= 0) {
return
}
DbManager.getInstance(context!!)?.getDaoSession(context)?.getStudentDao()?.insertInTx(list)
}

/**
* 添加数据至数据库，如果存在，将原来的数据覆盖
* 内部代码判断了如果存在就update(entity);不存在就insert(entity)；

* @param context
* *
* @param student
*/
fun saveData(context: Context?, student: Student) {
DbManager.getInstance(context!!)?.getDaoSession(context)?.getStudentDao()?.save(student)
}

/**
* 删除数据至数据库

* @param context
* *
* @param student 删除具体内容
*/
fun deleteData(context: Context?, student: Student) {
DbManager.getInstance(context!!)?.getDaoSession(context)?.getStudentDao()?.delete(student)
}

/**
* 根据id删除数据至数据库

* @param context
* *
* @param id      删除具体内容
*/
fun deleteByKeyData(context: Context?, id: Long) {
DbManager.getInstance(context!!)?.getDaoSession(context)?.getStudentDao()?.deleteByKey(id)
}

/**
* 删除全部数据

* @param context
*/
fun deleteAllData(context: Context?) {
DbManager.getInstance(context!!)?.getDaoSession(context)?.getStudentDao()?.deleteAll()
}

/**
* 更新数据库

* @param context
* *
* @param student
*/
fun updateData(context: Context?, student: Student) {
DbManager.getInstance(context!!)?.getDaoSession(context)?.getStudentDao()?.update(student)
}

/**
* 查询所有数据

* @param context
* *
* @return
*/
fun queryAll(context: Context?): MutableList<Student>? {
val builder = DbManager.getInstance(context!!)?.getDaoSession(context)?.getStudentDao()?.queryBuilder()
return builder?.build()?.list()
}

/**
* 根据id，其他的字段类似

* @param context
* *
* @param id
* *
* @return
*/
fun queryForId(context: Context?, id: Long): MutableList<Student>? {
val builder = DbManager.getInstance(context!!)?.getDaoSession(context)?.getStudentDao()?.queryBuilder()
/**
* 返回当前id的数据集合,当然where(这里面可以有多组，做为条件);
* 这里build.list()；与where(StudentDao.Properties.Id.eq(id)).list()结果是一样的；
* 在QueryBuilder类中list()方法return build().list();

*/
// Query<Student> build = builder.where(StudentDao.Properties.Id.eq(id)).build();
// List<Student> list = build.list();
return builder?.where(StudentDao.Properties.Id.eq(id))?.list()
}
}

步骤六、mainactivity布局

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/activity_main"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">

<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">

<Button
android:id="@+id/add"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="增" />

<Button
android:id="@+id/delete"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="删" />

<Button
android:id="@+id/updata"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="改" />

<Button
android:id="@+id/check"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:text="查" />

</LinearLayout>

<Button
android:id="@+id/deleteAll"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
android:layout_weight="1"
android:text="删除全部" />

<Button
android:id="@+id/check_id"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_above="@id/deleteAll"
android:layout_centerInParent="true"
android:text="根据id查" />

</RelativeLayout>

步骤七、mainActivity

package tsou.com.simple.greendaoforkotlin

import android.content.Context
import android.os.Bundle
import android.support.v7.app.AppCompatActivity
import android.util.Log
import kotlinx.android.synthetic.main.activity_main.*
import tsou.com.simple.greendaoforkotlin.bean.Student
import tsou.com.simple.greendaoforkotlin.dao.StudentDaoOpe

class MainActivity : AppCompatActivity() {

private var mContext: Context? = null
private var student: Student? = null

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
mContext = this
initData()
initListener()
}

private var studentList = mutableListOf<Student>()
/**
* 初始化数据
*/
private fun initData() {
for (i in 0..99) {
student = Student(i.toLong(), "huang" + i, 25)
studentList.add(student!!)//不为null
}

}

private fun initListener() {
/**
* 增
*/
add.setOnClickListener {
StudentDaoOpe.getInstance().insertData(mContext, studentList)
}
/**
* 删
*/
delete.setOnClickListener {
val student = Student(5.toLong(), "haung" + 5, 25)
/**
* 根据特定的对象删除
*/
StudentDaoOpe.getInstance().deleteData(mContext, student)
/**
* 根据主键删除
*/
StudentDaoOpe.getInstance().deleteByKeyData(mContext, 7)
}

/**
* 删除所有
*/
deleteAll.setOnClickListener {
StudentDaoOpe.getInstance().deleteAllData(mContext)
}

/**
* 更新
*/
updata.setOnClickListener {
val student = Student(2.toLong(), "haungxiaoguo", 16516)
StudentDaoOpe.getInstance().updateData(mContext, student)
}

/**
* 查询全部
*/
check.setOnClickListener {
val students = StudentDaoOpe.getInstance().queryAll(mContext)
for (i in students!!.indices) {
Log.i("Log", students[i].name)
}
}

/**
* 根据id查询
*/
check_id.setOnClickListener {
val students = StudentDaoOpe.getInstance().queryForId(mContext, 50)
for (i in students!!.indices) {
Log.i("Log", students[i].name)
}
}

}
}