GreenDao3.2的使用方法

最新推荐文章于 2022-12-26 20:01:59 发布

原创最新推荐文章于 2022-12-26 20:01:59 发布 · 525 阅读

0 ·

CC 4.0 BY-SA版权

Android工作中遇到问题专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍GreenDao3.2的使用方法，包括数据库版本管理、表字段更新、查询操作等核心功能，并提供了完整的示例代码。

使用GreenDao3.2的总结。

1.0在建表的过程中，使用id的自增模式，在查询的时候不会报错

2.0修改表字段的时候，同时要修改数据库的版本号。在build.gradle中的如下

 greendao {
  schemaVersion 2   ======================这里是数据库版本号
daoPackage 'com.sy.greendaotextdemo.gen'
targetGenDir 'src/main/java'
 }

3.0查询表

 List joes = user.Dao.queryBuilder()
  . where(Properties.FirstName.eq("joe"))   
  .orderAsc(Properties.LastName)
  .list

4.0查询的一些语句

// http://blog.youkuaiyun.com/liuchao9876543210/article/details/54378859

1）orderAsc：升序排序
（1）orderDesc: 降序排序
（1）eq()：==

（1）noteq()：!=
（1）gt()： >
（1）t()：<
（1）ge：>=
（1）le:<=
（1）like()：包含
（1）between：俩者之间
（1）in：在某个值内
（1）notIn：不在某个值内

实践操作

#第一步配置（代码如下）：

文件：build.gradle(app)

apply plugin: 'org.greenrobot.greendao' // apply plugin

buildscript {
repositories {
    mavenCentral()
}
dependencies {
    classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' // add plugin
}
 }


greendao {
schemaVersion 2
daoPackage 'com.rms.sy.rmscontrolsystem.gen'   //添加dao的位置
targetGenDir 'src/main/java'
}

第二步：编写bean(这里使用的是用户的信息bean)

 import org.greenrobot.greendao.annotation.Entity;
 import org.greenrobot.greendao.annotation.Id;
 import org.greenrobot.greendao.annotation.Keep;
 /** 
    ** 创建时间： 2017/9/11 0011.
    ** 编写人：Tina
    ** 功能描述：userBean
    */
 @Entity(generateConstructors = false)
 public class UserBean {
 @Id(autoincrement = true)
  private Long id;
  private String name;
  private String  password;
  private  String userid;

 public UserBean(Long id, String name, String password, String userid) {
    this.id = id;
    this.name = name;
    this.password = password;
    this.userid = userid;
 }
@Keep
public UserBean(String name, String password, String userid) {

    this.name = name;
    this.password = password;
    this.userid = userid;
}


public UserBean() {
 }
@Keep
public Long getId() {
    return this.id;
}
@Keep
public void setId(Long id) {
    this.id = id;
}
@Keep
public String getName() {
    return this.name;
}
@Keep
public void setName(String name) {
    this.name = name;
}



@Override
public String toString() {
    return "UserBean{" +
            "id=" + id +
            ", name='" + name + '\'' +
            ", password=" + password +
            ", userid=" + userid +
            '}';
}

@Keep
public String getPassword() {
    return password;
}

@Keep
public void setPassword(String password) {
    this.password = password;
}


@Keep
public String getUserid() {
    return userid;
}

@Keep
public void setUserid(String userid) {
    this.userid = userid;
}
 }

点击导航栏上的build中make project选项，就自动生成三个文件（）：
DaoMaster
DaoSession
UserBeanDao

第三步编写context（因为需求要把数据库放在本地，所以加了这段代码,么有这个需求的可以忽略这段）：

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



import java.io.File;
import java.io.IOException;

/**
 ** 创建时间： 2017/9/29 0029.
 ** 编写人：Tina
 ** 邮箱：1208156801@qq.com
 ** 功能描述：自定义数据库的位置
 */

 public class GreenDaoContext extends ContextWrapper {
private String currentUserId;
private Context mContext;

public GreenDaoContext() {
    super(MyApp.getContext());
    this.mContext = MyApp.getContext();
}

@Override
public File getDatabasePath(String name) {
    // 判断是否存在sd卡
    boolean sdExist = android.os.Environment.MEDIA_MOUNTED.equals(android.os.Environment.getExternalStorageState());
    if (!sdExist) {// 如果不存在,
        Log.e("SD卡管理：", "SD卡不存在，请加载SD卡");
        return null;
    } else {// 如果存在
        // 获取sd卡路径
        String dbDir = android.os.Environment.getExternalStorageDirectory().getAbsolutePath();
        dbDir += "/Benetech/Dababase";// 数据库所在目录
        String dbPath = dbDir + "/" + name;// 数据库路径
        // 判断目录是否存在，不存在则创建该目录
        File dirFile = new File(dbDir);
        if (!dirFile.exists())
            dirFile.mkdirs();

        // 数据库文件是否创建成功
        boolean isFileCreateSuccess = false;
        // 判断文件是否存在，不存在则创建该文件
        File dbFile = new File(dbPath);
        if (!dbFile.exists()) {
            try {
                isFileCreateSuccess = dbFile.createNewFile();// 创建文件
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else
            isFileCreateSuccess = true;
        // 返回数据库文件对象
        if (isFileCreateSuccess)
            return dbFile;
        else
            return super.getDatabasePath(name);
    }
}



/**
 ** 重载这个方法，是用来打开SD卡上的数据库的，android 2.3及以下会调用这个方法。
 *
 ** @param name
 ** @param mode
 ** @param factory
 */
@Override
public SQLiteDatabase openOrCreateDatabase(String name,
                                           int mode, SQLiteDatabase.CursorFactory factory) {
    SQLiteDatabase result = SQLiteDatabase.openOrCreateDatabase(getDatabasePath(name), factory);

    return result;
}

/**
 ** Android 4.0会调用此方法获取数据库。
 *
 ** @see android.content.ContextWrapper#openOrCreateDatabase(java.lang.String,
 **      int,
 **      android.database.sqlite.SQLiteDatabase.CursorFactory,
 **      android.database.DatabaseErrorHandler)
 ** @param name
 ** @param mode
 ** @param factory
 ** @param errorHandler
 */
@Override
public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler) {

    SQLiteDatabase result = SQLiteDatabase.openOrCreateDatabase(getDatabasePath(name), factory);
    return result;
}

}

第四步编写数据库升级更新的工具类（思路是新建临时表–复制数据–新表）因为网上很多介绍的，代码如下：

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

 import com.rms.sy.rmscontrolsystem.gen.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;
}
}

