SQLite数据库操作:原生操作,GreenDao操作讲解

使用原生的操作方法

首先实现一个databaseopenhelper继承sqliteopenhelper

public class databaseopenhelper extends sqliteopenhelper {
    //数据库版本号
    private static int init_version = 1;
    private static final string tag = "databaseopenhelper";

    /**
     *
     * @param context 上下文
     * @param name 数据库名称
     * @param factory
     * @param version 当前数据库的版本,值必须是整数并且是递增的状态
     */
    public databaseopenhelper(context context, string name, sqlitedatabase.cursorfactory factory, int version) {
        super(context, name, factory, version);
    }

    public databaseopenhelper(context context,string name,int version){
        this(context,name,null,version);
    }

    public databaseopenhelper(context context,string name){
        this(context,name,init_version);
    }

    @override
    public void oncreate(sqlitedatabase db) {
        log.e(tag,"创建数据库表");
        //创建了数据库并创建一个叫records的表
        //sqlite数据创建支持的数据类型: 整型数据,字符串类型,日期类型,二进制的数据类型
        string sql = "create table user(id integer primary key autoincrement,name varchar(20) not null);";
        //execsql用于执行sql语句
        //完成数据库的创建
        db.execsql(sql);
        //数据库实际上是没有被创建或者打开的,直到getwritabledatabase()
        // 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
    }

    @override
    public void onupgrade(sqlitedatabase db, int oldversion, int newversion) {
        log.e(tag,"更新数据库");
    }
}

操作数据库各种简单的方法

/**
     * 创建数据库
     */
    private void createdb() {
        // 创建sqliteopenhelper子类对象
        databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db");
        //数据库实际上是没有被创建或者打开的,直到getwritabledatabase()
        // 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
        sqlitedatabase database = helper.getwritabledatabase();
    }

    /**
     * 更新数据库
     */
    private void upgradedb() {
        databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db", 2);
        sqlitedatabase database = helper.getwritabledatabase();
    }

    /**
     * 插入数据
     */
    private void insertdb() {
        log.e(tag, "插入数据");
        // 创建sqliteopenhelper子类对象
        databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db", 2);
        //数据库实际上是没有被创建或者打开的,直到getwritabledatabase()
        // 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
        sqlitedatabase database = helper.getwritabledatabase();

        // 创建contentvalues对象
        contentvalues values = new contentvalues();
        // 向该对象中插入键值对
        values.put("id", 1);
        values.put("name", "唐嫣");

        // 调用insert()方法将数据插入到数据库当中
        database.insert("user", null, values);

        //使用sql插入数据
        /*string sql = "insert into user(id,name) values(1,'杨幂')";
        database.execsql(sql);*/

        //关闭数据库
        database.close();
    }

    /**
     * 更新数据
     */
    private void updatedb() {
        log.e(tag, "更新数据");
        // 创建sqliteopenhelper子类对象
        databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db", 2);
        //数据库实际上是没有被创建或者打开的,直到getwritabledatabase()
        // 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
        sqlitedatabase database = helper.getwritabledatabase();

        // 创建一个contentvalues对象
        contentvalues values = new contentvalues();
        values.put("name","刘诗诗");

        // 调用update方法修改数据库
        database.update("user",values,"id=?",new string[]{"1"});
        /*string sql = "update user set name='刘亦菲' where id=1";
        database.execsql(sql);*/
        database.close();
    }

    /**
     * 查询数据
     */
    private void selectdb() {
        log.e(tag, "查询数据");
        // 创建sqliteopenhelper子类对象
        databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db", 2);
        //数据库实际上是没有被创建或者打开的,直到getwritabledatabase()
        // 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
        sqlitedatabase database = helper.getwritabledatabase();
        // 调用sqlitedatabase对象的query方法进行查询
        // 返回一个cursor对象:由数据库查询返回的结果集对象
        cursor cursor = database.query("user", new string[]{"id", "name"}, "id=?", new string[]{"1"}, null, null, null);

        stringbuilder builder = new stringbuilder();
        //将光标移动到下一行,从而判断该结果集是否还有下一条数据
        //如果有则返回true,没有则返回false
        while (cursor.movetonext()) {
            string id = cursor.getstring(cursor.getcolumnindex("id"));
            string name = cursor.getstring(cursor.getcolumnindex("name"));
            builder.append("id:" + id).append("==>name:" + name).append("\n");
        }
        tvcontent.settext(builder.tostring());
        database.close();
    }

    /**
     * 删除数据
     */
    private void delete() {
        log.e(tag, "删除数据");
        // 创建sqliteopenhelper子类对象
        databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db", 2);
        //数据库实际上是没有被创建或者打开的,直到getwritabledatabase()
        // 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
        sqlitedatabase database = helper.getwritabledatabase();

        //删除数据
        database.delete("user","id=?",new string[]{"1"});

        /*string sql = "delete from user where id = 1";
        database.execsql(sql);*/
        database.close();
    }

    /**
     * 删除数据库
     */
    private void deletedb() {
        log.e(tag, "删除数据库");
        // 创建sqliteopenhelper子类对象
        databaseopenhelper helper = new databaseopenhelper(databaseactivity.this, "test_db", 2);
        //数据库实际上是没有被创建或者打开的,直到getwritabledatabase()
        // 或者 getreadabledatabase() 方法中的一个被调用时才会进行创建或者打开
        sqlitedatabase database = helper.getwritabledatabase();

        //删除数据库
        boolean detedb = deletedatabase("test_db");
        tvcontent.settext("是否被删除:"+detedb);
    }

