GreenDao的使用

最新推荐文章于 2024-05-08 21:39:34 发布
最新推荐文章于 2024-05-08 21:39:34 发布
阅读量334 收藏
点赞数
分类专栏： android基础 文章标签： GeeenDao Android 初识

 

运行效果图：

 

GreenDao的配置（AS）：

 

 

第一步：在build中添加配置如下：

projet 目录下的build.gradle

[html] view plain copy

  1. dependencies {  
  2.       
  3.        classpath 'org.greenrobot:greendao-gradle-plugin:3.2.0'  
  4.    }  

moudle 下的build.gradle添加如下内容：

[html] view plain copy

  1. apply plugin: 'org.greenrobot.greendao'  
  2.   
  3.  dependencies {  
  4.     .....................  
  5.       
  6.     compile 'org.greenrobot:greendao:3.2.0'  
  7. }  

添加完成之后点击sync一下工程

 

第二步：

首先在moudle下  build.gradle的根目录下添加如下配置

[html] view plain copy

  1. apply plugin: 'org.greenrobot.greendao'
  2. greendao {  
  3.     //数据库的schema版本，也可以理解为数据库版本号  
  4.     schemaVersion 1  
  5.     //设置DaoMaster、DaoSession、Dao包名，也就是要放置这些类的包的全路径。  
  6.     daoPackage 'com.koimy.greedaotest.dao'  
  7.     //设置DaoMaster、DaoSession、Dao目录  
  8.     targetGenDir 'src/main/java'  
  9. }  

在项目里面添加实体类Student如下所示：

 

 

然后点击 android studio 的 build-->make project

此时项目结构如下（会自动生成一个dao包）：

StudentBean 类里面的内容发生了变化如下：

 

GreenDao帮助我们自动生成了一些get和set方法，以及构造方法

第三步：为了方便使用我们添加了一个 db包

 

DbManager类如下：

 

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;

import com.koimy.greedaotest.dao.DaoMaster;
import com.koimy.greedaotest.dao.DaoSession;

/**
 * CDbManager
 */

public class DbManager {

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

    private static final String DB_NAME = "test.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;
    }

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

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

        return mDevOpenHelper.getWritableDatabase();
    }

    /**
     * 获取DaoMaster
     *
     * @param context
     * @return
     */
    public static DaoMaster getDaoMaster(Context context) {
        if (null == mDaoMaster) {
            synchronized (DbManager.class) {
                if (null == mDaoMaster) {
                    mDaoMaster = new DaoMaster(getWritableDatabase(context));
                }
            }
        }
        return mDaoMaster;
    }

    /**
     * 获取DaoSession
     *
     * @param context
     * @return
     */
    public static DaoSession getDaoSession(Context context) {
        if (null == mDaoSession) {
            synchronized (DbManager.class) {
                mDaoSession = getDaoMaster(context).newSession();
            }
        }
        return mDaoSession;
    }

}

 

SutdentDaoOpe类如下:

import android.content.Context;

import com.koimy.greedaotest.dao.StudentBeanDao;
import com.rock.administrator.greendao.StudentBean;

import org.greenrobot.greendao.query.QueryBuilder;

import java.util.List;

/**
 * Created by Administrator on 2018/4/1 0001.
 */

public class SutdentDaoOpe {

    /**
     * 添加数据至数据库
     *
     * @param context
     * @param stu
     */
    public static void insertData(Context context, StudentBean stu) {
        DbManager.getDaoSession(context).getStudentBeanDao().insert(stu);
    }


    /**
     * 将数据实体通过事务添加至数据库
     *
     * @param context
     * @param list
     */
    public static void insertData(Context context, List<StudentBean> list) {
        if (null == list || list.size() <= 0) {
            return;
        }
        DbManager.getDaoSession(context).getStudentBeanDao().insertInTx(list);
    }

    /**
     * 添加数据至数据库，如果存在，将原来的数据覆盖
     * 内部代码判断了如果存在就update(entity);不存在就insert(entity)；
     *
     * @param context
     * @param StudentBean
     */
    public static void saveData(Context context, StudentBean StudentBean) {
        DbManager.getDaoSession(context).getStudentBeanDao().save(StudentBean);
    }

