android 一个SQLite数据库多个数据表的基本使用框架 （带demo）

android 一个SQLite数据库多个数据表（带demo）

前言
        demo演示
        一、搭建
        二、建立实体类
        三、建立数据库操作类
        四、配置Application
        五、使用
    GitHub

前言

我的上一篇博客讲的是简单的 android SQLite 数据库的基本操作如增删改查，有兴趣的朋友可以点一下这里android 简单SQLite数据库 增删改查

但是呢，一般的项目里，一个数据库也不会只有一个数据表，常常是多个数据表共同管理的，这个时候应该怎么搭建项目的数据库操作代码框架呢？

光说不练假把式，动手开一个Demo
demo演示

demo
一、搭建

首先，在项目里建立起三个文件夹，分别是 app 、 db 、 model
文件夹
app 文件夹下存放继承 Application 的 MyApplication 类
db 文件夹下存放 数据库操作类
model 文件夹下存放 数据实体类
二、建立实体类

在 model 文件夹下创建 实体类 PhoneBean

/**
 * 手机实体类
 * @author  dlong
 * created at 2019/3/13 11:34 AM
 */
public class PhoneBean {
    /** 数据库自增ID */
    public int id;
    /** 手机品牌 */
    public String brand;
    /** 手机型号 */
    public String model;
    /** 手机价格 */
    public int price;

/**
     * 转化成字符串
     * @return
     */
    public String toString(){
        StringBuilder builder = new StringBuilder("[");
        builder.append(id).append("--");
        builder.append("品牌：").append(brand).append("--");
        builder.append("型号：").append(model).append("--");
        builder.append("价格：").append(price).append("]");
        return builder.toString();
    }
}

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28

在 model 文件夹下创建 实体类 CompanyBean

/**
 * 公司实体类
 * @author  dlong
 * created at 2019/3/13 11:37 AM
 */
public class CompanyBean {
    /** 数据库自增ID */
    public int id;
    /** 公司名称 */
    public String name;
    /** 公司CEO */
    public String ceo;
    /** 公司建立年份 */
    public int year;

public String toString(){
        StringBuilder builder = new StringBuilder("[");
        builder.append(id).append("--");
        builder.append("公司名称：").append(name).append("--");
        builder.append("CEO：").append(ceo).append("--");
        builder.append("创立年份：").append(year).append("年]");
        return builder.toString();
    }
}

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24

三、建立数据库操作类

在 db 文件夹下建立一个 DBConfig 用于记录数据库配置信息

/**
 * 数据库配置信息
 * @author  dlong
 * created at 2019/3/13 11:27 AM
 */
public class DBConfig {
    /**  数据库名称 */
    public static final String DB_NAME = "multiple_test.db";
    /**  数据库版本 */
    public static final int DB_VERSION = 1;

/**
     * 判断数据表是否为空
     * @param db
     * @param tablename
     * @return
     */
    public static boolean HaveData(SQLiteDatabase db, String tablename){
        Cursor cursor;
        boolean a = false;
        cursor = db.rawQuery("select name from sqlite_master where type=‘table‘ ", null);
        while(cursor.moveToNext()){
            //遍历出表名
            String name = cursor.getString(0);
            if(name.equals(tablename)){
                a = true;
            }
            Log.i("System.out", name);
        }
        if(a){
            cursor = db.query(tablename,null,null,null,null,null,null);
            //检查是不是空表
            return cursor.getCount() > 0;
        }else {
            return false;
        }
    }
}

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38

在 db 文件夹下建立一个 PhoneDBDao 用于操作数据表

/**
 * 手机数据表操作类
 * @author  dlong
 * created at 2019/3/13 11:39 AM
 */
