Greendao的使用

最新推荐文章于 2024-04-22 20:54:57 发布
最新推荐文章于 2024-04-22 20:54:57 发布
阅读量910 收藏
点赞数 1
分类专栏： Android 文章标签： 数据库 框架 Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Afanbaby/article/details/51480976
版权

Greendao(操作数据库的框架):是一种非常简单的框架。
一共分为四层：
1.DaoMaster—>最大的一层
2.DaoSession—>会话层
3.xxxDao—>真正的操作层（管理列表的）
想要使用Greendao必须添加lib
这里写图片描述
然后选择
这里写图片描述
添加依赖
这里写图片描述
然后我们创建一个GreendaoClass

public class GreendaoClass {

    public static void main(String[] args) {
        //首先创建数据图表(数据库框架)
        //两个参数,第一个参数:数据库的版本号,第二个参数:使我们自动生成代码的包名
        Schema schema = new Schema(1, "com.an.greendao");
        //调用添加方法
        addNote(schema);
        //自动生成代码,两个参数,第一个参数:图表对象,第二个参数:是自动生成的代码路径
        try {
            new DaoGenerator().generateAll(schema,"./app/src/main/java");
        } catch (Exception e) {
            e.printStackTrace();
        }


    }


    /**
     * 这个方法是为我们数据库添加所需的内容
     *
     * @param schema
     */
    public static void addNote(Schema schema) {
        //添加表名
        Entity entity = schema.addEntity("Person");
        //加入id,并且自增
        entity.addIdProperty().autoincrement().primaryKey();
        //添加类的属性,根据属性生成相应的表中字段
        entity.addStringProperty("name");
        entity.addIntProperty("age");
        entity.addStringProperty("sex");
    }
}

这样就配置完前一部分了，运行写的GreendaoClass,然后等一会儿，就会帮你创建四个类了。
这里写图片描述
创建的四个类分别是DaoMaster、DaoSession、Person、Person。
DaoMaster.java

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) {
        PersonDao.createTable(db, ifNotExists);
    }

    /** Drops underlying database table using DAOs. */
    public static void dropAllTables(SQLiteDatabase db, boolean ifExists) {
        PersonDao.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(PersonDao.class);
    }

    public DaoSession newSession() {
        return new DaoSession(db, IdentityScopeType.Session, daoConfigMap);
    }

    public DaoSession newSession(IdentityScopeType type) {
        return new DaoSession(db, type, daoConfigMap);
    }

}

DaoSession.java

public class DaoSession extends AbstractDaoSession {

    private final DaoConfig personDaoConfig;

    private final PersonDao personDao;

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

        personDaoConfig = daoConfigMap.get(PersonDao.class).clone();
        personDaoConfig.initIdentityScope(type);

        personDao = new PersonDao(personDaoConfig, this);

        registerDao(Person.class, personDao);
    }

    public void clear() {
        personDaoConfig.getIdentityScope().clear();
    }

    public PersonDao getPersonDao() {
        return personDao;
    }

}

Person.java

public class Person {

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

    public Person() {
    }

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

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

    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 Integer getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

}

PersonDao.java

public class PersonDao extends AbstractDao<Person, Long> {

    public static final String TABLENAME = "PERSON";