    /**
     * 删除数据至数据库
     *
     * @param context
     * @param StudentBean 删除具体内容
     */
    public static void deleteData(Context context, StudentBean StudentBean) {
        DbManager.getDaoSession(context).getStudentBeanDao().delete(StudentBean);
    }

    /**
     * 根据id删除数据至数据库
     *
     * @param context
     * @param id      删除具体内容
     */
    public static void deleteByKeyData(Context context, long id) {
        DbManager.getDaoSession(context).getStudentBeanDao().deleteByKey(id);
    }

    /**
     * 删除全部数据
     *
     * @param context
     */
    public static void deleteAllData(Context context) {
        DbManager.getDaoSession(context).getStudentBeanDao().deleteAll();
    }

    /**
     * 更新数据库
     *
     * @param context
     * @param StudentBean
     */
    public static void updateData(Context context, StudentBean StudentBean) {
        DbManager.getDaoSession(context).getStudentBeanDao().update(StudentBean);
    }


    /**
     * 查询所有数据
     *
     * @param context
     * @return
     */
    public static List<StudentBean> queryAll(Context context) {
        QueryBuilder<StudentBean> builder = DbManager.getDaoSession(context).getStudentBeanDao().queryBuilder();

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



    /**
     *  分页加载
     * @param context
     * @param pageSize 当前第几页(程序中动态修改pageSize的值即可)
     * @param pageNum  每页显示多少个
     * @return
     */
    public static List<StudentBean> queryPaging( int pageSize, int pageNum,Context context){
        StudentBeanDao StudentBeanDao = DbManager.getDaoSession(context).getStudentBeanDao();
        List<StudentBean> listMsg = StudentBeanDao.queryBuilder()
                .offset(pageSize * pageNum).limit(pageNum).list();
        return listMsg;
    }
}

 

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="5dp"
        android:layout_margin="5dp"
        android:orientation="horizontal">
        <TextView
            android:layout_width="0dp"
            android:layout_weight="1"
            android:layout_height="wrap_content"
            android:text="id : "
            android:layout_marginRight="5dp"
            android:textSize="16sp"/>

        <EditText
            android:id="@+id/et_id"
            android:layout_width="0dp"
            android:layout_weight="2.5"
            android:layout_height="wrap_content"
            android:textSize="16sp"
            android:inputType="number"
            android:hint="输入id"/>

        <TextView
            android:layout_width="0dp"
            android:layout_weight="1"
            android:layout_height="wrap_content"
            android:text="name : "
            android:layout_marginLeft="5dp"
            android:layout_marginRight="5dp"
            android:textSize="16sp"/>

        <EditText
            android:id="@+id/et_name"
            android:layout_width="0dp"
            android:layout_weight="2.5"
            android:layout_height="wrap_content"
            android:textSize="16sp"
            android:hint="输入name"/>
    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="5dp"
        android:layout_margin="5dp"
        android:orientation="horizontal">
        <TextView
            android:layout_width="0dp"
            android:layout_weight="1"
            android:layout_height="wrap_content"
            android:text="age : "
            android:layout_marginRight="5dp"
            android:textSize="16sp"/>

        <EditText
            android:id="@+id/et_age"
            android:layout_width="0dp"
            android:layout_weight="2.5"
            android:layout_height="wrap_content"
            android:textSize="16sp"
            android:inputType="number"
            android:hint="输入age"/>

        <TextView
            android:layout_width="0dp"
            android:layout_weight="1"
            android:layout_height="wrap_content"
            android:text="num : "
            android:layout_marginLeft="5dp"
            android:layout_marginRight="5dp"
            android:textSize="16sp"/>

        <EditText
            android:id="@+id/et_num"
            android:layout_width="0dp"
            android:layout_weight="2.5"
            android:layout_height="wrap_content"
            android:textSize="16sp"
            android:hint="输入num"/>
    </LinearLayout>