public class PhoneDBDao {

/** 数据表名称 */
    public static final String TABLE_NAME = "phone_info";

/** 表的字段名 */
    public static String KEY_ID = "id";
    public static String KEY_BRAND = "brand";
    public static String KEY_MODEL = "model";
    public static String KEY_PRICE = "price";

private SQLiteDatabase mDatabase;
    /** 上下文 */
    private Context mContext;
    /** 数据库打开帮助类 */
    private DBMaster.DBOpenHelper mDbOpenHelper;

public PhoneDBDao(Context context) {
        mContext = context;
    }

public void setDatabase(SQLiteDatabase db){
        mDatabase = db;
    }

/**
     * 插入一条数据
     * @param phone
     * @return
     */
    public long insertData(PhoneBean phone) {
        ContentValues values = new ContentValues();
        values.put(KEY_BRAND, phone.brand);
        values.put(KEY_MODEL, phone.model);
        values.put(KEY_PRICE, phone.price);
        return mDatabase.insert(TABLE_NAME, null, values);
    }

/**
     * 删除一条数据
     * @param id
     * @return
     */
    public long deleteData(int id) {
        return mDatabase.delete(TABLE_NAME, KEY_ID + "=" + id, null);
    }

/**
     * 删除所有数据
     * @return
     */
    public long deleteAllData() {
        return mDatabase.delete(TABLE_NAME, null, null);
    }

/**
     * 更新一条数据
     * @param id
     * @param phone
     * @return
     */
    public long updateData(int id, PhoneBean phone) {
        ContentValues values = new ContentValues();
        values.put(KEY_BRAND, phone.brand);
        values.put(KEY_MODEL, phone.model);
        values.put(KEY_PRICE, phone.price);
        return mDatabase.update(TABLE_NAME, values, KEY_ID + "=" + id, null);
    }

/**
     * 查询一条数据
     * @param id
     * @return
     */
    public List<PhoneBean> queryData(int id) {
        if (!DBConfig.HaveData(mDatabase,TABLE_NAME)){
            return null;
        }
        Cursor results = mDatabase.query(TABLE_NAME, new String[]{KEY_ID,
                        KEY_BRAND,
                        KEY_MODEL,
                        KEY_PRICE},
                KEY_ID + "=" + id , null, null, null, null);
        return convertUtil(results);
    }

/**
     * 查询所有数据
     * @return
     */
    public List<PhoneBean> queryDataList() {
        if (!DBConfig.HaveData(mDatabase,TABLE_NAME)){
            return null;
        }
        Cursor results = mDatabase.query(TABLE_NAME, new String[]{KEY_ID,
                        KEY_BRAND,
                        KEY_MODEL,
                        KEY_PRICE},
                null, null, null, null, null);
        return convertUtil(results);
    }

/**
     * 查询结果转换
     * @param cursor
     * @return
     */
    private List<PhoneBean> convertUtil(Cursor cursor) {
        int resultCounts = cursor.getCount();
        if (resultCounts == 0 || !cursor.moveToFirst()) {
            return null;
        }
        List<PhoneBean> mList = new ArrayList<>();
        for (int i = 0; i < resultCounts; i++) {
            PhoneBean phone = new PhoneBean();
            phone.id = cursor.getInt(cursor.getColumnIndex(KEY_ID));
            phone.brand = cursor.getString(cursor.getColumnIndex(KEY_BRAND));
            phone.model = cursor.getString(cursor.getColumnIndex(KEY_MODEL));
            phone.price = cursor.getInt(cursor.getColumnIndex(KEY_PRICE));
            mList.add(phone);
            cursor.moveToNext();
        }
        return mList;
    }
}

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130

在 db 文件夹下建立一个 CompanyDBDao 用于操作数据表

/**
 * 公司数据表操作类
 * @author  dlong
 * created at 2019/3/13 11:46 AM
 */
