GreenDao使用

最新推荐文章于 2022-08-22 15:14:38 发布

Session__csdn

最新推荐文章于 2022-08-22 15:14:38 发布

阅读量371

点赞数

分类专栏： GreenDao使用

GreenDao使用专栏收录该内容

2 篇文章 0 订阅

订阅专栏

GreenDao是一个关系型数据库，可方便的利用对象操作数据库，更可以利用其ORM的继承特性，整合代码编写。个人感觉就是给对于sql不熟练的我提供一个可以操作数据库的捷径。

GreenDao 官方地址：http://greenrobot.org/greendao/

GreenDao gitHub地址：https://github.com/greenrobot/greenDAO

本篇例程：http://download.csdn.NET/detail/xiaoleiacm/9538119

GreenDao的工程建立：

1 AS：在APP的Gradle中加入：（需要在GitHub上查找最新的版本）

[java]view plaincopy 
   
 compile 'org.greenrobot:greendao:2.2.0'  

2 建立一个java-gen

在APP的Gradle中的Android下加入：

[java]view plaincopy 
   
 sourceSets{  
        main{  
            java.srcDirs=['src/main/java','src/main.java-gen']  
        }  
    }  

3 新建一个java Library

命名为：

Library Name:greendaogenerator

Class Name:ExampleDaoGenerator （用于生成表对象）

生成如图结构

4 在greendaogenerator的Gradle中添加

[java]view plaincopy 
   
 compile 'org.greenrobot:greendao-generator:2.2.0'  

通过以上的设置已完成基本的Gradle设置。

ExampleDaoGenerator类是为了生成数据库表而建立的一个节点类，它需要完成数据库版本的建立，节点的建立，以及设置GreenDao核心代码的路径。

 
 
  
  
   
   
    
    [java] 
    
    view plain
    
     copy
    
    
    
     
    
    
    
    
   
   
  
  
  
  package com.example;  
  
import de.greenrobot.daogenerator.DaoGenerator;  
import de.greenrobot.daogenerator.Entity;  
import de.greenrobot.daogenerator.Schema;  
  
public class ExampleDaoGenerator {  
    public static void main(String[] args) {  
        //生成实体类entity 即对应的表  
        Schema schema = new Schema(1, "com.student.entity");  
        //添加节点  
        addStudent(schema);  
  
        schema.setDefaultJavaPackageDao("com.student.dao");// 设置数据的会话层  
  
  
        //将生成的内容放在指定的路径下C:\Users\admin\Desktop\shujuku\MyApplication\app\src\main\java-gen  
        try {  
            new DaoGenerator().generateAll(schema, "/Users/admin/Desktop/shujuku/MyApplication/app/src/main/java-gen");  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
  
    }  
  
    创建数据库的表  
    private static void addStudent(Schema schema) {  
  
        Entity entity = schema.addEntity("Student"); //创建数据库的表  
  
  
        /** 
         * 设置字符串获其他类型为主键 
         * entity.addStringProperty("身份证号").primaryKey(); 
         */  
        //当前表中的列  
  
        entity.addIdProperty();// 主键  
        entity.addStringProperty("name");  
        entity.addStringProperty("address");  
        entity.addIntProperty("age");  
  
    }  
  
  
}  
 
 
生成GreenDao的CoreCode

运行ExampleDaoGenerator类，可以在Java-gen目录下生成相应的Student表的核心代码。

DaoMaster: 维护GreenDao数据库的对象，管理Dao生成的类

DaoSession:GreenDao的会话层，提供数据库的增删改查功能。

xxDao（StudentDao）:比DaoSession更加具体的会话层，提供批量插入，Count等功能

Student:Student表的对象，里面包含着Student的表操作。

通过以上四个文件即可完成对关系对象型数据库GreenDao的操作。

GreenDao数据库的再封装：

由于数据库需要创建等有着大量的重复代码，可对GreenDao再封装。封装可分为数据库初始化，以及数据库调用接口。

数据库初始化：

由于数据库的操作，可使用的是单例模式，这样在创建DaoMaster时可使用synchronized防止出现多个数据库对象，保证了数据库的安全性。

对于数据库的初始化，可直接应用在其他工程中：

[java]view plaincopy 
   
 package com.example.admin.myapplication.dbManager;  
   
 import android.content.Context;  
   
 import com.example.admin.myapplication.Dao.DaoMaster;  
 import com.example.admin.myapplication.Dao.DaoSession;  
   
 import de.greenrobot.dao.query.QueryBuilder;  
   
 /** 
  * 1 创建数据库 
  * 2 创建数据库表 
  * 3 创建数据库的增删查改 
  * 4 对数据库的升级 
  * Created by admin on 2016/5/31. 
  */  
 public class DaoManager {  
     private static final String TAG = DaoManager.class.getSimpleName();  
     private static final String DB_NAME = "mydb.sqlite";  //声明数据库  
     private volatile static DaoManager manager; //多线程名称  
     private static DaoMaster.DevOpenHelper helper;  
   