    /**
     * Properties of entity Person.<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 Age = new Property(2, Integer.class, "age", false, "AGE");
        public final static Property Sex = new Property(3, String.class, "sex", false, "SEX");
    };


    public PersonDao(DaoConfig config) {
        super(config);
    }

    public PersonDao(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 + "\"PERSON\" (" + //
                "\"_id\" INTEGER PRIMARY KEY AUTOINCREMENT ," + // 0: id
                "\"NAME\" TEXT," + // 1: name
                "\"AGE\" INTEGER," + // 2: age
                "\"SEX\" TEXT);"); // 3: sex
    }

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

    /** @inheritdoc */
    @Override
    protected void bindValues(SQLiteStatement stmt, Person 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);
        }

        Integer age = entity.getAge();
        if (age != null) {
            stmt.bindLong(3, age);
        }

        String sex = entity.getSex();
        if (sex != null) {
            stmt.bindString(4, sex);
        }
    }

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

    /** @inheritdoc */
    @Override
    public Person readEntity(Cursor cursor, int offset) {
        Person entity = new Person( //
            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.getInt(offset + 2), // age
            cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3) // sex
        );
        return entity;
    }

    /** @inheritdoc */
    @Override
    public void readEntity(Cursor cursor, Person 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.setAge(cursor.isNull(offset + 2) ? null : cursor.getInt(offset + 2));
        entity.setSex(cursor.isNull(offset + 3) ? null : cursor.getString(offset + 3));
     }

    /** @inheritdoc */
    @Override
    protected Long updateKeyAfterInsert(Person entity, long rowId) {
        entity.setId(rowId);
        return rowId;
    }

    /** @inheritdoc */
    @Override
    public Long getKey(Person entity) {
        if(entity != null) {
            return entity.getId();
        } else {
            return null;
        }
    }

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

}

还需需要添加一个依赖，在build.gradle(Module:app)中添加
这里写图片描述

现在所有的东西都弄好了之后，我们就可以使用了

public class MainActivity extends AppCompatActivity {

    private SQLiteDatabase db;//数据库
    private DaoMaster daoMaster;//管理者
    private DaoSession daoSession;//回话者
    private PersonDao personDao;//数据库内相应表的操作对象

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initData();
    }

    public void initData() {
        //我们进行各种初始化,第一个参数:context,第二个参数:数据库的名字,打三个参数游标工厂,设置为null
        DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "greendao.db", null);
        //初始化数据库
        db = helper.getWritableDatabase();
        //初始化DaoMaster
        daoMaster = new DaoMaster(db);
        //初始化daoSession
        daoSession = daoMaster.newSession();
        //初始化personDao
        personDao = daoSession.getPersonDao();
        //删除所有,这里为了防止id冲突,事先将数据库里的所有内容清空
        personDao.deleteAll();

        List<Person> list = new ArrayList<>();

        for (int i = 0; i < 50; i++) {
            Person person = new Person((long) i, "baby", 21, "男");
            //增添方法
            personDao.insert(person);
        }
        //根据id删除内容
        personDao.deleteByKey(5l);
        //修改数据库内容
        personDao.update(new Person(2l, "宝宝", 15, "女"));
        //查看数据库
        List<Person> personList = personDao.queryBuilder().list();
        for (Person person : personList) {
            Log.d("TAG", "person:" + person.getName() +
                    person.getId() + person.getSex()
                    + person.getAge());
        }
    }
}

看了上面的代码是不是感觉使用Greendao来操作数据库方便了很多，当然我们的实际情况并不是只有一张表，所以我们需要把Greendao封装成单例，这样就能保证我们的我所用的Greendao的对象是一个了！接下来我们封装下一下吧！

public class GreendaoSingle {

    private SQLiteDatabase db;//数据库
    private DaoMaster daoMaster;//管理者
    private DaoSession daoSession;//回话者
    private PersonDao personDao;//数据库内相应表的操作对象
    private Context context;
    private DaoMaster.DevOpenHelper helper;

    public DaoMaster.DevOpenHelper getHelper() {
        if (helper == null) {
            helper = new DaoMaster.DevOpenHelper(context, "Person.db", null);
        }
        return helper;
    }


    private static GreendaoSingle ourInstance = new GreendaoSingle();

    public static GreendaoSingle getInstance() {
        return ourInstance;
    }

    private GreendaoSingle() {
        //这里需要一个context，所以我们又新建了一个自己的MyApp
        context = MyApp.getContext();
    }

    public SQLiteDatabase getDb() {
        if (db == null) {
            db = getHelper().getWritableDatabase();
        }
        return db;
    }

    public DaoMaster getDaoMaster() {
        if (daoMaster == null) {
            daoMaster = new DaoMaster(getDb());
        }
        return daoMaster;
    }

    public DaoSession getDaoSession() {
        if (daoSession == null) {
            daoSession = getDaoMaster().newSession();
        }
        return daoSession;
    }

    public PersonDao getPersonDao() {
        if (personDao == null) {
            personDao = getDaoSession().getPersonDao();
        }
        return personDao;
    }

}