##第六步添加数据表打开的工具类代码如下：

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

 import com.rms.sy.rmscontrolsystem.gen.DaoMaster;
 import com.rms.sy.rmscontrolsystem.gen.StudentDao;
 import com.rms.sy.rmscontrolsystem.gen.UserBeanDao;
 import com.rms.sy.rmscontrolsystem.gen.UserTrailLogBeanDao;

 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);
}

/**
 ** 数据库升级
 ** @param db
 ** @param oldVersion
 ** @param newVersion
 */
@Override
public void onUpgrade(Database db, int oldVersion, int newVersion) {
    //操作数据库的更新 有几个表升级都可以传入到下面

    MigrationHelper.getInstance().migrate(db, UserBeanDao.class);

}

 }

#第七步增删改查的工具类：

import android.content.Context;
import android.util.Log;
import com.rms.sy.rmscontrolsystem.MyApp;
import com.rms.sy.rmscontrolsystem.bean.UserBean;
import com.rms.sy.rmscontrolsystem.gen.UserBeanDao;
import java.util.List;
/**
 ** 创建时间： 2017/10/9 0009.
 ** 编写人：Tina
 ** 邮箱：1208156801@qq.com
 ** 功能描述：用户表的操作
 **/

 public class UserBeanDaoOpe {

    private String TAG = UserBeanDaoOpe.class.getSimpleName();
private Context mContext;
private UserBeanDao mUserBeanDao;

public UserBeanDaoOpe(){
    mContext = MyApp.getContext();
    mUserBeanDao = DbManager.getDaoSession(mContext).getUserBeanDao();
   }

//添加用户信息
public void insertUser(String name,String password,String userid){
    UserBean giou = new UserBean( name,password,userid);
    Log.d(TAG, "insertData: 插入用户信息"+name+"密码"+password);
    long insert = mUserBeanDao.insert(giou);
}

/**
 ** 插入用户集合
 ** @param userBeen
 */
public void inserUserList(List<UserBean> userBeen){
    if (userBeen ==null || userBeen.isEmpty()){
        return;
    }
    mUserBeanDao.insertInTx(userBeen);
}

/**
 ** 删除用户
 ** @param user
 */
public void deleteUser(UserBean user){
    mUserBeanDao.delete(user);
}

/**
 ** 删除多个对象
 */
public  void  deleteUser(List<UserBean> userList){
    mUserBeanDao.deleteInTx(userList);
}


public void cleanDB(){

    mUserBeanDao.deleteAll();
}

/**
 ** 更新用户
 ** @param userBean
 */
public  void updateUser(UserBean userBean){
 //        UserBean findUser = mUserBeanDao.queryBuilder().where(com.sy.greendaotextdemo.gen.UserBeanDao.Properties.Password.eq(name)).build().unique();
    mUserBeanDao.update(userBean);
}

/**
 ** 根据对应的名字查询更新
 ** @param name
 */
public void updateUser(String name){
    //先查询再更新
    UserBean findUser = mUserBeanDao.queryBuilder().where(UserBeanDao.Properties.Name.eq(name)).build().unique();
    mUserBeanDao.update(findUser);

}

/**
 ** 查询所有数据
 ** @return
 */
public List<UserBean> queryListAll(){
    List<UserBean> userBeanList = mUserBeanDao.queryBuilder().list();
    return  userBeanList;
}

public List<UserBean> queryList(){
    List<UserBean> userBeanList = mUserBeanDao.queryBuilder()
            .where(UserBeanDao.Properties.Id.notEq(999))
            .orderAsc(UserBeanDao.Properties.Id).limit(100).build().list();
    return  userBeanList;

}


//    /**
 //     * 判断相同id的对象是否已经存在
//     * 已经存在的不能再insert
//     * @param user
//     * @return
//     */
//    public boolean isExit(User user) {
 //        DaoMaster daoMaster = new DaoMaster(getReadableDatabase());
//        DaoSession daoSession = daoMaster.newSession();
//        UserDao userDao = daoSession.getUserDao();
//        QueryBuilder<User> qb = userDao.queryBuilder();
 //        qb.where(UserDao.Properties.Id.eq(user.getId()));
//        qb.buildCount().count();
//        return qb.buildCount().count() > 0 ? true : false;
//    }

}

#在activity中使用

查询：
List students = StudentDaoOpe.queryAll(mContext);

添加：

            UserBeanDaoOpe  userBeanDaoOpe = new UserBeanDaoOpe();
            name ="admin";    
            pwd ="admin";    
            String d = MD5Util.encode(pwd);    
            String userid = "123";    
           // userBeanDaoOpe.cleanDB();     
            userBeanDaoOpe.insertUser(name,d,userid);

嗯~~~整理到这里，后期有需求再添加。代码放在了github上，链接贴一下~
demo地址：
Demo

https://github.com/Xtlbb/GreenDaoTextDemo