Android框架学习之GreenDao（一）

最新推荐文章于 2024-07-19 14:08:52 发布
最新推荐文章于 2024-07-19 14:08:52 发布
阅读量867 收藏 1
点赞数
分类专栏： 框架学习

Giuthub:https://github.com/greenrobot/greenDAO
greenDao官网：http://greenrobot.org/greendao/
greenDao2的引入地址（Github上面已经更新到greenDao3）

一，添加依赖

  1. 在as中导入相关的包
compile'org.greenrobot:greendao:3.0.1'
compile'org.greenrobot:greendao-generator:3.0.0'

2.在build.gradle中进行配置：

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

3.自定义路径

greendao {
    schemaVersion 1
    daoPackage 'com.anye.greendao.gen'
    targetGenDir 'src/main/java'
}

schemaVersion–> 指定数据库schema版本号，迁移等操作会用到;
daoPackage –> dao的包名，包名默认是entity所在的包；
targetGenDir –> 生成数据库文件的目录;
在创建实体类后make工程，相关的master类和session类和dao类都会生成在这个文件下

二，greendao中的注解

(一) @Entity 定义实体
@nameInDb 在数据库中的名字，如不写则为实体中类名
@indexes 索引
@createInDb 是否创建表，默认为true,false时不创建
@schema 指定架构名称为实体
@active 无论是更新生成都刷新
(二) @Id
(三) @NotNull 不为null
(四) @Unique 唯一约束
(五) @ToMany 一对多
(六) @OrderBy 排序
(七) @ToOne 一对一
(八) @Transient 不存储在数据库中
(九) @generated 由greendao产生的构造函数或方法

本文将从 数据库基础接口抽离，greenDao知识，greenDao的个性化基类封装和一个简单示例 为序向各位读者说明一下作者的思路以及实践。

这里写图片描述

数据库操作基础接口

数据库操作无非就是 增、删、改、查、事务，好接下来就可以细化了

这里写图片描述

  • 插入 INSERT
    这里写图片描述
  • 删除 DELETE
    这里写图片描述
  • 改 UPDATE
    这里写图片描述
  • 查询 SELECT
    这里写图片描述
  • 事务 Transaction
    事务 runInTx(Runnable runnable)

三，使用

public interface IDataBase<T,K>{

    boolean insert(T t);

    boolean delete(T t);

    boolean deleteByKey(K k);

    boolean deleteList(List<T> mList);

    boolean deleteByKeyInTx(K... keys);
    //采用事务操作，删除key[ ]中每个key所对应的实体，并返回一个空的Observable

    boolean deleteAll();

    boolean insertOrReplace(@NonNull T t);

    boolean update(T t);

    boolean updateInTx(T... t);

    boolean updateList(List<T> mList);

    T selectByPrimaryKey(K key);

    List<T> loadAll();

    boolean refresh(T t);

    /**
     * 清理缓存
     */
    void clearDaoSession();

    /**
     * Delete all tables and content from our database
     */
    boolean dropDatabase();

    /**
     * 事务
     */
    void runInTx(Runnable runnable);

    /**
     * 添加集合
     *
     * @param mList
     */
    boolean insertList(List<T> mList);

    /**
     * 添加或更新集合
     *
     * @param mList
     */
    boolean insertOrReplaceList(List<T> mList);

    /**
     * 自定义查询
     *
     * @return
     */
    QueryBuilder<T> getQueryBuilder();

    /**
     * @param where
     * @param selectionArg
     * @return
     */
    List<T> queryRaw(String where, String... selectionArg);
}

这里写图片描述
这里写图片描述

public abstract class AbstractDatabaseManager<T,K> implements IDataBase<T,K> {

    private static final String DEFAULT_DATABASE_NAME = Constants.DEFAULT_DB_NAME;

    /**
     * The Android Activity reference for access to DatabaseManager.
     */
    private static DaoMaster.DevOpenHelper mHelper;
    protected static DaoSession daoSession;

    /**
     * 初始化OpenHelper
     * @param context
     */
    public static void initOpenHelper(@NonNull Context context) {
        mHelper = getOpenHelper(context, DEFAULT_DATABASE_NAME);
        openWritableDb();
    }