使用greendao操作数据库

配置
1、在你使用的module(一般不修改就是app)的build.gradle中导入greendao的依赖

//greendao的依赖
compile 'org.greenrobot:greendao:3.2.2'

2、然后还是在你所使用的module(一般不修改就是app)的build.gradle中配置

在最顶部加上
//使用greendao
apply plugin: 'org.greenrobot.greendao'

//然后在如下文件中配置
android {
    //greendao配置
    greendao {
        //版本号,升级是可配置
        schemaversion 1
        daopackage '此处配置greendao自动生成文件的包路径'
        targetgendir 'src/main/java'
    }
}

3、然后在你的project的build.gradle中配置

//greendao3.0的依赖
classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'

4、然后在application中配置,还有其他的配置方式

public class practiceapplication extends application {


    private static daosession daosession;

    @override
    public void oncreate() {
        super.oncreate();
        //配置数据库
        setupdatabase();
    }

    /**
     * 配置数据库
     */
    private void setupdatabase() {
        //创建数据库
        daomaster.devopenhelper helper = new daomaster.devopenhelper(getapplicationcontext(),"test_shop.dp",null);
        //获取可读可写数据库
        sqlitedatabase database = helper.getwritabledatabase();
        //获取数据库对象
        daomaster daomaster = new daomaster(database);
        //获取dao对象管理者
        daosession = daomaster.newsession();
    }

    public static daosession getdaoinstance(){
        return daosession;
    }
}

上面配置已经完成,接下来我们就来使用

/**
     * 添加数据,如果有重复就覆盖
     */
    private void insertdata() {
        shop shop = new shop(1l,"苹果","5",500,"www.img.com","www.baidu.com",shop.type_cart);
        practiceapplication.getdaoinstance().getshopdao().insertorreplace(shop);
    }

    /**
     * 删除数据
     */
    private void deletedata() {
        practiceapplication.getdaoinstance().getshopdao().deletebykey(1l);
    }

    /**
     * 修改数据
     */
    private void updatedata() {
        shop shop = new shop(1l,"橘子","5",500,"www.img.com","www.baidu.com",shop.type_cart);
        practiceapplication.getdaoinstance().getshopdao().update(shop);
    }

    /**
     * 查询类型为shop.type_cart的数据
     */
    private void querydata() {
        list list = practiceapplication.getdaoinstance().getshopdao().querybuilder().where(shopdao.properties.type.eq(shop.type_cart)).list();
        stringbuilder builder = new stringbuilder();
        for (shop shop : list) {
            builder.append(shop.getid()+"\n")
                    .append(shop.getname()+"\n")
                    .append(shop.getprice()+"\n")
                    .append(shop.getsellnum()+"\n")
                    .append(shop.getimgurl()+"\n")
                    .append(shop.getaddress()+"\n")
                    .append(shop.gettype()+"\n");
        }
        tvcontent.settext(builder.tostring());
    }

    /**
     * 查询所有数据
     */
    private void queryall() {
        list list = practiceapplication.getdaoinstance().getshopdao().loadall();
        stringbuilder builder = new stringbuilder();
        for (shop shop : list) {
            builder.append(shop.getid()+"\n")
                    .append(shop.getname()+"\n")
                    .append(shop.getprice()+"\n")
                    .append(shop.getsellnum()+"\n")
                    .append(shop.getimgurl()+"\n")
                    .append(shop.getaddress()+"\n")
                    .append(shop.gettype()+"\n");
        }
        tvcontent.settext(builder.tostring());
    }