MyApp.java

public class MyApp extends Application {
    private static Context context;

    @Override
    public void onCreate() {
        super.onCreate();
        context = this;
    }

    public static Context getContext() {
        return context;
    }
}

当然我们新建好的MyApp，还需要在清单文件中给Application添加一个name属性就可以了，
然后我们就可以使用单例的形式来操作了，

public class MainActivity extends AppCompatActivity {

    private SQLiteDatabase db;//数据库
    private DaoMaster daoMaster;//管理者
    private DaoSession daoSession;//回话者
    private PersonDao personDao;//数据库内相应表的操作对象

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initData();
    }

    public void initData() {

        //使用单列来创建PersonDao,在所有类当中,我们保证只是用一个PersonDao
        personDao = GreendaoSingle.getInstance().getPersonDao();

        //删除所有,这里为了防止id冲突,事先将数据库里的所有内容清空
        personDao.deleteAll();

        List<Person> list = new ArrayList<>();

        for (int i = 0; i < 50; i++) {
            Person person = new Person((long) i, "baby", 21, "男");
            //增添方法
            personDao.insert(person);
        }
        //根据id删除内容
        personDao.deleteByKey(5l);
        //修改数据库内容
        personDao.update(new Person(2l, "宝宝", 85, "女"));
        //查看数据库
        List<Person> personList = personDao.queryBuilder().list();
        for (Person person : personList) {
            Log.d("TAG", "person:" + person.getName() +
                    person.getId() + person.getSex()
                    + person.getAge());
        }
    }
}

本人菜鸟一个，大神勿喷，有什么不对的地方希望大家指出评论，希望大家一起努力学习进步！

