GreenDao3.x的简单使用

GreenDao 介绍:
greenDAO是一个对象关系映射(ORM)的框架,能够提供一个接口通过操作对象的方式去操作关系型数据库,它能够让你操作数据库时更简单、更方便。如下图所示:
官网地址:http://greenrobot.org/greendao/
Github地址:https://github.com/greenrobot/greenDAO
GreenDao 3.x使用
GreenDao 3.x采用注解的方式来定义实体类,通过gradle插件生成相应的代码。
****一、在as项目中添加配置****
一、先项目的Project 的 build.gradle 里添加

buildscript { 
    repositories { 
        mavenCentral() 
    } 
    dependencies { 
        classpath 'org.greenrobot:greendao-gradle-plugin:3.2.0' 
    }
}
apply plugin: 'org.greenrobot.greendao'
dependencies { 
     compile 'org.greenrobot:greendao:3.2.0'
}

二、 新建一个java module选择java library,并在新建lib的build.gradle 里添加

dependencies {
compile fileTree(include: ['*.jar'],dir:'libs')
compile'org.greenrobot:greendao-generator:3.2.0'
}

schemaVersion: 数据库schema版本,也可以理解为数据库版本号
daoPackage:设置DaoMaster、DaoSession、Dao包名
targetGenDir:设置DaoMaster、DaoSession、Dao目录
targetGenDirTest:设置生成单元测试目录
generateTests:设置自动生成单元测试用例
****二、生成数据库表,直接上代码****

public static void main(String[] args) {    //生成数据库的实体类    
    Schema schema = new Schema(1, "com.dralong.entity");        
    addDb(schema);    //创建数据库dao层        
    schema.setDefaultJavaPackageDao("com.dralong.dao");   
     try {        //生成到java-gen文件夹下        
    new DaoGenerator().generateAll(schema, "E:\\AndroidWork\\BookEntry\\app\\src\\main\\java-gen");    
    } catch (Exception e) { 
       e.printStackTrace();    
    }
}

private static void addDb(Schema schema) {    
    Entity entity = schema.addEntity("Type");//创建表                    
    entity.addIdProperty();//primary key   
    entity.addStringProperty("name");   
    entity.addStringProperty("nickname");   

    Entity detail = schema.addEntity("Detail");//创建表   
    detail.addIdProperty();//primary key   
    detail.addStringProperty("name");    
    detail.addStringProperty("typeName");    
    detail.addFloatProperty("money");    
    detail.addDateProperty("time");    
    Property IncomeAndExpenses_Id = entity.addLongProperty("type_Id").notNull().getProperty();    //添加一对一外键关联
    detail.addToOne(entity, IncomeAndExpenses_Id);
}

运行main方法自动生成数据库实体类代码
****三、封装以及使用****
一、封装application方便使用

public class BaseApp extends Application {    
      public DaoSession daoSession;   
      public SQLiteDatabase db;  
      public DaoMaster.DevOpenHelper helper;    
      public DaoMaster daoMaster;    

      @Override    
      public void onCreate() {        
          super.onCreate();        
          setupDatabase();    
      }   
      private void setupDatabase() {        
        // 通过 DaoMaster 的内部类 DevOpenHelper,你可以得到一个便利的 SQLiteOpenHelper 对象。       
        // 可能你已经注意到了,你并不需要去编写「CREATE TABLE」这样的 SQL 语句,因为 greenDAO 已经帮你做了。        
        // 注意:默认的 DaoMaster.DevOpenHelper 会在数据库升级时,删除所有的表,意味着这将导致数据的丢失。        
        // 所以,在正式的项目中,你还应该做一层封装,来实现数据库的安全升级。        
        helper = new DaoMaster.DevOpenHelper(this, Constants.DB_NAME, null);        
        db = helper.getWritableDatabase();        
        // 注意:该数据库连接属于 DaoMaster,所以多个 Session 指的是相同的数据库连接。        
        daoMaster = new DaoMaster(db);        
        daoSession = daoMaster.newSession();    
      }    
      public DaoSession getDaoSession() {        
                 return daoSession;    
      }    
      public SQLiteDatabase getDb() {        
                return db;    
      }
}

封装manager