    <Button
        android:id="@+id/btnAdd"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="增"/>

    <Button
        android:id="@+id/btnDel"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="删"/>

    <Button
        android:id="@+id/btnUpd"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="改"/>

    <Button
        android:id="@+id/btnSel"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="查"/>

    <EditText
        android:id="@+id/et_show"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</LinearLayout>

 

MainActivithy.java

 

package com.rock.administrator.greendao;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;

import com.db.SutdentDaoOpe;
import com.koimy.greedaotest.dao.StudentBeanDao;

import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private EditText et_id, et_name, et_age, et_num, et_show;
    private Button btnAdd, btnDel, btnUpd, btnSel;

    private int getID;
    private String getName;
    private int getAge;
    private String getNum;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
    }

    private void initView() {
        et_id = (EditText) findViewById(R.id.et_id);
        et_name = (EditText) findViewById(R.id.et_name);
        et_age = (EditText) findViewById(R.id.et_age);
        et_num = (EditText) findViewById(R.id.et_num);
        et_show = (EditText) findViewById(R.id.et_show);

        btnAdd = (Button) findViewById(R.id.btnAdd);
        btnDel = (Button) findViewById(R.id.btnDel);
        btnUpd = (Button) findViewById(R.id.btnUpd);
        btnSel = (Button) findViewById(R.id.btnSel);

        btnAdd.setOnClickListener(this);
        btnDel.setOnClickListener(this);
        btnUpd.setOnClickListener(this);
        btnSel.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            //增
            case R.id.btnAdd:
                getDate();
                StudentBean sBean = new StudentBean((long) getID, getName, getAge, getNum);
                SutdentDaoOpe.insertData(this, sBean);
                break;

            //删
            case R.id.btnDel:
                int getID2 = Integer.valueOf(et_id.getText().toString().trim());
                SutdentDaoOpe.deleteByKeyData(this, getID2);
                break;

            //改
            case R.id.btnUpd:
                getDate();
                StudentBean upBean = new StudentBean((long) getID, getName, getAge, getNum);
                SutdentDaoOpe.updateData(this, upBean);
                break;

            //查
            case R.id.btnSel:
                List<StudentBean> student = SutdentDaoOpe.queryAll(this);
                if (student.size() == 0) {
                    et_show.setText("数据库没有数据！");
                } else {
                    //创建一个list,用来收集一组数据
                    ArrayList list1 = new ArrayList();
                    for (int i = 0; i < student.size(); i++) {
                        list1.add(" [");
                        list1.add(student.get(i).getId());
                        list1.add(student.get(i).getName());
                        list1.add(student.get(i).getAge());
                        list1.add(student.get(i).getNum());
                        list1.add("] ");
                    }
                    et_show.setText(list1.toString());
                }
                break;
        }
    }

    /*
    优化获取editText数据的重复代码
     */
    private void getDate() {
        getID = Integer.valueOf(et_id.getText().toString().trim());
        getName = et_name.getText().toString().trim();
        getAge = Integer.valueOf(et_age.getText().toString().trim());
        getNum = et_num.getText().toString().trim();
    }
}

 

数据库的升级：

首先新建一个helper包引入两个类,内容如下：

MigrationHelper类：

 

 
package com.helper;
/**
 * 数据库更新辅助类
 *
 * 原理：创建临时表-->删除原表-->创建新表-->复制临时表数据到新表并删除临时表；这样数据库表的更新就完成了
 */

import android.database.Cursor;
import android.text.TextUtils;
import android.util.Log;


import com.koimy.greedaotest.dao.DaoMaster;

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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


public class MigrationHelper {

    private static final String CONVERSION_CLASS_NOT_FOUND_EXCEPTION = "MIGRATION HELPER - CLASS DOESN'T MATCH WITH THE CURRENT PARAMETERS";
    private static MigrationHelper instance;

    public static MigrationHelper getInstance() {
        if (instance == null) {
            instance = new MigrationHelper();
        }
        return instance;
    }

