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

最新推荐文章于 2024-08-06 03:59:51 发布
最新推荐文章于 2024-08-06 03:59:51 发布
阅读量9.1k 收藏 4
点赞数 2
分类专栏： android—kotlin语言 文章标签： 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huangxiaoguo1/article/details/78163004
版权

先看效果

这里写图片描述

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

  • 在app的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'
}
  • 在项目的build.gradle中
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)
            }
        }

    }
}

其他详细的步骤请看：greendao3.0以上使用步骤（一）：基础使用

Demo地址：http://download.csdn.net/download/huangxiaoguo1/10008298

晓果博客
关注
专栏目录
android：kotlin语言使用greendao3，跨平台app开发框架
m0_66264798的博客
02-15 1851
apply plugin: ‘org.greenrobot.greendao’ greendao { //数据库的schema版本，也可以理解为数据库版本号 schemaVersion 1 //设置DaoMaster、DaoSession、Dao包名，也就是要放置这些类的包的全路径。 daoPackage ‘tsou.com.simple.greendaoforkotlin.greendao’ //设置DaoMaster、DaoSession、Dao目录 targetGenDir ‘src/main/jav
安卓：Kotlin数据库框架GreenDao的使用
风尘的博客
11-12 1005
优势： 1.存取速度快; 2.支持数据库加密; 3.轻量级; 4.激活实体; 5.支持缓存; 6.代码自动生成； 导入依赖： 项目中： buildscript { repositories { google() jcenter() mavenCentral() // add repository } dependencies ...
android：kotlin语言使用greendao数据库简解
10-05
使用kotlin语言编写android程序时，使用greendao3.0数据库简介
Kotlin语言基础入门：Kotlin简介
最新发布
weixin_40448449的博客
08-06 244
在2019年Google I/O大会上，Google 宣布今后将优先采用 Kotlin 进行 Android 开发。一，简介Kotlin 是一种富有表现力且简洁的编程语言，不仅可以减少常见代码错误，还可以轻松集成到现有应用中。Google 列举的 Kotlin 的优势：富有表现力且简洁：可以使用更少的代码实现更多的功能。表...
Kotlin中GreenDao的使用
luoyanda的博客
03-13 1973
1.依赖添加：apply plugin: 'org.greenrobot.greendao' 在android{***}中添加： greendao { schemaVersion 1 daoPackage 'com.example.architectrue' //包名 targetGenDir 'src/main/java' //存放greendao库生成文件（DaoMaster和DaoSession）的目录 } 在添加classpath 'org.greenrobot:greendao-gradle-pl
android：kotlin语言使用greendao3
2301_77110605的博客
04-17 581
希望本文对你有所启发，有任何面试上的建议也欢迎留言分享给大家。好了，今天的分享就到这里，如果你对在面试中遇到的问题，或者刚毕业及工作几年迷茫不知道该如何准备面试并突破现状提升自己，对于自己的未来还不够了解不知道给如何规划，来看看同行们都是如何突破现状，怎么学习的，来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。好了~如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。
Kotlin GreenDao
蒙蒙的专栏
04-17 1174
GreenDao 使用： 在project 的gradle 添加对于GreenDao的引用 classpath 'org.greenrobot:greendao-gradle-plugin:3.2.0'//greendao 在app gradle 添加： apply plugin: 'org.greenrobot.greendao' android { greendao...
GreenDao 3.0 基本使用
u011424451的专栏
03-22 368
文章目录1、引入2、基本使用3、多表关联，@ToMany、@ToOne的使用3.1、1对多关系3.2、1对1关系3.3 多对多关系PS: 需要注意的问题 GreenDao是一款Android上的ORM框架（对象/关系映射），在数据库开发中能帮我们从枯燥的CRUD中节约大量的时间，这里针对GreenDao3.0以后的版本做一个简单的使用介绍。 1、引入 GreenDao Github地址 引入Gradle插件， 在根目录的build.gradle中，加入GreenDao的插件依赖地址： depende
GreenDao 3.3.0 基本使用与入门 （一）
Mr_kings的专栏
07-21 3433
GreenDao 引入 GreenDao官网 GreenDaoAPI地址 Porject 目录下 build.gradle 下添加配置 dependencies { classpath 'com.android.tools.build:gradle:4.0.0' classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" classpath 'com.neenbedan
Android-阳哥面试宝典V3.0.pdf
09-28
4. 数据持久化：使用ORM框架如GreenDao或Room进行数据库操作的优化。 5. 图片加载库：认识Glide、Picasso、 Fresco等图片加载库的使用和优化技巧。 三、Android性能优化 1. 内存优化：避免内存泄漏，理解内存分析...
com.hy.minifetion.v3.0.zip_android
09-21
Android原生支持SQLite数据库，开发者也可能使用第三方库如GreenDao或Room进行ORM操作。此外，SharedPreferences常用于轻量级的数据存储，而File或内部存储用于文件管理。 4. **UI布局与设计**：Android应用的用户...
greenDAO:适用于Android的轻量级ORM解决方案，可将对象映射到SQLite数据库-开源
05-15
适用于您SQLite数据库的Android ORM。 对于新应用程序，我们建议使用ObjectBox，这是一个新的面向对象的数据库，它比SQLite快得多并且易于使用。 对于基于greenDAO的现有应用程序，我们提供了DaoCompat以便轻松切换（另请参见公告）。 greenDAO是一个开放源代码的Android ORM，使对SQLite数据库的开发再次变得有趣。 它使开发人员免于处理低级数据库要求，同时节省了开发时间。 SQLite是一个很棒的嵌入式关系数据库。 尽管如此，编写SQL和解析查询结果仍然是非常繁琐且耗时的任务。 通过将Java对象映射到数据库表（称为ORM，“对象/关系映射”），greenDAO使您摆脱了这些麻烦。 这样，您可以使用简单的面向对象的API来存储，更新，删除和查询Java对象。 我们想提供最快的Android ORM。
五分钟教你Android-Kotlin项目编写
08-30
本篇文章主要介绍了五分钟教你Android-Kotlin项目编写，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Kotlin GreenDao简单使用
weixin_43915921的博客
10-14 1114
1.在主工程‘app’中下加入一下配置 repositories { mavenCentral() } dependencies { classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' } 2.在当前项目build中配置 //最上面添加 apply plugin: 'org.green...
greendao3，阿里Android岗面试百题
m0_65512365的博客
12-18 1258
} @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) {
Kotlin语言开发android系列：GreenDao3基本使用
Lemon_Geek的博客
08-10 3360
本文内容： 本文的内容主要是针对使用Kotlin开发android过程中使用Greendao3来操作数据库的基本使用指南。由于Greendao3相关资料比较多，请大家自行搜索，本文不再对Greendao3进行详细介绍。 Greendao3配置： 在使用Greendao3之前，需要对Greendao3进行配置（这已经是默认流程了！），打开build.gradle（Module：app）添...
android：kotlin语言使用greendao3，熬夜整理Android高频面试题
m0_46608024的博客
03-22 923
**添加数据至数据库@param stu*/!/**将数据实体通过事务添加至数据库*/) {return!/**添加数据至数据库，如果存在，将原来的数据覆盖内部代码判断了如果存在就update(entity);不存在就insert(entity)；*/!/**删除数据至数据库@param student 删除具体内容*/!/**根据id删除数据至数据库@param id 删除具体内容*/!/**删除全部数据*/) {!/**更新数据库*/
greenDao再kotlin中的问题
phoenix
04-11 1957
kotlin 1.2.30版本前发现 kotlin不支持greenDao .故greenDao依然采用java类来定义 greendao采用注解  和一些自定义生成的java函数 猜测 可能不能采用kotlin方式。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值