/** 
* 1、创建数据库
* 2、创建数据库表 
* 3、包含对数据库的CRUD 
* 4、对数据库的升级 
*/
public class DaoManager {    
    private static final String TAG = DaoManager.class.getSimpleName();            
    private static volatile DaoManager manager;    
    private static DaoMaster.DevOpenHelper helper;    
    private static DaoSession daoSession;    
    private Context mContext;    
    private DaoManager(Context context) {        
        this.mContext = context;    
    }    
    public static DaoManager getInstance(Context context) {        
        if (manager == null) {            
            synchronized (DaoManager.class) {                
                if (manager == null) {                    
                    manager = new DaoManager(context);               
                 }            
              }        
        }        
        return manager;    
    }    
    private static DaoMaster daoMaster;    
    //判断是否存在数据库,没有就创建    
    public DaoMaster getDaoMaster() {        
        if (daoMaster == null) {            
            helper = new DaoMaster.DevOpenHelper(mContext, Constants.DB_NAME, null);            
            daoMaster = new DaoMaster(helper.getWritableDb());        
        }        
        return daoMaster;    
    }   
    //   数据处理       
    public DaoSession getDaoSession() {        
        if (daoSession == null) {            
            if (daoMaster == null) {                
                daoMaster = getDaoMaster();            
            }            
            daoSession = daoMaster.newSession();        
        }        
        return daoSession;    
    }       
    //输出日志        
    public void setDebug() {        
        QueryBuilder.LOG_SQL = true;        
        QueryBuilder.LOG_VALUES = true;    
    }    
    public void close() {        
        closeHelper();        
        closeSession();    
    }    
    public void closeHelper() {        
        if (helper != null) {            
            helper.close();            
            helper = null;        
        }    
    }    
    //关闭session     
    public void closeSession() {        
        if (daoSession != null) {            
          daoSession.clear();            
          daoSession = null;        
        }    
    }
}

对数据库操作增删改查

class DaoHelper {    
    private DaoManager manager;    
    private Class clazz;    
    public DaoHelper(Context context) {        
        manager = DaoManager.getInstance(context);    
    }    
    private Class getClazz() {        
        if (clazz == null) {//获取泛型的Class对象            
            clazz = ((Class) (((ParameterizedType) (this.getClass().getGenericSuperclass())).getActualTypeArguments()[0]));        
        }        
        return clazz;    
    }    
    // 插入增加   
    public boolean insert(T t) {       
     return manager.getDaoSession().insert(t) != -1 ? true : false;    
    }    
    //插入集合    
    public boolean insertList(final List datas) {        
        boolean flag = false;        
        try {            
            manager.getDaoSession().runInTx(new Runnable() {                
                @Override                
                public void run() {                    
                    for (T t : datas) {                        
                        manager.getDaoSession().insertOrReplace(t);                    
                    }                
                  }            
                });            
                flag = true;        
            } catch (Exception e) {            
                e.printStackTrace();        
            }        
        return flag;    
    }    
    //删除        
    public boolean delete(T t) {       
     try {           
       manager.getDaoSession().delete(t);           
       return true;       
     } catch (Exception e) {           
       e.printStackTrace();       
     }       
     return false;    
    }    
    // 删除所有     
    public boolean deleteAll() {        
        try {            
            manager.getDaoSession().deleteAll(clazz);            
            return true;        
        } catch (Exception e) {            
            e.printStackTrace();        
        }        
        return false;    
    }    
    //列出所有        
    public List listAll() {        
        return (List) manager.getDaoSession().loadAll(getClazz());    
    }    
    public T find(long id) {        
        return manager.getDaoSession().load(clazz, id);    
    }    
    //更新        
    public boolean update(T t) {        
        try {            
            manager.getDaoSession().update(t);            
            return true;        
        } catch (Exception e) {            
            e.printStackTrace();        
        }        
        return false;    
     }    
    //queryRaw查询       
    public List queryAll(String where, String... selectionArgs) {        
        List list = manager.getDaoSession().queryRaw(clazz, where, selectionArgs);        
        return list;   
     }    
    //biuld查询        
     public List queryBuilder() {       
         List list = manager.getDaoSession().queryBuilder(clazz)                .list();       
         return list;   
     }     
    //查询全部,dao查询 
    public List queryDaoAll(Class clazz) {       
         DaoMaster daoMaster = manager.getDaoMaster();        
        DaoSession session = daoMaster.newSession();        
        List list = session.loadAll(clazz);       
         return list;   
     }
}

你可能感兴趣的:(GreenDao3.x的简单使用)