     private static DaoMaster daomaster;  
     private static DaoSession daoSession;  
   
     private Context context;  
   
     public void init(Context context) {  
         this.context = context;  
     }  
   
     /** 
      * 1 数据库类的创建 
      * 线程安全创建DaoManager,使用单例模式获得操作数据库的对象 
      * 
      * @return note:为保证数据库的有效性，采用单利模式进行访问 
      */  
     public static DaoManager getInstance() {  
   
             DaoManager instance = null;  
             if (manager == null) {  
                 synchronized (DaoManager.class) {  
                     if (instance == null) {  
                         instance = new DaoManager();  
                         manager = instance;  
                     }  
                 }  
             }  
             return instance;  
     }  
   
     /** 
      * 2 Master类的创建 
      * 得到DaoMaster 
      * 
      * @return note：系统帮助用户监测是否有数据库，如果没有，则创建数据库 
      */  
     public DaoMaster getDaoMaster() {  
         if (daomaster == null) {  
             DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(context, DB_NAME, null);  
             daomaster = new DaoMaster(helper.getWritableDatabase());  
         }  
         return daomaster;  
     }  
   
   
     /** 
      * 3 数据库会话层DaoSession的创建 
      * 完成对数据库的增删改查的操作，这里仅仅是一个接口。 
      * 
      * @return 
      */  
     public DaoSession getDaoSession() {  
         if (daoSession == null) {  
             if (daomaster == null) {  
                 daomaster = getDaoMaster();  
             }  
             daoSession = daomaster.newSession();  
         }  
         return daoSession;  
     }  
   
   
     /** 
      * 关闭数据库的操作，使用完毕数据库，必须执行此操作。 
      */  
     public void CloseConnection() {  
         CloseHelper();  
         ColseDaoSession();  
     }  
   
     /** 
      * 关闭helper 
      */  
     public void CloseHelper() {  
         if (helper != null) {  
             helper.close();  
             helper = null;  
         }  
     }  
   
     /** 
      * 关闭Session会话层 
      */  
     public void ColseDaoSession() {  
         if (daoSession != null) {  
             daoSession.clear();  
             daoSession = null;  
         }  
     }  
   
   
     /** 
      * 打开输出日志的操作 
      */  
     public void SetDebug() {  
         QueryBuilder.LOG_SQL = true;  
         QueryBuilder.LOG_VALUES = true;  
   
     }  
   
 }  

调用接口实现：实现数据库的增删改查功能

[java]view plaincopy 
   
 package com.example.admin.myapplication.dbManager;  
   
 import android.content.Context;  
 import android.database.Cursor;  
 import android.util.Log;  
   
 import com.example.admin.myapplication.Dao.Student;  
 import com.example.admin.myapplication.Dao.StudentDao;  
   
 import java.util.List;  
   
 import de.greenrobot.dao.query.Query;  
 import de.greenrobot.dao.query.QueryBuilder;  
 import de.greenrobot.dao.query.WhereCondition;  
   
 /** 
  * Created by admin on 2016/5/31. 
  */  
 public class CommitUtils {  
     private DaoManager manager;  
   
     public CommitUtils(Context context) {  
         manager = DaoManager.getInstance();  
         manager.init(context);  
     }  
   
     /** 
      * 完成对数据库表的插入操作 
      * 
      * @param student 
      * @return 
      */  
     public boolean insertStudent(Student student) {  
         boolean flag = false;  
         flag = manager.getDaoSession().insert(student) != -1 ? true : false;  
         return flag;  
     }  
   