public class CompanyDBDao {

/** 数据表名称 */
    public static final String TABLE_NAME = "company_info";

/** 表的字段名 */
    public static String KEY_ID = "id";
    public static String KEY_NAME = "name";
    public static String KEY_CEO = "ceo";
    public static String KEY_YEAR = "year";

private SQLiteDatabase mDatabase;
    /** 上下文 */
    private Context mContext;
    /** 数据库打开帮助类 */
    private DBMaster.DBOpenHelper mDbOpenHelper;

public CompanyDBDao(Context context) {
        mContext = context;
    }

public void setDatabase(SQLiteDatabase db){
        mDatabase = db;
    }

/**
     * 插入一条数据
     * @param company
     * @return
     */
    public long insertData(CompanyBean company) {
        ContentValues values = new ContentValues();
        values.put(KEY_NAME, company.name);
        values.put(KEY_CEO, company.ceo);
        values.put(KEY_YEAR, company.year);
        return mDatabase.insert(TABLE_NAME, null, values);
    }

/**
     * 删除一条数据
     * @param id
     * @return
     */
    public long deleteData(int id) {
        return mDatabase.delete(TABLE_NAME, KEY_ID + "=" + id, null);
    }

/**
     * 删除所有数据
     * @return
     */
    public long deleteAllData() {
        return mDatabase.delete(TABLE_NAME, null, null);
    }

/**
     * 更新一条数据
     * @param id
     * @param company
     * @return
     */
    public long updateData(int id, CompanyBean company) {
        ContentValues values = new ContentValues();
        values.put(KEY_NAME, company.name);
        values.put(KEY_CEO, company.ceo);
        values.put(KEY_YEAR, company.year);
        return mDatabase.update(TABLE_NAME, values, KEY_ID + "=" + id, null);
    }

/**
     * 查询一条数据
     * @param id
     * @return
     */
    public List<CompanyBean> queryData(int id) {
        if (!DBConfig.HaveData(mDatabase,TABLE_NAME)){
            return null;
        }
        Cursor results = mDatabase.query(TABLE_NAME, new String[]{KEY_ID,
                        KEY_NAME,
                        KEY_CEO,
                        KEY_YEAR},
                KEY_ID + "=" + id , null, null, null, null);
        return convertUtil(results);
    }

/**
     * 查询所有数据
     * @return
     */
    public List<CompanyBean> queryDataList() {
        if (!DBConfig.HaveData(mDatabase,TABLE_NAME)){
            return null;
        }
        Cursor results = mDatabase.query(TABLE_NAME, new String[]{KEY_ID,
                        KEY_NAME,
                        KEY_CEO,
                        KEY_YEAR},
                null, null, null, null, null);
        return convertUtil(results);
    }

/**
     * 查询结果转换
     * @param cursor
     * @return
     */
    private List<CompanyBean> convertUtil(Cursor cursor) {
        int resultCounts = cursor.getCount();
        if (resultCounts == 0 || !cursor.moveToFirst()) {
            return null;
        }
        List<CompanyBean> mList = new ArrayList<>();
        for (int i = 0; i < resultCounts; i++) {
            CompanyBean company = new CompanyBean();
            company.id = cursor.getInt(cursor.getColumnIndex(KEY_ID));
            company.name = cursor.getString(cursor.getColumnIndex(KEY_NAME));
            company.ceo = cursor.getString(cursor.getColumnIndex(KEY_CEO));
            company.year = cursor.getInt(cursor.getColumnIndex(KEY_YEAR));
            mList.add(company);
            cursor.moveToNext();
        }
        return mList;
    }
}

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130

在 db 文件夹下建立一个 DBMaster 用于管理数据库里的全部数据表

/**
 * 数据库总操作类
 * @author  dlong
 * created at 2019/3/13 11:29 AM
 */