    /**
     * 初始化OpenHelper     *
     * @param context
     * @param dataBaseName
     */
    public static void initOpenHelper(@NonNull Context context, @NonNull String dataBaseName) {
        mHelper = getOpenHelper(context, dataBaseName);
        openWritableDb();
    }

    public static DaoSession getDaoSession() {
        return daoSession;
    }

    /**     * Query for readable DB     */
    protected static void openReadableDb() throws SQLiteException {
        daoSession = new DaoMaster(getReadableDatabase()).newSession();
    }

    /**     * Query for writable DB     */
    protected static void openWritableDb() throws SQLiteException {
        daoSession = new DaoMaster(getWritableDatabase()).newSession();
    }

    private static SQLiteDatabase getWritableDatabase() {
        return mHelper.getWritableDatabase();
    }

    private static SQLiteDatabase getReadableDatabase() {
        return mHelper.getReadableDatabase();
    }


    /**     * 在applicaiton中初始化DatabaseHelper     */
    private static DaoMaster.DevOpenHelper getOpenHelper(@NonNull Context context, @Nullable String dataBaseName) {
        closeDbConnections();//关闭数据库
        return new DaoMaster.DevOpenHelper(context, dataBaseName, null);//初始化数据库
    }

    /**
     * 只关闭helper就好,看源码就知道helper关闭的时候会关闭数据库
     */
    public static void closeDbConnections() {
        if (mHelper != null) {
            mHelper.close();
            mHelper = null;
        }
        if (daoSession != null) {
            daoSession.clear();
            daoSession = null;
        }
    }