    public void migrate(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {

        generateTempTables(db, daoClasses);
        DaoMaster.dropAllTables(db, true);
        DaoMaster.createAllTables(db, false);
        restoreData(db, daoClasses);
    }

    /**
     * 生成临时列表
     *
     * @param db
     * @param daoClasses
     */
    private void generateTempTables(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        for (int i = 0; i < daoClasses.length; i++) {
            DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);

            String divider = "";
            String tableName = daoConfig.tablename;
            String tempTableName = daoConfig.tablename.concat("_TEMP");
            ArrayList<String> properties = new ArrayList<>();

            StringBuilder createTableStringBuilder = new StringBuilder();

            createTableStringBuilder.append("CREATE TABLE ").append(tempTableName).append(" (");

            for (int j = 0; j < daoConfig.properties.length; j++) {
                String columnName = daoConfig.properties[j].columnName;

                if (getColumns(db, tableName).contains(columnName)) {
                    properties.add(columnName);

                    String type = null;

                    try {
                        type = getTypeByClass(daoConfig.properties[j].type);
                    } catch (Exception exception) {
                        exception.printStackTrace();
                    }

                    createTableStringBuilder.append(divider).append(columnName).append(" ").append(type);

                    if (daoConfig.properties[j].primaryKey) {
                        createTableStringBuilder.append(" PRIMARY KEY");
                    }

                    divider = ",";
                }
            }
            createTableStringBuilder.append(");");

            db.execSQL(createTableStringBuilder.toString());

            StringBuilder insertTableStringBuilder = new StringBuilder();

            insertTableStringBuilder.append("INSERT INTO ").append(tempTableName).append(" (");
            insertTableStringBuilder.append(TextUtils.join(",", properties));
            insertTableStringBuilder.append(") SELECT ");
            insertTableStringBuilder.append(TextUtils.join(",", properties));
            insertTableStringBuilder.append(" FROM ").append(tableName).append(";");

            db.execSQL(insertTableStringBuilder.toString());

        }
    }

    /**
     * 存储新的数据库表 以及数据
     *
     * @param db
     * @param daoClasses
     */
    private 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");
            ArrayList<String> properties = new ArrayList();

            for (int j = 0; j < daoConfig.properties.length; j++) {
                String columnName = daoConfig.properties[j].columnName;

                if (getColumns(db, tempTableName).contains(columnName)) {
                    properties.add(columnName);
                }
            }

            StringBuilder insertTableStringBuilder = new StringBuilder();

            insertTableStringBuilder.append("INSERT INTO ").append(tableName).append(" (");
            insertTableStringBuilder.append(TextUtils.join(",", properties));
            insertTableStringBuilder.append(") SELECT ");
            insertTableStringBuilder.append(TextUtils.join(",", properties));
            insertTableStringBuilder.append(" FROM ").append(tempTableName).append(";");

            StringBuilder dropTableStringBuilder = new StringBuilder();
            dropTableStringBuilder.append("DROP TABLE ").append(tempTableName);
            db.execSQL(insertTableStringBuilder.toString());
            db.execSQL(dropTableStringBuilder.toString());
        }
    }

    private String getTypeByClass(Class<?> type) throws Exception {
        if (type.equals(String.class)) {
            return "TEXT";
        }
        if (type.equals(Long.class) || type.equals(Integer.class) || type.equals(long.class)) {
            return "INTEGER";
        }
        if (type.equals(Boolean.class)) {
            return "BOOLEAN";
        }

        Exception exception = new Exception(CONVERSION_CLASS_NOT_FOUND_EXCEPTION.concat(" - Class: ").concat(type.toString()));
        exception.printStackTrace();
        throw exception;
    }

    private List<String> getColumns(Database db, String tableName) {
        List<String> columns = new ArrayList<>();
        Cursor cursor = null;
        try {
            cursor = db.rawQuery("SELECT * FROM " + tableName + " limit 1", null);
            if (cursor != null) {
                columns = new ArrayList<>(Arrays.asList(cursor.getColumnNames()));
            }
        } catch (Exception e) {
            Log.v(tableName, e.getMessage(), e);
            e.printStackTrace();
        } finally {
            if (cursor != null)
                cursor.close();
        }
        return columns;
    }
}