Afanbaby
关注
专栏目录
GreenDao使用
hanjiexuan的博客
04-23 453
一：什么是GreenDao 1.官网地址：https://github.com/greenrobot/greenDAO 2.greenDAO通过将Java对象映射到数据库表（称为ORM，“对象/关系映射”），可以使用简单的面向对象API来存储、更新、删除和查询Java对象。 二：效果 三：GreenDao使用 1.在项目中的整体build.gradle使用添加依赖 buildscript { repositories { jcenter() mavenCentral
GreenDao的使用(保姆式教学)
braveheart12580的博客
11-18 514
GreenDao的基本集成及使用 前言 Greendao是一款用于数据库创建与管理的框架，由于原生SQLite语言比较复杂繁琐，使得不少程序员不得不去学习SQLite原生语言，但是学习成本高，效率低下，所以不少公司致力于开发一款简单的数据库管理框架，较为著名的就有Greendao和ORMLite，但是就数据分析来看，Greendao的效率是高于ORMLite及其他框架的，是目前该行业的领先者。也因为Greendao的使用方法简便，且效率高使得其成为目前使用最为广泛的数据库管理框架。 优点 1：存取速度快。
GreenDao的使用
10-26
greendao的导入基本使用，里面有外键一对一关联（ToOne）和一对多关联(ToMany)的详细使用和十分齐全的查询姿势。
GreenDao的使用；
Choi晨的博客
04-27 322
为什么使用GreenDao？ greenDAO的独特功能集： 坚如磐石：greenDAO自2011年以来一直存在，并被无数著名应用程序使用 超级简单：简洁明了的API，在V3中带有注释 小型：该库小于150K，它只是普通的Java jar（没有依赖于CPU的本机部分） 快速：可能是智能代码生成的驱动，是最快的Android ORM 安全且富有表现力的查询API：QueryBuilder...
android 的Greendao使用demo，供初学者使用
03-03
这个“android的GreenDao使用demo”是为初学者准备的一个实例，旨在帮助理解并快速上手GreenDao的使用。 一、GreenDao简介 GreenDao是一款高效且易于使用的Java库，它允许开发者直接在Android应用中通过对象与...
安卓GreenDao使用.rar
09-25
**Android GreenDao 使用详解** GreenDao 是一个针对 Android 平台的高性能 ORM（对象关系映射）库，它使得在 Android 应用中操作 SQLite 数据库变得更加简单。通过使用 GreenDao，开发者可以将 Java 对象直接映射...
GreenDao使用demo
06-20
**GreenDao使用详解** GreenDao是一款专门为Android平台设计的高效、轻量级的对象关系映射（ORM）框架，它使得开发者能够便捷地在SQLite数据库上操作数据，无需编写大量的SQL语句。GreenDao通过将Java对象与数据库...
greendao的使用（简洁易懂）
热门推荐
秦时明月
06-14 1万+
今天在项目里使用到了greendao，记录一下greendao的使用过程。greendao是对sqlite数据库操作的封装，可以让我们更加方便的使用sqlite，其它类似的框架还有OrmLite、SugarORM、Active Android、Realm。但是greendao的性能要远远的高于其它四个框架，在官网有测试结果，因为它不是使用反射的机制，而是直接生成相关的代码。这就大幅度提升了它的性能。
GreenDao使用教程
专栏
04-27 1072
一 Greendao简介 二Greendao的使用方法 配置 初始化Greendao Greendao操作数据库文件增删改查 三多表关联 四Greendao注解含义 五Greendao特性 一、 Greendao简介Greendao是一款用于数据库创建与管理的框架，由于原生SQLite语言比较复杂繁琐，使得不少程序员不得不去学习SQLite原生语言，但是学习成本高，效率低下，所以不少公司致力于开发一
GreenDao的基本使用
03-30
GreenDao greendao GreenDao源码 GreenDao代码，Green的相关使用
GreenDao基本使用
10-08
GreenDao基本使用，包括增删改查，一对一，一对多，多对多
GreenDao的简单使用
Zhan_ll的博客
08-30 349
近期应公司要求研究了下GreenDao框架的使用，于是打算记录一下关于GreenDao的使用。 GreenDao的使用 GreenDao就是一个将对象映射到 SQLite 数据库中的轻量且快速的 ORM 解决方案。 GreenDao官网给出的优点 性能是AndroidORM中最快的 易于使用的API 最小的内存消耗 强大的社区：超过5000个GitHub明星表明有一个强大而活跃的社区 数据库加...
GreenDao使用方式
neabea2016的博客
04-13 234
用过litepal，抛弃litepal是因为多层级时数据插入查询太慢了，greendao也没有进项大量数据测试，也是尝试阶段。 1.项目gradle buildscript { repositories { jcenter() mavenCentral() // add repository } dependencies { ...
Android 数据库框架greenDao的使用
最新发布
chuchun_langye的博客
04-22 723
4.2 ORM 框架，即 Object-Relational Mapping，它的作用是在关系型数据库和对象之间作一个映射，这样，我们在具体操作数据库的时候，就不需要再去和复杂的 SQL 语句打交道，只是像平时操作对象一样操作它就可以了。DaoSession还提供了一些通用的持久性方法，如实体的插入，加载，更新，刷新和删除。indexes：标记如果DAO应该创建数据库表(默认为true)，如果您有多个实体映射到一个表，或者表的创建是在greenDAO之外进行的，那么将其设置为false。
greenDAO 使用
赵小龙同学的博客
11-06 120
greenDAO Documentationhttps://greenrobot.org/greendao/documentation/ Tutorials and How-Tos How to get started Introduction–project setup Modelling entities– schema and annotations Sessions– identity scope and session cache Queries– using the ...
greendao的使用
火星男孩的分享空间
02-28 370
参考：GreenDao 3.X之基本使用 GreenDao 3.2.0 的基本使用 Android ORM 框架之 greenDAO GreenDao3.2.2使用 史上最牛逼的Android数据库 GreenDao3.1 详细使用教程（小白容易上手）本篇demo地址简介：性能最大化，可能是Android平台上最快的ORM框架 易于使用的API 最小的内存开销 依赖体积小,小于100k
Greendao3配置与使用教程：简化代码生成与操作指南
本文档主要介绍了GreenDao 3的详细使用流程，GreenDao 3相比其前一代版本做了多项改进，尤其是在代码生成和配置方面的简化。以下是关键知识点的详细说明： 1. 依赖包名称的变化： GreenDao 3的依赖包名字已更新为`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值