1、GreenDao封装后使用

最新推荐文章于 2024-04-20 15:31:22 发布
最新推荐文章于 2024-04-20 15:31:22 发布
阅读量1.8k 收藏 1
点赞数
分类专栏： android开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IKNOWNU/article/details/52107009
版权

DaoManager

/**
 * 1、创建数据库
 * 2、创建数据库的表
 * 3、包含对数据库的CRUD
 * 4、对数据库的升级
 */
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;

    /**
     * 使用单例模式获得操作数据库的对象
     * @return
     */
    public  static DaoManager getInstance(){
       DaoManager instance = null;
        if (manager==null){
            synchronized (DaoManager.class){
                if (instance==null){
                    instance = new DaoManager();
                    manager = instance;
                }
            }
        }
        return instance;
    }

    public void init(Context context){
        this.context = context;
    }
    /**
     * 判断是否存在数据库，如果没有则创建数据库
     * @return
     */
    public DaoMaster getDaoMaster(){
        if (daoMaster==null){
            DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(context,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 void setDebug(){
        QueryBuilder.LOG_SQL = true;
        QueryBuilder.LOG_VALUES = true;
    }

    /**
     * 关闭所有的操作,数据库开启的时候，使用完毕了必须要关闭
     */
    public void closeConnection(){
        closeHelper();
        closeDaoSession();
    }
    public  void  closeHelper(){
        if (helper!=null){
            helper.close();;
            helper = null;
        }
    }
    public void closeDaoSession(){
        if (daoSession!=null){
            daoSession.clear();;
            daoSession = null;
        }
    }
}

CommonUtils

/**
 * 完成对某一张表的具体操作,ORM 操作的是对象，Student
 */
public class CommonUtils {
    private DaoManager manager;

    public CommonUtils(Context context) {
        manager = DaoManager.getInstance();
        manager.init(context);
    }

    /**
     * 完成对数据库中student 表的插入操作
     *
     * @param student
     * @return
     */
    public boolean insertStudent(Student student) {
        boolean flag = false;

        flag = manager.getDaoSession().insert(student) != -1 ? true : false;
        Log.i("CommonUtils", "----insertStudent--result is -->>" + flag);
        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 {
            //按照指定的id进行删除 delete from student where _id = ?
            manager.getDaoSession().delete(student);
            //manager.getDaoSession().deleteAll();//删除所有的记录
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     *
     */
    public void deleteAllStudent(Class cls){
        manager.getDaoSession().deleteAll(cls);
    }
    /**
     * 返回多行记录
     *
     * @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);
    }

    public void query1() {
        //使用native sql进行查询操作，
        List<Student> list = manager.getDaoSession().queryRaw(Student.class, " where name like ? and _id > ? ", new String[]{"%李%", "1002"});
        Log.i("--->>", "" + list);
    }

    /**
     * select  * from student where name like ? or name =? or
     * <  <= >= !=  in between and
     * select * from student where age > 23 and address like "江西"
     */
    public void query2() {
        //查询构建器
        QueryBuilder<Student> builder = manager.getDaoSession().queryBuilder(Student.class);
        List<Student> list = builder.where(StudentDao.Properties.Age.ge(23)).where(StudentDao.Properties.Address.like("江西")).list();
        Log.i("--->>", "" + list);
    }

    public void query3() {

        //逻辑与 和 逻辑或 是双目运算符
       QueryBuilder<Student> builder = manager.getDaoSession().queryBuilder(Student.class);
        //select * from student where (address='北京' or age > 50) and name like '%张%'
        builder.whereOr(StudentDao.Properties.Address.eq("北京"), StudentDao.Properties.Age.ge(50));
        builder.whereOr(StudentDao.Properties.Id.ge(2), StudentDao.Properties.Age.ge(10)).limit(3);//区前三条数据

        //builder.where(StudentDao.Properties.Name.like("张"));
        List<Student> list = builder.list();
        Log.i("--->>", "" + list);
    }

}

MainActivity

public class MainActivity extends ActionBarActivity {

    private static final String TAG = "MainActivity";

    private CommonUtils commonUtils;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        commonUtils = new CommonUtils(this);
    }

    //插入数据库的操作
    public void insertData(View view) {
        Log.i(TAG, "insert Data");
        Student student = new Student();
        student.setAddress("江西");
        student.setName("李四");
        student.setAge(24);
//        student.setId(1001l);
        commonUtils.insertStudent(student);
    }

    public void insertMultData(View view) {
        Log.i(TAG, "insert mult Data");
        List<Student> list = new ArrayList<>();
        Student student1 = new Student();
        student1.setAge(23);
        student1.setName("张三");
        student1.setAddress("北京育知同创科技有限公司");


        Student student2 = new Student();
        student2.setAge(45);
        student2.setName("李四");
        student2.setAddress("北京");


        Student student3 = new Student();
        student3.setAge(56);
        student3.setName("张学友");
        student3.setAddress("杭州");

        Student student4 = new Student();
        student4.setAge(12);
        student4.setName("刘德华");
        student4.setAddress("香港");

        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student4);

        commonUtils.insertMultStudent(list);//插入多条数据

    }

    public void updateData(View view) {
        //update student set name='jack' where id = 1001;
        Student student = new Student();
        student.setId(1001l);
        student.setAge(100);
        student.setName("jack");
        student.setAddress("北京育知同创科技有限公司");
        commonUtils.updateStudent(student);
    }

    public void deleteData(View view) {
//        Student student = new Student();
//        student.setId(1001l);
        //delete from student where _id = 1001;
        commonUtils.deleteAllStudent(Student.class);

    }

    public void queryOneORMore(View view) {
//        List<Student> list =  commonUtils.listAll();
//        Log.i(TAG,list.toString());
        // Log.i(TAG, commonUtils.listOneStudent(1001l) + "");
        commonUtils.query3();
    }

    /**
     * 使用复合条件进行查询
     *
     * @param view
     */
    public void queryBuilder(View view) {
        commonUtils.deleteAllStudent(Student.class);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="cn.data.laoluo.greendao_projects.MainActivity">


    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="添加数据"
        android:id="@+id/button"
        android:layout_alignParentTop="true"
        android:layout_alignParentStart="true"
        android:layout_alignParentEnd="true"
        android:onClick="insertData"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="添加多条记录"
        android:id="@+id/button2"
        android:layout_below="@+id/button"
        android:layout_alignParentStart="true"
        android:layout_alignEnd="@+id/button"
        android:onClick="insertMultData"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="修改一条数据"
        android:id="@+id/button3"
        android:layout_below="@+id/button2"
        android:layout_alignParentStart="true"
        android:layout_alignEnd="@+id/button2"
        android:onClick="updateData"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="删除单条记录"
        android:id="@+id/button4"
        android:layout_below="@+id/button3"
        android:layout_alignParentStart="true"
        android:layout_alignEnd="@+id/button3"
        android:onClick="deleteData"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="查询单行/多行记录"
        android:id="@+id/button5"
        android:layout_below="@+id/button4"
        android:layout_alignParentStart="true"
        android:layout_alignEnd="@+id/button4"
        android:onClick="queryOneORMore"
        />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="使用QueryBuilder查询"
        android:id="@+id/button6"
        android:layout_centerVertical="true"
        android:layout_alignParentStart="true"
        android:layout_alignEnd="@+id/button5"
        android:onClick="queryBuilder"
        />
</RelativeLayout>

使用的Java代码：

public class DaoMaker {


    public static  void  main(String[] args){

        //生成数据库的实体类XXentity 对应的是数据库的表
        Schema schema = new Schema(1,"com.student.entity");
        addStudent(schema);
        schema.setDefaultJavaPackageDao("com.student.dao");
        try{
            new DaoGenerator().generateAll(schema,"/Users/luoliwen/AndroidStudioProjects/GreenDao_Projects/app/src/main/java-gen");
        }catch(Exception e){
           e.printStackTrace();
        }


    }

    //创建数据库的表
    private static  void addStudent(Schema schema){
        Entity entity  =schema.addEntity("Student");//创建数据库的表
        entity.addIdProperty();//主键 是 int类型
        entity.addStringProperty("name");//对应的数据库的列
        entity.addStringProperty("address");//对应的数据库的列
        entity.addIntProperty("age");//对应的数据库的列
    }
}

利用GreenDao自动生成的代码如下：

dao包下

/** 
 * Master of DAO (schema version 1): knows all DAOs.
*/
public class DaoMaster extends AbstractDaoMaster {
    public static final int SCHEMA_VERSION = 1;

    /** Creates underlying database table using DAOs. */
    public static void createAllTables(SQLiteDatabase db, boolean ifNotExists) {
        StudentDao.createTable(db, ifNotExists);
    }
    
    /** Drops underlying database table using DAOs. */
    public static void dropAllTables(SQLiteDatabase db, boolean ifExists) {
        StudentDao.dropTable(db, ifExists);
    }
    
    public static abstract class OpenHelper extends SQLiteOpenHelper {

        public OpenHelper(Context context, String name, CursorFactory factory) {
            super(context, name, factory, SCHEMA_VERSION);
        }

        @Override
        public void onCreate(SQLiteDatabase db) {
            Log.i("greenDAO", "Creating tables for schema version " + SCHEMA_VERSION);
            createAllTables(db, false);
        }
    }
    
    /** WARNING: Drops all table on Upgrade! Use only during development. */
    public static class DevOpenHelper extends OpenHelper {
        public DevOpenHelper(Context context, String name, CursorFactory factory) {
            super(context, name, factory);
        }

        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            Log.i("greenDAO", "Upgrading schema from version " + oldVersion + " to " + newVersion + " by dropping all tables");
            dropAllTables(db, true);
            onCreate(db);
        }
    }

    public DaoMaster(SQLiteDatabase db) {
        super(db, SCHEMA_VERSION);
        registerDaoClass(StudentDao.class);
    }
    
    public DaoSession newSession() {
        return new DaoSession(db, IdentityScopeType.Session, daoConfigMap);
    }
    
    public DaoSession newSession(IdentityScopeType type) {
        return new DaoSession(db, type, daoConfigMap);
    }
    
}

public class DaoSession extends AbstractDaoSession {

    private final DaoConfig studentDaoConfig;

    private final StudentDao studentDao;

    public DaoSession(SQLiteDatabase db, IdentityScopeType type, Map<Class<? extends AbstractDao<?, ?>>, DaoConfig>
            daoConfigMap) {
        super(db);

        studentDaoConfig = daoConfigMap.get(StudentDao.class).clone();
        studentDaoConfig.initIdentityScope(type);

        studentDao = new StudentDao(studentDaoConfig, this);

        registerDao(Student.class, studentDao);
    }
    
    public void clear() {
        studentDaoConfig.getIdentityScope().clear();
    }

    public StudentDao getStudentDao() {
        return studentDao;
    }

}


public class DaoSession extends AbstractDaoSession {

    private final DaoConfig studentDaoConfig;

    private final StudentDao studentDao;

    public DaoSession(SQLiteDatabase db, IdentityScopeType type, Map<Class<? extends AbstractDao<?, ?>>, DaoConfig>
            daoConfigMap) {
        super(db);

        studentDaoConfig = daoConfigMap.get(StudentDao.class).clone();
        studentDaoConfig.initIdentityScope(type);

        studentDao = new StudentDao(studentDaoConfig, this);

        registerDao(Student.class, studentDao);
    }
    
    public void clear() {
        studentDaoConfig.getIdentityScope().clear();
    }

    public StudentDao getStudentDao() {
        return studentDao;
    }

}


public class StudentDao extends AbstractDao<Student, Long> {

    public static final String TABLENAME = "STUDENT";

    /**
     * Properties of entity Student.<br/>
     * Can be used for QueryBuilder and for referencing column names.
    */
    public static class Properties {
        public final static Property Id = new Property(0, Long.class, "id", true, "_id");
        public final static Property Name = new Property(1, String.class, "name", false, "NAME");
        public final static Property Address = new Property(2, String.class, "address", false, "ADDRESS");
        public final static Property Age = new Property(3, Integer.class, "age", false, "AGE");
    };


    public StudentDao(DaoConfig config) {
        super(config);
    }
    
    public StudentDao(DaoConfig config, DaoSession daoSession) {
        super(config, daoSession);
    }

    /** Creates the underlying database table. */
    public static void createTable(SQLiteDatabase db, boolean ifNotExists) {
        String constraint = ifNotExists? "IF NOT EXISTS ": "";
        db.execSQL("CREATE TABLE " + constraint + "\"STUDENT\" (" + //
                "\"_id\" INTEGER PRIMARY KEY ," + // 0: id
                "\"NAME\" TEXT," + // 1: name
                "\"ADDRESS\" TEXT," + // 2: address
                "\"AGE\" INTEGER);"); // 3: age
    }

    /** Drops the underlying database table. */
    public static void dropTable(SQLiteDatabase db, boolean ifExists) {
        String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"STUDENT\"";
        db.execSQL(sql);
    }

    /** @inheritdoc */
    @Override
    protected void bindValues(SQLiteStatement stmt, Student entity) {
        stmt.clearBindings();
 
        Long id = entity.getId();
        if (id != null) {
            stmt.bindLong(1, id);
        }
 
        String name = entity.getName();
        if (name != null) {
            stmt.bindString(2, name);
        }
 
        String address = entity.getAddress();
        if (address != null) {
            stmt.bindString(3, address);
        }
 
        Integer age = entity.getAge();
        if (age != null) {
            stmt.bindLong(4, age);
        }
    }

    /** @inheritdoc */
    @Override
    public Long readKey(Cursor cursor, int offset) {
        return cursor.isNull(offset + 0) ? null : cursor.getLong(offset + 0);
    }    

    /** @inheritdoc */
    @Override
    public Student readEntity(Cursor cursor, int offset) {
        Student entity = new Student( //
            cursor.isNull(offset + 0) ? null : cursor.getLong(offset + 0), // id
            cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1), // name
            cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2), // address
            cursor.isNull(offset + 3) ? null : cursor.getInt(offset + 3) // age
        );
        return entity;
    }
     
    /** @inheritdoc */
    @Override
    public void readEntity(Cursor cursor, Student entity, int offset) {
        entity.setId(cursor.isNull(offset + 0) ? null : cursor.getLong(offset + 0));
        entity.setName(cursor.isNull(offset + 1) ? null : cursor.getString(offset + 1));
        entity.setAddress(cursor.isNull(offset + 2) ? null : cursor.getString(offset + 2));
        entity.setAge(cursor.isNull(offset + 3) ? null : cursor.getInt(offset + 3));
     }
    
    /** @inheritdoc */
    @Override
    protected Long updateKeyAfterInsert(Student entity, long rowId) {
        entity.setId(rowId);
        return rowId;
    }
    
    /** @inheritdoc */
    @Override
    public Long getKey(Student entity) {
        if(entity != null) {
            return entity.getId();
        } else {
            return null;
        }
    }

    /** @inheritdoc */
    @Override    
    protected boolean isEntityUpdateable() {
        return true;
    }
    
}

entity包下

public class Student {

    private Long id;
    private String name;
    private String address;
    private Integer age;

    public Student() {
    }

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

    public Student(Long id, String name, String address, Integer age) {
        this.id = id;
        this.name = name;
        this.address = address;
        this.age = age;
    }

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", age=" + age +
                '}';
    }
}
yungcs_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android GreenDao数据封装使用
长歌的博客
08-19 326
GreenDao 这里只讲封装，基础的继承，建表就不在这写了，放个链接，不会的可以去看下。 https://www.jianshu.com/p/ec007010fa07 这里是P层的查询调用 DbCheck.getInstance().getSqlList(0, "name").subscribe(new HttpSubscriber<List<BeanEntity>...
Android GreenDAO使用总结以及封装使用
weixin_43976036的博客
04-27 478
前言 总所周知，GreenDAO这个数据库框架在Android中是非常出名的，是基于sqlite进行封装的，GreenDAO是一个对象关系映射（ORM）的框架，能够提供一个接口通过操作对象的方式去操作关系型数据库，让操作数据库时更简单、更方便。 GreenDao对外提供的核心类有： DaoMaster：DaoMaster保存数据库对象（SQLiteDatabase）并管理特定模式的Dao类。它具有静态方法来创建表或将他们删除。其内部类OpenHelper和DevOpenHelper是在SQLite数据库中
GreenDao封装使用
Android唐浮的专栏
10-22 620
GreenDao封装使用 GreenDAO是一个开源的Android ORM(“对象/关系映射”)，通过ORM（称为“对象/关系映射”），简单来说就是操作对象达到更改数据库的效果，在我们数据库开发过程中节省了开发时间！ 为什么使用GreenDao 历来的工作中用GreenDao很多，在官方的对比截图中也觉得它强于其它框架。 高性能 易于使用的强大API，涵盖关系和连接； 最小的内存消耗; 小库大...
GreenDao的封装及使用
qq_39200790的博客
11-15 663
导入步骤： 第一步： 在项目的.gradle文件里面添加 buildscript { repositories { google() jcenter() mavenCentral() } dependencies { classpath 'com.android.tools.build:gra...
Android数据库GreenDao，封装实践
黑蛋丶的博客
07-01 782
一、首先就是GreenDao环境的集成 GreenDao 地址 环境集成比较简单，如下 首先在项目下的build.gradle文件中： //GreenDao3依赖 classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' 模块的build.gradle文件中： apply plugin: 'org.greenrobot.greendao' //greenDao配置 greendao { //指定数据库schema版本号，迁移等操作会用到;
Android——Greendao封装进行
xy8199的博客
12-01 4517
  关于GreenDao   greenDao是一个将对象映射到SQLite数据库中的轻量且快速的ORM解决方案。 关于greenDAO的概念可以看官网greenDAO   greenDAO 优势   1、一个精简的库 2、性能最大化 3、内存开销最小化 4、易于使用的 APIs 5、对 Android 进行高度优化   GreenDao 3.0使用 GreenDao 3.0采...
对GreenDao数据库操作的封装
最新发布
2401_84123077的博客
04-20 428
代码真的是重质不重量，质量高的代码，是当前代码界提倡的，当然写出高质量的代码肯定需要一个相当高的专业素养，这需要在日常的代码书写中逐渐去吸收掌握，谁不是每天都在学习呀，目的还不是为了一个，为实现某个功能写出高质量的代码。所以，长征路还长，大家还是好好地做个务实的程序员吧。最后，小编这里有一系列Android提升学习资料，有兴趣的小伙伴们可以来看下哦~《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！战项目、讲解视频，并且会持续更新！**
GreenDao的使用与封装
poorSir的博客
01-19 1073
官方api文档 SQLite可视化工具下载地址 Personal为免费版本配置在项目build.gradle中配置 dependencies { classpath 'org.greenrobot:greendao-gradle-plugin:3.1.0' }在你要使用的模块下的build.gradle配置（我是直接在app模块下）apply plugin: 'org.green
greenDao的使用与封装
天道酬勤的博客
03-14 599
1. greenDao的使用步骤： 第一步： 在项目的.gradle文件里面添加 buildscript { repositories { mavenCentral() jcenter() } dependencies { classpath 'com.android.tools.build:gra...
GreenDao 封装
09-22
封装后的GreenDao模块可以提高代码的可读性和可维护性，降低耦合度。 3. **封装步骤** - **设置数据库版本**：创建`DatabaseConfig`类，用于配置数据库版本、数据库升级策略等。 - **创建实体类**：根据数据模型...
greenDAO的使用工具类封装
04-06
在这个项目“greenDAO的使用工具类封装”中，作者YaphetZhao提供了封装后的GreenDAO工具类，使得在Android开发中使用GreenDAO更加便捷。** 首先，让我们深入理解GreenDAO的核心概念。GreenDAO是通过生成Java对象...
GreenDao封装
09-11
GreenDao封装，对数据库进行增删改查，升级等操作。其中有使用示例。相关的博客链接地址说明： http://blog.csdn.net/wu371894545/article/details/77936224
Android数据库框架GreenDao封装使用，易理解、易扩展
04-13
本资源提供了一份关于如何封装和使用GreenDao的教程，特别适合初学者以及希望提升数据库操作效率的开发者。 GreenDao的核心概念是实体类，这些类直接映射到数据库表。通过简单的注解，你可以定义实体属性，如字段...
封装GreenDao
07-13
**四、使用封装的GreenDao** 在Activity或Fragment中，我们可以通过调用`fetchUsers`方法获取数据并更新UI： ```java DatabaseManager.fetchUsers(this, getDaoSession(), new DatabaseManager.DaoCallback() { @...
NestedScrollView 嵌套 RecyclerView
热门推荐
yungcs的专栏
01-07 1万+
NestedScrollView 嵌套 RecyclerView     1、重写 RecyclerView  的  LinearLayoutManager FullyLinearLayoutManager.class   package com.yungcs.project.myapplication; import android.content.Context; import ...
NestedScrollView 之 ScrollView 嵌套 ListView
yungcs的专栏
01-07 9419
  【问题汇总】ScrollView嵌套ListView的问题 Anroid  Studio 新建一个工程之后，默认继承AppCompatActivity， MainActivity 布局如下  main.layout   &lt;?xml version="1.0" encoding="utf-8"?&gt; &lt;android.support.design.widget.C...
Android 笔记之动态创建button 一行三列
yungcs的专栏
11-30 2104
package com.example.mytest2; import android.app.Activity; import android.content.Intent; import android.os.Bundle; import android.util.DisplayMetrics; import android.view.Menu; import android.vi
Android中接口回调——fagment与activity
yungcs的专栏
05-16 1828
确实是对接口回调的东西不是很明白不是很熟悉，看到如下解释后，恍然大悟。 这里主要是这样的意思，首先我们可以在fragment里面定义一个接口，然后 然后将activity强转成接口，然后赋值给接口，那么直接在activity里面就可以实现这个接口定义的方法。 1、在Fragment中自定义接口 public interface OnButtonClickListener { publi
greendao封装
09-19
GreenDao是一个用于Android开发的轻量级数据库框架，它可以帮助我们更方便地进行数据库操作。在使用GreenDao时，可以进行一些封装来简化操作。通常，我们可以创建一个GreenDao管理类来管理数据库的创建、升级和操作等。在这个管理类中，我们可以定义各种增删改查的方法，以及其他数据库操作相关的方法。这样，我们就可以通过调用这些方法来进行数据库的操作。对于操作的实体类，GreenDao会自动生成相应的Dao类来帮助我们进行数据库的增删改查操作。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值