MyOpenHelper类：

 

 
package com.helper;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;

import com.koimy.greedaotest.dao.DaoMaster;
import com.koimy.greedaotest.dao.StudentBeanDao;

import org.greenrobot.greendao.database.Database;

/**
 * 数据库版本升级
 */

public class MyOpenHelper extends DaoMaster.OpenHelper{

    public MyOpenHelper(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("version", oldVersion + "---先前和更新之后的版本---" + newVersion);
        if (oldVersion < newVersion) {
            Log.i("version", oldVersion + "---先前和更新之后的版本---" + newVersion);
            MigrationHelper.getInstance().migrate(db, StudentBeanDao.class);
            //更改过的实体类(新增的不用加)   更新UserDao文件 可以添加多个  XXDao.class 文件
//             MigrationHelper.getInstance().migrate(db, UserDao.class,XXDao.class);
        }
    }
}

注：有两个onUpgrade，这里使用的是DataBase，不是SQLiteDatabase。

然后将

[html] view plain copy

  1. /**  
  2.  * 获取DaoMaster  
  3.  *  
  4.  * @param context  
  5.  * @return  
  6.  */  
  7. public static DaoMaster getDaoMaster(Context context) {  
  8.     if (null == mDaoMaster) {  
  9.         synchronized (DbManager.class) {  
  10.             if (null == mDaoMaster) {  
  11.                 mDaoMaster = new DaoMaster(getWritableDatabase(context));  
  12.             }  
  13.         }  
  14.     }  
  15.     return mDaoMaster;  
  16. }  

换成如下所示：

 

[html] view plain copy

  1. /**  
  2.    * 获取DaoMaster  
  3.    *  
  4.    * 判断是否存在数据库，如果没有则创建数据库  
  5.    * @param context  
  6.    * @return  
  7.    */  
  8.   public static DaoMaster getDaoMaster(Context context) {  
  9.       if (null == mDaoMaster) {  
  10.           synchronized (DbManager.class) {  
  11.               if (null == mDaoMaster) {  
  12.                   MyOpenHelper helper = new MyOpenHelper(context,DB_NAME,null);  
  13.                   mDaoMaster = new DaoMaster(helper.getWritableDatabase());  
  14.               }  
  15.           }  
  16.       }  
  17.       return mDaoMaster;  
  18.   }  

注：这里有getDaoMaster和getDaoSessin,修改的是getDaoMaster。

接下来：我们在Student类里面添加一个 属性 grade属性，然后将build.gradle里面schemaVersion改为 2

 

然后编译，运行一下程序,就OK了。

 

参考：https://blog.csdn.net/wzgbgz/article/details/79140056

 