public class DBMaster {

/** 上下文 */
    private Context mContext;
    private SQLiteDatabase mDatabase;
    private DBOpenHelper mDbOpenHelper;

/** 数据表操作类实例化 */
    public PhoneDBDao mPhoneDBDao;
    public CompanyDBDao mCompanyDBDao;

public DBMaster(Context context){
        mContext = context;
        mPhoneDBDao = new PhoneDBDao(mContext);
        mCompanyDBDao = new CompanyDBDao(mContext);
    }

/**
     * 打开数据库
     */
    public void openDataBase() {
        mDbOpenHelper = new DBOpenHelper(mContext, DB_NAME, null, DB_VERSION);
        try {
            mDatabase = mDbOpenHelper.getWritableDatabase();//获取可写数据库
        } catch (SQLException e) {
            mDatabase = mDbOpenHelper.getReadableDatabase();//获取只读数据库
        }
        // 设置数据库的SQLiteDatabase
        mPhoneDBDao.setDatabase(mDatabase);
        mCompanyDBDao.setDatabase(mDatabase);
    }

/**
     * 关闭数据库
     */
    public void closeDataBase() {
        if (mDatabase != null) {
            mDatabase.close();
        }
    }

/** 创建该数据库下phone表的语句 */
    private static final String mPhoneSqlStr = "create table if not exists " + PhoneDBDao.TABLE_NAME + " (" +
            PhoneDBDao.KEY_ID + " integer primary key autoincrement , " +
            PhoneDBDao.KEY_BRAND + " text not null , " +
            PhoneDBDao.KEY_MODEL + " text not null , " +
            PhoneDBDao.KEY_PRICE + " integer );";

/** 创建该数据库下Company表的语句 */
    private static final String mCompanySqlStr = "create table if not exists " + CompanyDBDao.TABLE_NAME + " (" +
            CompanyDBDao.KEY_ID + " integer primary key autoincrement , " +
            CompanyDBDao.KEY_NAME + " text not null , " +
            CompanyDBDao.KEY_CEO + " text not null , " +
            CompanyDBDao.KEY_YEAR + " integer );";

/** 删除该数据库下phone表的语句 */
    private static final String mPhoneDelSql = "DROP TABLE IF EXISTS " + PhoneDBDao.TABLE_NAME;

/** 删除该数据库下Company表的语句 */
    private static final String mCompanyDelSql = "DROP TABLE IF EXISTS " + CompanyDBDao.TABLE_NAME;

/**
     * 数据表打开帮助类
     */
    public static class DBOpenHelper extends SQLiteOpenHelper {

public DBOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {
            super(context, name, factory, version);
        }

@Override
        public void onCreate(SQLiteDatabase db) {
            db.execSQL(mPhoneSqlStr);
            db.execSQL(mCompanySqlStr);
        }

@Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            db.execSQL(mPhoneDelSql);
            db.execSQL(mCompanyDelSql);
            onCreate(db);
        }
    }
}

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89

四、配置Application

在 app 文件夹建立 MyApplication

public class MyApplication extends Application {

/** 声明数据库操作实例 */
    public static DBMaster mDBMaster;

@Override
    public void onCreate() {
        super.onCreate();
        //启动数据库
        mDBMaster = new DBMaster(getApplicationContext());
        mDBMaster.openDataBase();
    }
}

1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

还要在 AndroidManifest.xml 的 <application 里添加

android:name=".app.MyApplication"

1

五、使用

// 新实例化一个PHONE
        PhoneBean phone = new PhoneBean();
        phone.brand = "Google";
        phone.model = "Pixel 3";
        phone.price = 4999;
        // 插入数据库
        MyApplication.mDBMaster.mPhoneDBDao.insertData(phone);

1
    2
    3
    4
    5
    6
    7

// 删除最老的一个数据
        if (null != mPhoneList && mPhoneList.size()>0){
            MyApplication.mDBMaster.mPhoneDBDao.deleteData(mPhoneList.get(0).id);
            updatePhoneTxt();
        }

1
    2
    3
    4
    5

// 查询数据库里的所有数据
        mPhoneList = MyApplication.mDBMaster.mPhoneDBDao.queryDataList();
        // 数据为空，也不能让列表为null
        if (null == mPhoneList) mPhoneList = new ArrayList<>();
---------------------
作者：YD-10-NG
来源：CSDN
原文：https://blog.csdn.net/sinat_38184748/article/details/88532631
版权声明：本文为博主原创文章，转载请附上博文链接！

原文地址：https://www.cnblogs.com/dogdogwang/p/10988897.html

时间： 2024-11-04 13:56:55