     /** 
      * 完成对数据库的多次插入 
      * 
      * @param students 
      * @return 
      */  
     public boolean insertMultStudent(final List<Student> students) {  
         boolean flag = false;  
   
         try { // 启动一个线程，执行多次插入  
   
             manager.getDaoSession().runInTx(new Runnable() {  
                 @Override  
                 public void run() {  
                     for (Student student : students) {  
                         manager.getDaoSession().insertOrReplace(student);  
                     }  
   
                 }  
             });  
             flag = true;  
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
         return flag;  
     }  
   
     /** 
      * 更新对student某一条记录的修改 
      * @param student 
      * @return 
      */  
     public boolean updateStudent(Student student) {  
         boolean flag = false;  
         try {  
             manager.getDaoSession().update(student);  
             flag = true;  
         } catch (Exception e)  
   
         {  
             e.printStackTrace();  
         }  
   
   
         return flag;  
     }  
   
   
     /** 
      * 删除一条数据 
      * @param student 
      * @return 
      */  
     public boolean deleteStudent(Student student) {  
   
         boolean flag = false;  
         try {  
             // 删除一条记录  
             manager.getDaoSession().delete(student);  
   
             flag = true;  
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
 //        manager.getDaoSession().deleteAll(Student.class);  
   
         return flag;  
   
     }  
 //  
   
     /** 
      * 返回多行记录 
      * @return 
      */  
     public List<Student> ListAll() {  
         return manager.getDaoSession().loadAll(Student.class);  
     }  
   
     /** 
      * 按照主键返回单行记录 
      * @param key 
      * @return 
      */  
     public Student ListOneStudent(long key) {  
         return manager.getDaoSession().load(Student.class, key);  
     }  
   
   
     /** 
      * 查询数据 条件查询 
      * @return 
      */  
     public   List<Student> Query1() {  
   
   
       return manager.getDaoSession().queryRaw(Student.class, "where name like ? and _id > ?", new String[]{"%张三%", "2"});  
   
     }  
   
     /** 
      * 查询数据 对于数据库不熟悉可使用这种方式 
      * @return 
      */  
     public List<Student> Query() {  
   
         QueryBuilder<Student> builder = manager.getDaoSession().queryBuilder(Student.class);  
         List<Student> list = builder.where(StudentDao.Properties.Age.between(23, 26))  
                 .where(StudentDao.Properties.Address.like("北京")).list();  
 //        builder.orderAsc(StudentDao.Properties.Age);  
   
        return list;  
     }  
   
 }  

通过上面的两层封装，可以方便的调用GreenDao.

调用代码：

[java]view plaincopy 
   
 package com.example.admin.myapplication;  
   
 import android.os.Bundle;  
   
 import android.support.v7.app.AppCompatActivity;  
 import android.util.Log;  
 import android.view.View;  
   
 import com.example.admin.myapplication.Dao.Student;  
 import com.example.admin.myapplication.dbManager.CommitUtils;  
   
 import java.util.ArrayList;  
 import java.util.List;  
   
   
 public class MainActivity extends AppCompatActivity {  
   
     private static final String TAG="MainActivity";  
     private CommitUtils commitUtils;  
     @Override  
     protected void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.activity_main);  
         commitUtils = new CommitUtils(this);  
     }  
   
     //插入数据  
     public void InsertData(View view) {  
   
         Log.i(TAG, "insert Data");  
         Student student = new Student();  
         student.setAddress("北京");  
         student.setAge(23);  
         student.setId(10001l);  
         student.setName("张三");  
         commitUtils.insertStudent(student);  
   
     }  
   
     //插入多条数据  
     public void InsertMulData(View view) {  
         Log.i(TAG, "insert Mut Data");  
         List<Student> list = new ArrayList<>();  
         for (int i = 0; i < 10; i++) {  
             Student student = new Student();  
             student.setAddress("北京");  
             student.setAge(23 + i);  
 //            student.setId(10001l + i);  
             student.setName("张三");  
             list.add(student);  
         }  
         commitUtils.insertMultStudent(list);  
     }  
   
   
     /** 
      * //更改数据 
      * @param view 
      */  
     public void updataData(View view) {  
         Log.i(TAG, "data Data");  
         Student student = new Student();  
         student.setAge(1000);  
         student.setName("xiaolei");  
         student.setId(1l);  
         student.setAddress("2432");  
         commitUtils.updateStudent(student);  
     }  
   
   
     public void deleteData(View view) {  
         Student student = new Student();  
         student.setId(2l);  
         commitUtils.deleteStudent(student);  
     }  
   
     public void oneList(View view) {  
 //        Student student = commitUtils.ListOneStudent(1);  
         Student student = commitUtils.ListOneStudent(1);  
         Log.i(TAG, student.getName() + "");  
   
     }  
   
     public void mutiList(View view) {  
         List<Student> list = commitUtils.ListAll();  
 //        if(list!=null)  
         Log.i(TAG, list.toString());  
     }  
   
    public  void QueryData(View view){  
 //       List<Student> query = commitUtils.Query();  
   
   
 //       for(int i=0;i<query.size();i++)  
 //       {  
 //          Log.i(TAG, query.get(i).getAge().toString()+" :"+ query.get(i).getId()) ;  
 //       }  
   
        List<Student> students = commitUtils.Query();  
        if(students!=null)  
        for(int i=0;i<students.size();i++) {  
            Log.i(TAG, students.get(i).getAge() + " :" + students.get(i).getId());  
        }  
   
    }  
   
 }  

Session__csdn

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
GreenDao使用

GreenDao是一个关系型数据库，可方便的利用对象操作数据库，更可以利用其ORM的继承特性，整合代码编写。个人感觉就是给对于sql不熟练的我提供一个可以操作数据库的捷径。GreenDao 官方地址：http://greenrobot.org/greendao/GreenDao gitHub地址：https://github.com/greenrobot/greenDAO本
复制链接

扫一扫