星枫丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一篇好文之Android数据库 GreenDao的使用指南(源码+案列)
aserbao的博客
10-23 5万+
之前在开发过程中，数据库基本上会使用Litepal和SQlite自己写，最近换新环境，公司原先使用的数据库就是GreenDao，在各种情况的作用下，准备了解下GreenDao，顺便写一篇文章记录下GreenDao的基本使用！大家在使用GreenDao的时候遇到什么问题，欢迎在文章底部或者我的公众号aserbao给我留言！ 本文主要从如下几个方面进行讲解：GreenDao的优缺点 1. Gree...
利用注解获取greendao的表名
qq_33256701的博客
11-23 1043
greendao Entity注解类源码中： @Retention(RetentionPolicy.SOURCE) //表示编译时有效，运行时是没有效果的 所以无法使用greendao的注解来进行映射获取表名等属性 ； 首先自己新建注解类后重新注解； @Retention(RetentionPolicy.RUNTIME) //使其运行时有效 @Target(ElementType.T...
【GreenDao】 实现数据库迁移，使用 GreenDao 提供的 MigrationHelper类辅助完成
资深全栈开发工程师
07-31 477
类提供的方法来执行各种升级操作，比如创建新的表、修改表结构、迁移数据等。请注意，上述示例代码仅供参考，具体的迁移操作可能需要根据你的实际需求进行调整。要在 GreenDao 中实现数据库迁移，可以使用 GreenDao 提供的。注意，在升级过程中，可能需要创建新的表、修改表结构、迁移数据等操作。这样，在数据库升级时，GreenDao 会自动调用我们定义的迁移类的。首先，按照 GreenDao 的使用方式，配置相关依赖和生成代码。在上述示例代码中，我们将数据库版本号设置为 2。在该方法中，我们可以使用。
Android最全Android GreenDao的基本使用，腾讯高级工程师面试
最新发布
2401_84545862的博客
05-08 707
我这些话比较直接，可能会戳到一些人的玻璃心，但是我知道肯定会对一些人起到点醒的效果的。因为你的技术体系并不系统，是零碎的，散乱的。对现有技术架构的影响？而现在随着跨平台开发，混合式开发，前端开发之类的热门，Android开发者需要学习和掌握的技术也在不断的增加。初级工程师拿到需求会直接开始做，然后做着做着发现有问题了，要么技术实现不了，要么逻辑有问题。ps：这里的坑要注意，如果id自增的话，必须必须定义id类型为大写的Long，小写的会报错。这是一个普通的实体类，我们通过注解，可以让后续声称对应的表。
Android greenDao
xiaowang_lj的博客
07-02 1489
greenDAO是一个开源的Android ORM(对象-关系映射)，它让SQLite数据库的开发再次变得有趣。它使开发人员免于处理低级数据库要求，同时节省了开发时间。SQLite是一个很棒的嵌入式关系数据库。尽管如此，编写SQL和解析查询结果仍然是非常繁琐且耗时的任务。通过将Java对象映射到数据库表（称为ORM，“对象/关系映射”），greenDAO使您摆脱了这些麻烦。这样，您可以使用简单的面向对象的API来存储，更新，删除和查询Java对象。 最佳性能 (可能是 Android 中最快的 ORM) ，
Android数据库GreenDao的使用完全解析
一个IT人的技术成长历程。创造未来的行为就发生在今天，没有明天的目标，今天的行动就是重复昨天的事情。
10-02 1672
之前在开发过程中，数据库基本上会使用Litepal或者SQlite自己写，最近换新环境，公司原先使用的数据库就是GreenDao，在各种情况的作用下，准备了解下GreenDao，顺便写一篇文章记录下GreenDao的基本使用！如果你是Android开发者，你在开发路上遇到任何问题，欢迎来我的公众号给我留言，咱们一起讨论，加入的Android开发讨论小组，一起进步！文章转载请注明出处。本文主要从如下几个方面进行讲解存储的数据库结构GreenDao的优缺点GreenDao的使用配置。
Android ORM 框架之 greenDAO
是阿超
01-25 2261
Android ORM 框架之 greenDAO
GreenDao使用
hanjiexuan的博客
04-23 431
一：什么是GreenDao 1.官网地址：https://github.com/greenrobot/greenDAO 2.greenDAO通过将Java对象映射到数据库表（称为ORM，“对象/关系映射”），可以使用简单的面向对象API来存储、更新、删除和查询Java对象。 二：效果 三：GreenDao使用 1.在项目中的整体build.gradle使用添加依赖 buildscript { repositories { jcenter() mavenCentral
GreenDao使用demo
06-20
**GreenDao使用详解** GreenDao是一款专门为Android平台设计的高效、轻量级的对象关系映射（ORM）框架，它使得开发者能够便捷地在SQLite数据库上操作数据，无需编写大量的SQL语句。GreenDao通过将Java对象与数据库...
GreenDao使用Demo
08-10
在这个"GreenDao使用Demo"中，虽然代码可能较为混乱，但展示了如何在实际项目中结合RxJava来运用GreenDao的主要功能。 1. **安装与配置**： - 首先，你需要在项目级`build.gradle`文件中添加GreenDao的依赖，通常...
greenDAO使用demo
01-10
在这个“greenDAO使用demo”中，我们将深入探讨如何在Android应用中集成并使用greenDAO。 首先，我们要了解**对象关系映射（ORM）**的概念，它是连接数据库和编程语言的一种技术，使得开发者可以像操作对象一样操作...
android 的Greendao使用demo，供初学者使用
03-03
这个“android的GreenDao使用demo”是为初学者准备的一个实例，旨在帮助理解并快速上手GreenDao的使用。 一、GreenDao简介 GreenDao是一款高效且易于使用的Java库，它允许开发者直接在Android应用中通过对象与...
GreenDao的使用及相关步骤方法
fuzhongbin的博客
04-26 1288
一、GreenDao创建表 1.创建生成数据库表相关Dao的生成位置，一般在与java包同级创建java-gen包，用于存放生成器生成的类。在build grade中android{}添加： sourceSets { main { java.srcDirs = ['src/main/java', 'src/main/java-gen'] } }在dpendenc
Android GreenDao 使用全面讲解，2024最新大厂Android面经
m0_61549781的博客
03-28 729
这里附上上述的面试题相关的几十套字节跳动，京东，小米，腾讯、头条、阿里、美团等公司19年的面试题。网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。从GreenDao 3 使用注解来定义模型和实体，前面也讲过，通过注解的使用可以快速构建数据库表，包括设置主键，自增，值是否唯一等等等……
Android 数据库之GreenDAO
qq_19688207的博客
08-08 1292
GreenDAO 是一款开源的面向 Android 的轻便、快捷的 ORM 框架，将 Java 对象映射到 SQLite 数据库中，我们操作数据库的时候，不再需要编写复杂的 SQL语句， 在性能方面，greenDAO 针对 Android 进行了高度优化，最小的内存开销 、依赖体积小 同时还是支持 数据库加密。对于每个实体类， greenDAO 都会生成一个与之对应 DAO 对象，如：User 实体，则会生成一个 UserDao 类。1、build.gradle(Module:app)中添加配置与依赖。
Android GreenDao 使用全面讲解，Android组件化入门
03-15 1572
我见过很多技术leader在面试的时候，遇到处于迷茫期的大龄程序员，比面试官年龄都大。这些人有一些共同特征：可能工作了5、6年，还是每天重复给业务部门写代码，工作内容的重复性比较高，没有什么技术含量的工作。问到这些人的职业规划时，他们也没有太多想法。其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。不断奔跑，你就知道学习的意义所在！
Android GreenDao使用教程
木晓的博客
11-27 541
GreenDao是一款操作数据库的神器，经过了2.0版本的升级后，已经被广泛的开发者使用。确实是很好用，入门简单，可以剩去了数据库的建表操作和数据库SQL的编写 GreenDao3.2的配置 一、需要在工程（Project）的build.gradle中添加依赖 repositories { google() jcenter() } dependencies { classp...
GreenDao一对多的使用
05-04
GreenDao是一种轻量级的ORM框架，它可以帮助开发人员更加方便地操作数据库。在GreenDao中，一对多的关系可以使用注解@ToMany来定义。 下面是一个示例： ``` @Entity public class User { @Id private Long id; private String name; @ToMany(referencedJoinProperty = "userId") private List<Address> addresses; // getters and setters } @Entity public class Address { @Id private Long id; private String street; private String city; private String state; private String zip; private Long userId; // getters and setters } ``` 在上面的示例中，User和Address之间是一对多的关系。使用@ToMany注解表示User可以有多个Address对象，referencedJoinProperty属性指定在Address实体中用于关联User的属性。 要在GreenDao中查询一对多关系，可以使用Query类的list方法和相关的QueryBuilder对象，例如： ``` List<User> users = userDao.queryBuilder() .where(UserDao.Properties.Name.eq("John")) .list(); for (User user : users) { List<Address> addresses = user.getAddresses(); // do something with addresses } ``` 在上面的示例中，首先使用userDao.queryBuilder()获取QueryBuilder对象，然后使用where方法指定查询条件，最后使用list方法获取符合条件的User对象列表。接着，遍历User对象列表，并使用getAddresses方法获取每个User对象的Address列表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值