还可以如下写法,就是第四步不配置,使用的时候才来创建数据库,但是我觉得最好按照上面的步骤来,
创建一个数据库管理类dbmanager

public class dbmanager {
    private static final string db_name = "test_qmui";
    private context context;
    private daomaster.devopenhelper helper;
    private static dbmanager dbmanager;

    private dbmanager(context context){
        this.context = context;
        helper = new daomaster.devopenhelper(context,db_name,null);
    }

    /**
     * 创建dbmanager
     * @param context
     * @return
     */
    public static dbmanager getinstance(context context) {
        if (null == dbmanager) {
            synchronized (dbmanager.class) {
                return new dbmanager(context);
            }
        }
        return dbmanager;
    }

    /**
     * 获取数据库的操作类
     * @return
     */
    public daosession getwritedaosession(){
        if(null == helper){
            //创建数据库
            helper = new daomaster.devopenhelper(context,db_name,null);
        }
        //获取可读可写数据库
        sqlitedatabase database = helper.getwritabledatabase();
        //获取数据库对象
        daomaster daomaster = new daomaster(database);
        return daomaster.newsession();
    }

    /**
     * 获取数据库的操作类
     * @return
     */
    public daosession getreaddaosession(){
        if(null == helper){
            helper = new daomaster.devopenhelper(context,db_name,null);
        }
        //获取可读数据库
        sqlitedatabase database = helper.getreadabledatabase();
        //获取数据库对象
        daomaster daomaster = new daomaster(database);
        //获取dao对象管理者
        return daomaster.newsession();
    }
}

操作数据库

public class handleuserdao {
    private context context;

    public handleuserdao(context context){
        this.context = context;
    }

    /**
     * 插入数据
     * @param user
     */
    public void insert(user user){
        userdao userdao = dbmanager.getinstance(context).getwritedaosession().getuserdao();
        userdao.insert(user);
    }

    /**
     * 查询所有数据
     * @return
     */
    public list querylist(){
        userdao userdao = dbmanager.getinstance(context).getwritedaosession().getuserdao();
        return userdao.loadall();
    }

    /**
     * 根据条件查询
     * @param username
     * @return
     */
    public list querylist(string username){
        userdao userdao = dbmanager.getinstance(context).getwritedaosession().getuserdao();
        return userdao.querybuilder().where(userdao.properties.username.gt(username))
                .orderasc(userdao.properties.username).build().list();
    }

    /**
     * 删除所有数据
     */
    public void deleteall(){
        userdao userdao = dbmanager.getinstance(context).getwritedaosession().getuserdao();
        userdao.deleteall();
    }

    /**
     * 删除指定数据
     * @param username
     */
    public void delete(string username){
        userdao userdao = dbmanager.getinstance(context).getwritedaosession().getuserdao();
        user user = userdao.querybuilder().where(userdao.properties.username.eq(username)).build().unique();
        if(null != user){
            userdao.deletebykey(user.getid());
        }
    }

    /**
     * 更新所有数据
     * @param user
     */
    public void update(user user){
        userdao userdao = dbmanager.getinstance(context).getwritedaosession().getuserdao();
        userdao.update(user);
    }
}
(0)
上一篇 2022年3月21日
下一篇 2022年3月21日

相关推荐