    @Override
    public boolean insert(T t) {
        try {
            if (t == null)
                return false;
            openWritableDb();
            getAbstractDao().insert(t);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean delete(T t) {
        try {
            if (t == null)
                return false;
            openWritableDb();
            getAbstractDao().delete(t);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteByKey(K k) {
        try {
            if (TextUtils.isEmpty(k.toString()))
                return false;
            openWritableDb();
            getAbstractDao().deleteByKey(k);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteList(List<T> mList) {
        try {
            if (mList == null || mList.size() == 0)
                return false;
            openWritableDb();
            getAbstractDao().deleteInTx(mList);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteByKeyInTx(K... keys) {
        try {
            openWritableDb();
            getAbstractDao().deleteByKeyInTx(keys);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteAll() {
        try {
            openWritableDb();
            getAbstractDao().deleteAll();
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean insertOrReplace(@NonNull T t) {
        try {
            if (t == null)
                return false;
            openWritableDb();
            getAbstractDao().insertOrReplace(t);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean update(T t) {
        try {
            if (t == null)
                return false;
            openWritableDb();
            getAbstractDao().update(t);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean updateInTx(T... t) {
        try {
            if (t == null)
                return false;
            openWritableDb();
            getAbstractDao().updateInTx(t);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean updateList(List<T> mList) {
        try {
            if (mList == null || mList.size() == 0)
                return false;
            openWritableDb();
            getAbstractDao().updateInTx(mList);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public T selectByPrimaryKey(K key) {
        try {
            openReadableDb();
            return getAbstractDao().load(key);
        } catch (SQLiteException e) {
            return null;
        }
    }

    @Override
    public List<T> loadAll() {
        openReadableDb();
        return getAbstractDao().loadAll();
    }

    @Override
    public boolean refresh(T t) {
        try {
            if (t == null)
                return false;
            openWritableDb();
            getAbstractDao().refresh(t);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public void clearDaoSession() {
        if (daoSession != null) {
            daoSession.clear();
            daoSession = null;
        }
    }

    @Override
    public boolean dropDatabase() {
        try {
            openWritableDb();
            // DaoMaster.dropAllTables(database, true); // drops all tables
            // mHelper.onCreate(database); // creates the tables
//          daoSession.deleteAll(BankCardBean.class); // clear all elements
            // from
            // a table
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    @Override
    public void runInTx(Runnable runnable) {
        try {
            openWritableDb();
            daoSession.runInTx(runnable);
        } catch (SQLiteException e) {
        }
    }

    @Override
    public boolean insertList(List<T> mList) {
        try {
            if (mList == null || mList.size() == 0)
                return false;
            openWritableDb();
            getAbstractDao().insertInTx(mList);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean insertOrReplaceList(List<T> mList) {
        try {
            if (mList == null || mList.size() == 0)
                return false;
            openWritableDb();
            getAbstractDao().insertOrReplaceInTx(mList);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public QueryBuilder<T> getQueryBuilder() {
        openReadableDb();
        return getAbstractDao().queryBuilder();
    }

    @Override
    public List<T> queryRaw(String where, String... selectionArg) {
        openReadableDb();
        return getAbstractDao().queryRaw(where, selectionArg);
    }

    public Query<T> queryRawCreate(String where, Object... selectionArg) {
        openReadableDb();
        return getAbstractDao().queryRawCreate(where, selectionArg);
    }

    public Query<T> queryRawCreateListArgs(String where, Collection<Object> selectionArg) {
        openReadableDb();
        return getAbstractDao().queryRawCreateListArgs(where, selectionArg);
    }

    /**
     * 设置debug模式开启或关闭，默认关闭
     * @param flag
     */
    public void setDebug(boolean flag){
        QueryBuilder.LOG_SQL = flag;
        QueryBuilder.LOG_VALUES = flag;
    }
    /**
     * 获取Dao
     * @return
     */
    protected abstract AbstractDao<T, K> getAbstractDao();
}

在Application 内初始化 helper:

AbstractDatabaseManager.initOpenHelper(getApplicationContext());//初始化数据库

实体类：

@Entity(nameInDb = "NOTE")
public class Note {
    @Id
    private Long id;

    @NotNull
    private String text;
    private String content;
    private java.util.Date date;

    @Generated(hash = 1272611929)
    public Note() {
    }

    public Note(Long id) {
        this.id = id;
    }

    @Generated(hash = 1657551704)
    public Note(Long id, @NotNull String text, String content, java.util.Date date) {
        this.id = id;
        this.text = text;
        this.content = content;
        this.date = date;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    @NotNull
    public String getText() {
        return text;
    }

    /** Not-null value; ensure this value is available before it is saved to the database. */
    public void setText(@NotNull String text) {
        this.text = text;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public java.util.Date getDate() {
        return date;
    }

    public void setDate(java.util.Date date) {
        this.date = date;
    }
}

实际类：

public class NoteDbManager extends AbstractDatabaseManager<Note,Long> {

    @Override
    public AbstractDao<Note, Long> getAbstractDao() {
        return daoSession.getNoteDao();
    }
}

调用：

new NoteDbManager().insert(note);
new NoteDbManager().setDebug(true);
new NoteDbManager().delete(note);

第二种

public class BaseDao<T> {

    public static final String TAG = BaseDao.class.getSimpleName();
    public static final boolean DUBUG = true;
    public DaoManager manager;
    public DaoSession daoSession;

    public BaseDao(Context context) {
        manager = DaoManager.getInstance();
        manager.init(context);
        daoSession = manager.getDaoSession();
        manager.setDebug(DUBUG);
    }
    /**************************数据库插入操作***********************/
    /**
     * 插入单个对象
     * @param object
     * @return
     */
    public boolean insertObject(T object){
        boolean flag = false;
        try {
            flag = manager.getDaoSession().insert(object) != -1 ? true:false;
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
        return flag;
    }
    /**
     * 插入多个对象，并开启新的线程
     * @param objects
     * @return
     */
    public boolean insertMultObject(final List<T> objects){
        boolean flag = false;
        if (null == objects || objects.isEmpty()){
            return false;
        }
        try {
            manager.getDaoSession().runInTx(new Runnable() {
                @Override
                public void run() {
                    for (T object : objects) {
                        manager.getDaoSession().insertOrReplace(object);
                    }
                }
            });
            flag = true;
        } catch (Exception e) {
            Log.e(TAG, e.toString());
            flag = false;
        }finally {
//            manager.CloseDataBase();
        }
        return flag;
    }
    /**************************数据库更新操作***********************/
    /**
     * 以对象形式进行数据修改
     * 其中必须要知道对象的主键ID
     * @param object
     * @return
     */
    public void  updateObject(T object){
        if (null == object){
            return ;
        }
        try {
            manager.getDaoSession().update(object);
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
    }
    /**
     * 批量更新数据
     * @param objects
     * @return
     */
    public void updateMultObject(final List<T> objects, Class clss){
        if (null == objects || objects.isEmpty()){
            return;
        }
        try {
            //反射
            daoSession.getDao(clss).updateInTx(new Runnable() {
                @Override
                public void run() {
                    for(T object:objects){
                        daoSession.update(object);
                    }
                }
            });
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
    }

    /**************************数据库删除操作***********************/
    /**
     * 删除某个数据库表
     * @param clss
     * @return
     */
    public boolean deleteAll(Class clss){
        boolean flag = false;
        try {
            manager.getDaoSession().deleteAll(clss);
            flag = true;
        } catch (Exception e) {
            Log.e(TAG, e.toString());
            flag = false;
        }
        return flag;
    }
    /**
     * 删除某个对象
     * @param object
     * @return
     */
    public void deleteObject(T object){
        try {
            daoSession.delete(object);
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
    }

    /**
     * 异步批量删除数据
     * @param objects
     * @return
     */
    public boolean deleteMultObject(final List<T> objects, Class clss){
        boolean flag = false;
        if (null == objects || objects.isEmpty()){
            return false;
        }
        try {

            daoSession.getDao(clss).deleteInTx(new Runnable() {
                @Override
                public void run() {
                    for(T object:objects){
                        daoSession.delete(object);
                    }
                }
            });
            flag = true;
        } catch (Exception e) {
            Log.e(TAG, e.toString());
            flag = false;
        }
        return flag;
    }


    /**************************数据库查询操作***********************/

    /**
     * 获得某个表名
     * @return
     */
    public String getTablename(Class object){
        return daoSession.getDao(object).getTablename();
    }

    /**
     * 查询某个ID的对象是否存在
     * @param
     * @return
     */
    public boolean isExitObject(long id,Class object){
        QueryBuilder<T> qb = (QueryBuilder<T>) daoSession.getDao(object).queryBuilder();
        qb.where(CustomerDao.Properties.Id.eq(id));
        long length = qb.buildCount().count();
        return length>0 ? true:false;
    }

    /**
     * 根据主键ID来查询
     * @param id
     * @return
     */
    public T QueryById(long id,Class object){
        return (T) daoSession.getDao(object).loadByRowId(id);
    }


    /**
     * 查询某条件下的对象
     * @param object
     * @return
     */
    public List<T> QueryObject(Class object,String where,String...params){
        Object obj = null;
        List<T> objects = null;
        try {
            obj = daoSession.getDao(object);
            if (null == obj){
                return null;
            }
            objects = daoSession.getDao(object).queryRaw(where,params);
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
        return objects;
    }

    /**
     * 查询所有对象
     * @param object
     * @return
     */
    public List<T> QueryAll(Class object){
        List<T> objects = null;
        try {
            objects = (List<T>) daoSession.getDao(object).loadAll();
        } catch (Exception e) {
            Log.e(TAG,e.toString());
        }
        return objects;
    }

    /***************************关闭数据库*************************/
    /**
     * 关闭数据库一般在Odestory中使用
     */
    public void CloseDataBase(){
        manager.closeDataBase();
    }

public class NoteBase extends BaseDao<Note> {

    public NoteBase(Context context) {
        super(context);
    }

    @Override
    public boolean insertObject(Note object) {
        return super.insertObject(object);
    }
}
/**
 * Created by hzf on 2016/12/15 0015.
 * 进行数据库的管理
 * 1.创建数据库
 * 2.创建数据库表
 * 3.对数据库进行增删查改
 * 4.对数据库进行升级
 */
public class DaoManager {
    private static  final String  TAG = DaoManager.class.getSimpleName();
    private static  final String  DB_NAME="note";//数据库名称
    private volatile  static DaoManager mDaoManager;//多线程访问
    private  static DaoMaster.DevOpenHelper mHelper;
    private static  DaoMaster mDaoMaster;
    private static DaoSession mDaoSession;
    private static SQLiteDatabase db;
    private Context context;
    /**
     * 使用单例模式获得操作数据库的对象
     * @return
     */
    public  static DaoManager getInstance(){
        DaoManager instance = null;
        if (mDaoManager==null){
            synchronized (DaoManager.class){
                if (instance==null){
                    instance = new DaoManager();
                    mDaoManager = instance;
                }
            }
        }
        return mDaoManager;
    }

    /**
     * 初始化Context对象
     * @param context
     */
    public void init(Context context){
        this.context = context;
    }

    /**
     * 判断数据库是否存在，如果不存在则创建
     * @return
     */
    public DaoMaster getDaoMaster(){
        if (null == mDaoMaster){
            mHelper =  new DaoMaster.DevOpenHelper(context,DB_NAME,null);
            mDaoMaster = new DaoMaster(mHelper.getWritableDatabase());
        }
        return mDaoMaster;
    }

    /**
     * 完成对数据库的增删查找
     * @return
     */
    public DaoSession getDaoSession(){
        if (null == mDaoSession){
            if (null == mDaoMaster){
                mDaoMaster = getDaoMaster();
            }
            mDaoSession = mDaoMaster.newSession();
        }
        return mDaoSession;
    }

    /**
     * 设置debug模式开启或关闭，默认关闭
     * @param flag
     */
    public void setDebug(boolean flag){
        QueryBuilder.LOG_SQL = flag;
        QueryBuilder.LOG_VALUES = flag;
    }

    /**
     * 关闭数据库
     */
    public void closeDataBase(){
        closeHelper();
        closeDaoSession();
    }

    public void closeDaoSession(){
        if (null != mDaoSession){
            mDaoSession.clear();
            mDaoSession = null;
        }
    }

    public  void  closeHelper(){
        if (mHelper!=null){
            mHelper.close();
            mHelper = null;
        }
    }

}
new NoteBase(this).deleteObject(note);
new NoteBase(this).insertObject(note);

第三种

/**
 * Created by hzf on 2016/12/14 0014.
 * 单例模式适用场合
 * 需要频繁的进行创建和销毁的对象；
 * 创建对象时耗时过多或耗费资源过多，但又经常用到的对象；
 * 工具类对象；
 * 频繁访问数据库或文件的对象。
 */

public class GreenDaoManager {
   private  static  GreenDaoManager mInstance;
   private DaoMaster daoMaster;
   private DaoSession daoSession;
   private  GreenDaoManager(){
       DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(BaseApplication.getContext(),Constants.DB_NAME,null);
      daoMaster = new DaoMaster(helper.getWritableDatabase());
      daoSession = daoMaster.newSession();
   }
   //懒汉式(线程不安全)[不可用]
   public  static  GreenDaoManager getInstance(){
       if (mInstance == null) {
           mInstance = new GreenDaoManager();
       }
       return  mInstance;
   }
   //懒汉式，同步方法（不推荐）
   public static synchronized  GreenDaoManager getInstance4(){
       if (mInstance == null) {
           mInstance = new GreenDaoManager();
       }
       return  mInstance;
   }
   //懒汉式，双重检查[推荐用]
   public  static  GreenDaoManager getInstance2(){
       if(mInstance == null){
           synchronized (GreenDaoManager.class){
               if(mInstance == null){
                   mInstance = new GreenDaoManager();
               }
           }
       }
       return  mInstance;
   }
   //静态内部类[推荐用]
   private static class GreenDaoManagerInstance {
        private static final GreenDaoManager INSTANCE = new GreenDaoManager();
   }
   public  static  GreenDaoManager  getInstance3(){
       return GreenDaoManagerInstance.INSTANCE;
   }

    /**
     * 判断数据库是否存在，如果不存在则创建
     * @return
     */
//   public DaoMaster getDaoMaster() {
//       if(daoMaster == null) {
//           helper = new DaoMaster.DevOpenHelper(BaseApplication.getContext(),Constants.DB_NAME,null);
//           daoMaster = new DaoMaster(helper.getWritableDatabase());
//       }
//       return daoMaster;
//    }

//    /**
//     * 完成对数据库的增删查找
//     * @return
//     */
    public DaoSession getDaoSession() {
//        if(daoSession == null){
//           if(daoMaster == null){
//              daoMaster = getDaoMaster();
//           }
//           daoSession = daoMaster.newSession();
//        }
        return daoSession;
    }

    public  DaoSession getNewDaoSession(){
        daoSession = daoMaster.newSession();
        return daoSession;
    }
    /**
     * 设置debug模式开启或关闭，默认关闭
     * @param flag
     */
    public void setDebug(boolean flag){
        QueryBuilder.LOG_SQL = flag;
        QueryBuilder.LOG_VALUES = flag;
    }
    /**
     * 关闭数据库
     */
    public void closeDataBase(){
        closeHelper();
        closeDaoSession();
    }

    public void closeDaoSession(){
        if (null != daoSession){
            daoSession.clear();
            daoSession = null;
        }
    }

    public  void  closeHelper(){
//        if (helper!=null){
//            helper.close();
//            helper = null;
//        }
    }
}
 GreenDaoManager.getInstance2().getDaoSession().getNoteDao().insert(note);

上面的三种写法只是对不同层进行的分装，主要思想还是直接将dao层接口抽离出来操作，让结构更加合理。

文章部分内容转自博客：http://blog.csdn.net/sinat_15877283/article/details/51098477

hzflogo
关注
专栏目录
greenDAO 查询
hcq__yy的专栏
11-18 1426
greenDAO、OrmLite、ActiveAndroid的对比图 3、支持加密 三、greenDAO集成 1、设置仓库与插件（Project： build.gradle） 1 buildscript {2 repositories {3 jcenter()4 mavenCentral() // add repository5 }6 depen...
Android数据库框架GreenDao封装使用，易理解、易扩展
04-13
GreenDao是一个流行的ORM（对象关系映射）框架，它使得Java对象与SQLite数据库之间的交互变得简单易行。本资源提供了一份关于如何封装和使用GreenDao的教程，特别适合初学者以及希望提升数据库操作效率的开发者。 ...
Android学习之——自己搭建Http框架(2)——框架扩展
Mr.傅的专栏
05-23 2568
· 本文主要讲解的是Json指定转化成对象返回，下载进度更新，随时取消Request请求 一、Json指定转化成对象返回        上篇文章主要讲基础的框架搭建起来了，这次需要做一些些的扩展，这里Json转化用到了google的Gson。         上篇文章，我们直接返回了String的字符串，那么如果是请求返回回来的是Json格式的，我们能否在数据返回的时候将数据转化成需
【Git】（基础篇四）—— GitHub使用
最新发布
牧夏的个人博客
07-19 4917
GitHub使用经过上一篇的文章，相信大家已经对git的熟悉了，但哪些使用git的方法只是在本地仓库进行，本文介绍如何使用git和远程仓库进行连接使用。
Android平台框架学习
weixin_34106122的博客
04-12 1935
2019独角兽企业重金招聘Python工程师标准>>> ...
Android系统框架学习
haofeng_ma的博客
03-03 824
Android系统框架 下图为一张Google官方提供的经典分层架构图，从下往上依次分为Linux内核层、硬件抽象层HAL、系统运行库层、应用程序框架层以及应用程序层这5层架构，其中每一层都包含大量的子模块或子系统。 Linux内核层 Android的底层是基于Linux操作系统的。从严格意义上来讲，它属于Linux操作系统的一个变种。Android选择在Linux内核的基础上来搭建自己的运行平台有几个好处。首先，避开了与硬件直接打交道。Li...
Android 框架学习（1）—— 系统架构
hezhanran的博客
04-21 622
        最近由于工作需要，开始接触Android 8.0架构，以前做过几款简单的Android应用，但是对于底层架构这方面的知识完全是小白，所以得从头学起，网络上对于Android 8.0架构的内容很多，但更多的是基于应用方面的内容，这里边学习边做些笔记，好记性不如烂笔头，开始吧。 一、系统架构  ...
Android greenDAO 数据库 简单学习之基本使用
05-07
**Android greenDAO 数据库 简单学习之基本使用** 在Android开发中，数据库操作是不可或缺的一部分，而greenDAO作为一款高效、轻量级的对象关系映射（ORM）框架，可以简化我们对SQLite数据库的操作。它允许开发者...
Android-greenDAO是一个轻量和快速的AndroidORM框架
08-12
综上所述，greenDAO作为Android开发中的一个强大ORM框架，极大地简化了Android应用与SQLite数据库的交互，提升了开发效率和应用性能。通过熟练掌握greenDAO，开发者可以更专注于业务逻辑，而非底层数据库操作。
Android_ORM框架_GreenDao
08-09
GreenDao是Android平台上广泛使用的ORM框架之一，尤其受到开发者青睐。本文将深入探讨GreenDao的特性、使用方法以及如何在实际项目中集成和应用。 GreenDao 3.2.2是其最新的稳定版本，它提供了一系列优化和改进，以...
Android应用源码之greenDAO-master_应用.zip
09-03
**绿色DAO（GreenDAO）是Android平台上一个流行的ORM（对象关系映射）框架，它使得在Android应用中操作SQLite数据库变得更加简单。通过使用GreenDAO，开发者可以将Java对象直接映射到数据库表，从而避免了繁琐的SQL...
Android初学之路—Android系统框架
李伟驰的博客
08-21 497
从下到上依次为： 1.Linux内核（Linux Kernel） Android系统的最底层是基于Linux内核实现的，它负责硬件驱动、网络管理、电源管理、系统安全、内存管理等。例如它可以负责显示驱动、基于Linux的帧缓存驱动、键盘驱动、Flash驱动、摄像头驱动、音频视频驱动、WiFi驱动等。 2. Android核心类库（Libraries） Android系...
Android接口和框架学习
LoongEmbedded的专栏
01-10 4143
Android接口和框架学习缩写：HAL：HardwareAbstraction Layer，硬件抽象层CTS：CompatibilityTest Suite，兼容性测试套件 Android让你能够自由实现设备规格和驱动，HAL提供一套标准方法来在Android平台栈(platform stack)和硬件之间创建软件钩子(hook)，Android系统是开源的，你可以贡献自己的接口和增加功能。 为
Android 网络框架学习一（必备的功能）
黑夜骑士
12-26 289
android请求接口一般是短连接的http请求方式 一个完整框架需要具备有同步和异步，get post方式，图片，流文件等上传的功能，即对外要暴露这些接口。那么在代码设计时需要考虑到封装好这些方法。 查看这个接口类 /** * 网络请求工具接口 * @author zhousf */ public interface OkHttpUtilInterface { /** ...
GreenDao简明教程（查询，Querying）
热门推荐
技海拾贝
01-15 5万+
6.查询 查询接口返回符合指定条件的实体对象集合.你可以使用SQL组织你的查询语句，或者采用更好的方法，使用greenDao的QueryBuilder API.greenDao的查询也支持延迟加载结果，当结果集很大的时候，它会节省内存和提高性能. 6.1QueryBuilder QueryBuilder类让你不需要写SQL来构建查询条件.写SQL大多数人都不喜欢，并且容易出错，因
Android的常用框架，Android开发必须掌握
Python毕设源码程序王哥
03-25 1348
由于本文罗列的知识点是根据我自身总结出来的，并且由于本人水平有限，无法全部提及，欢迎大神们能补充~将来我会对上面的知识点一个一个深入学习，也希望有童鞋跟我一起学习，一起进阶。提升架构认知不是一蹴而就的，它离不开刻意学习和思考。**这里，笔者分享一份从架构哲学的层面来剖析的视频及资料分享给大家，**梳理了多年的架构经验，筹备近1个月最新录制的，相信这份视频能给你带来不一样的启发、收获。点击这里获取免费架构视频资料，第一时间获取最新知识点。
Android百大框架学习计划和状况
Dimen-zhou的博客
06-23 651
1：Retrofit  网络 （安全网络框架，基于HTTP协议。专注封装接口完成业务需求） 学习方向应用，原理： 状况： 2：OKhttp 网络（专注网络请求安全高效） 3：ButterKnife 代码模板 4：MPAndroidChart 图表 5：glide 图片加载 6：fresco 图片加载 7：Android-Universal-lmage-Loader 图片加载 8：
【安卓面试】Android三方框架原理学习笔记
weixin_41802023的博客
07-29 1692
Android面试必备！常见三方框架原理重点解析
一文解决Android framework从入门到精通【大龄程序员必看】
zzz777qqq的博客
05-14 1277
学习是一个长期坚持的过程，为大家整理了一份PDF文档，里面涵盖了学习Android framework的方方面面，比如Binder、Handler、系统启动流程、AMS、WMS、PKMS核心源码解析，不仅仅停留在app应用层开发。文章篇幅有限，无法一一展示，有需要的朋友可以扫描下方二维码，免费获取相关资料。
绿色道路：GreenDAO入门与高效Android ORM实践
GreenDAO是一款针对Android平台的...选择GreenDAO作为Android ORM框架能极大地简化数据库操作，提高开发效率，并在性能和内存管理方面提供显著的优势。但同时，开发者也应理解其适用场景和局限性，以便做出最佳决策。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值