SQLite数据库操作(原生操作，GreenDao操作)

最新推荐文章于 2024-02-22 16:26:06 发布

吃骨头不吐股骨头皮

最新推荐文章于 2024-02-22 16:26:06 发布

阅读量2.5k

点赞数

分类专栏： android 文章标签： SQLite GreenDao

本文链接：https://blog.csdn.net/u013855006/article/details/79843416

版权

android 专栏收录该内容

50 篇文章 2 订阅

订阅专栏

使用原生的操作方法

首先实现一个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<Shop> 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<Shop> 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<User> queryList(){
        UserDao userDao = DBManager.getInstance(context).getWriteDaoSession().getUserDao();
        return userDao.loadAll();
    }

    /**
     * 根据条件查询
     * @param userName
     * @return
     */
    public List<User> 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);
    }
}