android 一个SQLite数据库多个数据表的基本使用框架 （带demo）的相关文章

Android 学习笔记之如何使用SQLite数据库来保存数据...

PS:最近一阵子都在为考试复习...坑爹的计算机网络,复习了3天,最后该不会的还是不会...明天还考英语...真蛋疼... 学习内容: 1.使用SQLite数据库来保存数据... SQLite:   SQLite一个轻量级的数据库,数据库这东西就是为了保存大量数据而存在的一个工具,SQLite支持SQL语言,其实和Mysql差不多,语句基本都是一样的,增删改查也非常的方便...SQLite独立性非常的好,使用SQLite不需要安装...不依赖与任何的引擎就可以独立的去执行...感觉这一点还是非常

android中sqlite数据库的基本使用和添加多张表

看了很多关于android使用sqlite数据库的文章,很多都是介绍了数据库的建立和表的建立,而表通常都是只建立一张,而实际情况我们用到的表可能不止一张,那这种情况下我们又该怎么办呢,好了,下面我教大家如何在sqlite数据库中建立多张表. 首先是如何建立数据库和表: 建立一个类继承SQLiteOpenHelper,即: public class ReaderOpenHelper extends SQLiteOpenHelper 然后添加构造方法: public ReaderOpenHelper

android在sqlite数据库的SQLiteOpenHelper中的onUpgrade里判断表是否存在

private boolean tabbleIsExist(String tableName, SQLiteDatabase db) { LogUtils.d("DatabaseHelper", "checking tabbleIsExist " + tableName); boolean result = false; if (tableName == null) { return false; } Cursor cursor = null; try { Stri

【Android】Sqlite数据库增删改查

Android系统内置一个Sqlite数据库,如果app需要使用Sqlite数据库数据库存储数据,Android会为此app生成一个.db文件.这个数据库在data/data/<package_name>/databases里面,其中<package_name>为该安卓app的工程包名,这个目录必须root后才能看到.在Windows,单机的应用程序,存储数据,基本放到一个文件里面,正如游戏的存档,基本就是把当前的游戏状态存到一个用户很难找到的文件里面.每次存档读档就是一个从这个存

android中SQLite数据库的增删改查

1.数据库帮助类PersonSQLiteOpenHelper package com.wzw.sqllitedemo.db; import android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteDatabase.CursorFactory; import android.database.sqlite.SQLiteOpenHelper

Android实现SQLite数据库的增、删、改、查的操作

核心代码DAO类 package com.examp.use_SQLite.dao; import java.util.ArrayList; import java.util.List; import android.content.ContentValues; import android.content.Context; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; import

Android学习---SQLite数据库的增删改查和事务(transaction)调用

上一篇文章中介绍了手工拼写sql语句进行数据库的CRUD操作,本文将介绍调用sqlite内置的方法实现CRUD操作,其实质也是通过拼写sql语句. 首先,创建一个新的android项目: 其次,查看代码实现增删查改: 1.创建DB工具类 MyDBHelper.java(创建数据库的操作) package com.amos.android_db; import android.content.Context; import android.database.sqlite.SQLiteDatabas

android操作sqlite数据库及心得

写这篇文章主要是网上的对sqlite的操作太多且太杂,很多时候都不能很好的运用到自己的项目中,结构不清晰,我自己写了一篇适合刚刚接触的人看的操作方法. 近来用android时要将一些数据保存起来,一开始用的是preferences,后来要保存的东西多了,发现用preferences明显不能满足要求了,而且发现用这个的话代码就变得有点乱了,所以才开始学习使用sqlite数据库,一开始以为不就是个数据库么,和平时的mysql啊或者是sqlserver都一样,都很简单的,但后来真正在用的时候才发现困难

android greenDao SQLite数据库操作工具类使用

上一篇介绍了如何建立类生成工程,现在介绍如何使用. 以下是ExampleDaoGenerator工程代码,做了一些修改 /* * Copyright (C) 2011 Markus Junginger, greenrobot (http://greenrobot.de) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in com