再读Android sqlite

Android原生支持sqlite数据库操作，sqlite时轻量级关系型数据库，支持标准sql语句。Android对sqlite进行良好的接口封装来避免sql注入等安全问题。

本文解决的问题：

1、Android App内如何创建数据库

2、Android App内创建数据库如何自定义文件路径

3、Android App内获取数据库流程解析

4、无Context模式使用数据库，可在uiautomator1.0测试框架和其他app_process启动的进程内使用数据库。

App内常规使用数据库

Android应用内使用数据库需要借助于SQLiteOpenHelper类实现对数据库的操作，使用数据库通过以下几步：

1、创建私有类集成自SQLiteOpenHelper方法，并覆写onCreate、onUpdate方法实现对数据库升级降级操作。

2、获取SQLiteOpenHelper对象实例。

3、获取只读、读写类型数据库SQLiteDatabase对象实例（getReadableDatabase()/getWritableDatabase()），当数据库升级或创建时才会调用onCreate、onUpdate方法。

4、使用SQLiteDatabase接口实现数据库操作（增删改查）

  1. //1、创建私有SQLiteOpenHelper类
  2. class DatabaseHelper extends SQLiteOpenHelper {
  4.     public DatabaseHelper(Context context, String dbName, int version) {
  5.         super(context, dbName, null, version);
  6.         LogUtil.print("DatabaseHelper dbName[%s] version[%d]",dbName+"",version);
  7.     }
  9.     @Override
  10.     public void onCreate(SQLiteDatabase db) {
  11.         //数据库创建时调用
  12.     }
  14.     @Override
  15.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  16.         //数据库升级时调用
  17.     }
  18. }
  19. //2、获取SQLiteOpenHelper对象实例。
  20. int dbVersion=0;
  21. DatabaseHelper databaseHelper=new (context,"test.db",dbVersion);
  22. //3、获取只读、读写类型数据库SQLiteDatabase对象实例
  23. SQLiteDatabase db = databaseHelper.getWritableDatabase();
  24. //4、使用SQLiteDatabase接口实现数据库操作（增删改查）
  25. String sql = "select * from testTable where id=?"
  26. Cursor cursor = db.rawQuery(sql, new String[]{"1111"});

数据库源码解析

1、SQLiteOpenHelper构造方法仅初始化参数：版本号必须大于0

  1. public SQLiteOpenHelper(Context context, String name, CursorFactory factory, int version,
  2.             int minimumSupportedVersion, DatabaseErrorHandler errorHandler) {
  3.         if (version < 1) throw new IllegalArgumentException("Version must be >= 1, was " + version);
  5.         mContext = context;
  6.         mName = name;
  7.         mFactory = factory;
  8.         mNewVersion = version;
  9.         mErrorHandler = errorHandler;
  10.         mMinimumSupportedVersion = Math.max(0, minimumSupportedVersion);
  11.     }

2、获取数据库实例：真正创建数据库文件

  • Android8.0及以下版本：区分writeable和readable数据库
  1.     private SQLiteDatabase getDatabaseLocked(boolean writable) {
  2.         if (mDatabase != null) {
  3.             if (!mDatabase.isOpen()) {
  4.                 // Darn!  The user closed the database by calling mDatabase.close().
  5.                 mDatabase = null;
  6.                 //如果获取只读数据库且缓存了可写数据库则直接返回
  7.             } else if (!writable || !mDatabase.isReadOnly()) {
  8.                 // The database is already open for business.
  9.                 return mDatabase;
  10.             }
  11.         }
  13.         if (mIsInitializing) {
  14.             throw new IllegalStateException("getDatabase called recursively");
  15.         }
  17.         SQLiteDatabase db = mDatabase;
  18.         try {
  19.             mIsInitializing = true;
  21.             if (db != null) {
  22.                 //如果获取可写数据库，复用缓存的只读数据库
  23.                 if (writable && db.isReadOnly()) {
  24.                     db.reopenReadWrite();
  25.                 }
  26.             } else if (mName == null) {
  27.                 db = SQLiteDatabase.create(null);
  28.             } else {
  29.                 try {
  30.                 //获取只读类型数据库实例
  31.                     if (DEBUG_STRICT_READONLY && !writable) {
  32.                         final String path = mContext.getDatabasePath(mName).getPath();
  33.                         db = SQLiteDatabase.openDatabase(path, mFactory,
  34.                                 SQLiteDatabase.OPEN_READONLY, mErrorHandler);
  35.                     } else {
  36.                     //获取可读写数据库实例
  37.                         db = mContext.openOrCreateDatabase(mName, mEnableWriteAheadLogging ?
  38.                                 Context.MODE_ENABLE_WRITE_AHEAD_LOGGING : 0,
  39.                                 mFactory, mErrorHandler);
  40.                     }
  41.                 } catch (SQLiteException ex) {
  42.                 //获取数据库异常时，如果获取可写数据库，则直接抛出
  43.                     if (writable) {
  44.                         throw ex;
  45.                     }
  46.                     Log.e(TAG, "Couldn't open " + mName
  47.                             + " for writing (will try read-only):", ex);
  48.                     //获取数据库异常时，如果获取只读数据库，重试获取只读类型数据库。
  49.                     final String path = mContext.getDatabasePath(mName).getPath();
  50.                     db = SQLiteDatabase.openDatabase(path, mFactory,
  51.                             SQLiteDatabase.OPEN_READONLY, mErrorHandler);
  52.                 }
  53.             }
  54.             onConfigure(db);
  55.             final int version = db.getVersion();
  56.             //数据库升级处理逻辑
  57.             if (version != mNewVersion) {
  58.                 if (db.isReadOnly()) {
  59.                     throw new SQLiteException("Can't upgrade read-only database from version " +
  60.                             db.getVersion() + " to " + mNewVersion + ": " + mName);
  61.                 }
  62.                 //程序运行时更新数据库：使用缓存数据库时走此逻辑，重新加载数据库
  63.                 if (version > 0 && version < mMinimumSupportedVersion) {
  64.                     File databaseFile = new File(db.getPath());
  65.                     onBeforeDelete(db);
  66.                     db.close();
  67.                     if (SQLiteDatabase.deleteDatabase(databaseFile)) {
  68.                         mIsInitializing = false;
  69.                         return getDatabaseLocked(writable);
  70.                     } else {
  71.                         throw new IllegalStateException("Unable to delete obsolete database "
  72.                                 + mName + " with version " + version);
  73.                     }
  74.                 } else {
  75.                 //事务更新（降级/升级）数据库
  76.                     db.beginTransaction();
  77.                     try {
  78.                         if (version == 0) {
  79.                             onCreate(db);
  80.                         } else {
  81.                             if (version > mNewVersion) {
  82.                                 onDowngrade(db, version, mNewVersion);
  83.                             } else {
  84.                                 onUpgrade(db, version, mNewVersion);
  85.                             }
  86.                         }
  87.                         db.setVersion(mNewVersion);
  88.                         db.setTransactionSuccessful();
  89.                     } finally {
  90.                         db.endTransaction();
  91.                     }
  92.                 }
  93.             }
  95.             onOpen(db);
  97.             if (db.isReadOnly()) {
  98.                 Log.w(TAG, "Opened " + mName + " in read-only mode");
  99.             }
  101.             mDatabase = db;
  102.             return db;
  103.         } finally {
  104.             mIsInitializing = false;
  105.             if (db != null && db != mDatabase) {
  106.                 db.close();
  107.             }
  108.         }
  109.     }
  • Android8.1.0及以上版本：均获取writable类型数据库，仅在发生异常时返回readable类型数据库
  1.     private SQLiteDatabase getDatabaseLocked(boolean writable) {
  2.         if (mDatabase != null) {
  3.             if (!mDatabase.isOpen()) {
  4.                 // Darn!  The user closed the database by calling mDatabase.close().
  5.                 mDatabase = null;
  6.             } else if (!writable || !mDatabase.isReadOnly()) {
  7.                 //如果获取只读数据库且缓存了可写数据库则直接返回
  8.                 // The database is already open for business.
  9.                 return mDatabase;
  10.             }
  11.         }
  13.         if (mIsInitializing) {
  14.             throw new IllegalStateException("getDatabase called recursively");
  15.         }
  17.         SQLiteDatabase db = mDatabase;
  18.         try {
  19.             mIsInitializing = true;
  21.             if (db != null) {
  22.                 //如果缓存的数据库为只读类型的，并且当次获取可写类型数据库，则覆用缓存数据库
  23.                 if (writable && db.isReadOnly()) {
  24.                     db.reopenReadWrite();
  25.                 }
  26.             } else if (mName == null) {
  27.                 db = SQLiteDatabase.createInMemory(mOpenParamsBuilder.build());
  28.             } else {
  29.                 //获取数据库的存储路径：注-仅次一处使用到了context对象
  30.                 final File filePath = mContext.getDatabasePath(mName);
  31.                 SQLiteDatabase.OpenParams params = mOpenParamsBuilder.build();
  32.                 try {
  33.                     //打开数据库实例对象
  34.                     db = SQLiteDatabase.openDatabase(filePath, params);
  35.                     // Keep pre-O-MR1 behavior by resetting file permissions to
  36.                     setFilePermissionsForDb(filePath.getPath());
  37.                 } catch (SQLException ex) {
  38.                     if (writable) {
  39.                         throw ex;
  40.                     }
  41.                     Log.e(TAG, "Couldn't open " + mName
  42.                             + " for writing (will try read-only):", ex);
  43.                     params = params.toBuilder().addOpenFlags(SQLiteDatabase.OPEN_READONLY).build();
  44.                     db = SQLiteDatabase.openDatabase(filePath, params);
  45.                 }
  46.             }
  48.             onConfigure(db);
  50.             final int version = db.getVersion();
  51.             if (version != mNewVersion) {
  52.                 if (db.isReadOnly()) {
  53.                     throw new SQLiteException("Can't upgrade read-only database from version " +
  54.                             db.getVersion() + " to " + mNewVersion + ": " + mName);
  55.                 }
  56.                 //程序运行时更新数据库：使用缓存数据库时走此逻辑，重新加载数据库
  57.                 if (version > 0 && version < mMinimumSupportedVersion) {
  58.                     File databaseFile = new File(db.getPath());
  59.                     onBeforeDelete(db);
  60.                     db.close();
  61.                     if (SQLiteDatabase.deleteDatabase(databaseFile)) {
  62.                         mIsInitializing = false;
  63.                         return getDatabaseLocked(writable);
  64.                     } else {
  65.                         throw new IllegalStateException("Unable to delete obsolete database "
  66.                                 + mName + " with version " + version);
  67.                     }
  68.                 } else {
  69.                 //事务更新（降级/升级）数据库
  70.                     db.beginTransaction();
  71.                     try {
  72.                         if (version == 0) {
  73.                             onCreate(db);
  74.                         } else {
  75.                             if (version > mNewVersion) {
  76.                                 onDowngrade(db, version, mNewVersion);
  77.                             } else {
  78.                                 onUpgrade(db, version, mNewVersion);
  79.                             }
  80.                         }
  81.                         db.setVersion(mNewVersion);
  82.                         db.setTransactionSuccessful();
  83.                     } finally {
  84.                         db.endTransaction();
  85.                     }
  86.                 }
  87.             }
  89.             onOpen(db);
  91.             if (db.isReadOnly()) {
  92.                 Log.w(TAG, "Opened " + mName + " in read-only mode");
  93.             }
  95.             mDatabase = db;
  96.             return db;
  97.         } finally {
  98.             mIsInitializing = false;
  99.             if (db != null && db != mDatabase) {
  100.                 db.close();
  101.             }
  102.         }
  103.     }

3、ContextImpl获取数据库路径

  1.     public File getDatabasePath(String name) {
  2.         File dir;
  3.         File f;
  4.         if (name.charAt(0) == File.separatorChar) {
  5.         //数据库文件名为绝对路径时，例如（/sdcard/test.db）则返回该绝对路径的文件对象。
  6.             String dirPath = name.substring(0, name.lastIndexOf(File.separatorChar));
  7.             dir = new File(dirPath);
  8.             name = name.substring(name.lastIndexOf(File.separatorChar));
  9.             f = new File(dir, name);
  10.             if (!dir.isDirectory() && dir.mkdir()) {
  11.                 FileUtils.setPermissions(dir.getPath(), 505, -1, -1);
  12.             }
  13.         } else {
  14.         //如果仅指定文件名称时，通过conext对象获取数据库文件存储目录，获取该目录下的数据库文件对象想。
  15.             dir = this.getDatabasesDir();
  16.             f = this.makeFilename(dir, name);
  17.         }
  19.         return f;
  20.     }

数据库本地文件路径

通过上面源码分析发现获取数据库对象的具体调用逻辑：

1、通过getWritableDatabase()方法获取数据库对象，实际是调用getDatabaseLocked(true)方法。

  1. public SQLiteDatabase getWritableDatabase() {
  2.         synchronized (this) {
  3.             return getDatabaseLocked(true);
  4.         }
  5.     }

getDatabaseLocked（true）方法获取数据库实例：获取数据库路径源码

  1.     private SQLiteDatabase getDatabaseLocked(boolean writable) {
  2.         SQLiteDatabase db = mDatabase;
  3.         try {
  4.             mIsInitializing = true;
  6.             if (db != null) {
  7.                 ...
  8.             } else if (mName == null) {
  9.             ...
  10.             } else {
  11.                 final File filePath = mContext.getDatabasePath(mName);
  12.                 SQLiteDatabase.OpenParams params = mOpenParamsBuilder.build();
  13.                 try {
  14.                     db = SQLiteDatabase.openDatabase(filePath, params);
  15.                    ...
  16.                 } catch (SQLException ex) {
  17.                     ...
  18.                     db = SQLiteDatabase.openDatabase(filePath, params);
  19.                 }
  20.             }
  21.             ...
  22.             mDatabase = db;
  23.             return db;
  24.         } finally {
  25.             ...
  26.              }
  27.     }

在getDatabaseLocked（true）获取数据库存储路径是调用Context的getDatabasePath(mName)方法，在Android中contex的具体实现类为ContextImpl，所以获取数据库存储路径要看ContextImpl.getDatabasePath(String)方法的实现。

  1.  public File getDatabasePath(String name) {
  2.         File dir;
  3.         File f;
  4.         if (name.charAt(0) == File.separatorChar) {
  5.         //数据库文件名为绝对路径时，例如（/sdcard/test.db）则返回该绝对路径的文件对象。
  6.             String dirPath = name.substring(0, name.lastIndexOf(File.separatorChar));
  7.             dir = new File(dirPath);
  8.             name = name.substring(name.lastIndexOf(File.separatorChar));
  9.             f = new File(dir, name);
  10.             if (!dir.isDirectory() && dir.mkdir()) {
  11.                 FileUtils.setPermissions(dir.getPath(), 505, -1, -1);
  12.             }
  13.         } else {
  14.         //如果仅指定文件名称时，通过conext对象获取数据库文件存储目录，获取该目录下的数据库文件对象想。
  15.             dir = this.getDatabasesDir();
  16.             f = this.makeFilename(dir, name);
  17.         }
  19.         return f;
  20.     }

自定义本地数据库文件路径

我们在使用数据库时有时候需要自定义数据库存储路径，下面介绍三种改变数据库文件路径的方法。

  • 一、更改context中getDatabasesDir()的返回值

    1、自定义Application

    2、覆写Application的getDatabasePath(String name)方法，在方法内指定自定义路径。

    3、在AndroidManifest.xml中指定自定义Application
  1. 1、自定义Application
  2. public class MyApplication extends Application{
  3. 	public static MyApplication getInstance()
  4. 	{
  5. 		return mInstance;
  6. 	}
  8. 	@Override
  9. 	public void onCreate()
  10. 	{
  11. 		super.onCreate();
  12. 	}
  14. 	@Override
  15. 	public File getDatabasePath(String name) {
  16. 		return new File("/sdcard/");
  17. 	}
  18. }
  20. 2、在manifest文件中指定application
  21. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  22.     package="com.qihoo.qa">
  23. //申请权限
  24.   ...
  25.     <application
  26.         android:name=".MyApplication"
  27.         android:label="@string/app_name"
  28.         android:icon="@drawable/ic_launcher"
  29.         android:supportsRtl="true"
  30.         android:theme="@style/AppTheme">
  32.     </application>
  33. </manifest>
  34. 4、获取DatabaseHelper,数据库文件为/sdcard/test.db
  35. DatabaseHelper dataBaseHelper =  new DatabaseHelper(context, "test.db", 0);
  • 二、构建数据库时传入绝对路径
  1. //获取DatabaseHelper,数据库文件为/sdcard/test.db
  2. DatabaseHelper dataBaseHelper =  new DatabaseHelper(context, "/sdcard/test.db", 0);
  • 三、在SQLiteOpenHelper子类中覆写getWritableDatabase()和getReadableDatabase()

  2. class DatabaseHelper extends SQLiteOpenHelper {
  3.     //1、指定数据库文件名
  4.     String dbName="/sdcard/test.db";
  5.     int version;
  6.     public DatabaseHelper(Context context, String dbName, int version) {
  7.         super(context, dbName, null, version);
  8.     }
  10.     @Override
  11.     public void onCreate(SQLiteDatabase db) {
  12.         //数据库创建时调用
  13.     }
  15.     @Override
  16.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  17.         //数据库升级时调用
  18.     }
  20.     //覆写获取数据库实现
  21.     @Override
  22.     public SQLiteDatabase getWritableDatabase() {
  23.         return getDataBase(dbName, version);
  24.     }
  25.     //覆写获取数据库实现
  26.     @Override
  27.     public SQLiteDatabase getReadableDatabase() {
  28.        return getDataBase(dbName, version);
  29.     }
  31.     //实现获取数据库具体逻辑
  32.     private SQLiteDatabase getDataBase(String fileName, int version){
  33.         try {
  34.             SQLiteDatabase database = SQLiteDatabase.openOrCreateDatabase(fileName, null);
  35.             int oldVer = database.getVersion();
  36.             database.setVersion(version);
  37.             if (version > oldVer) {
  38.                 this.onUpgrade(database, oldVer, version);
  39.             }
  40.             if(version<oldVer){
  41.                 this.onDowngrade(database, oldVer, version);
  42.             }
  44.             return database;
  45.         } catch (Exception var4) {
  46.             LogUtil.e(var4);
  47.             return super.getWritableDatabase();
  48.         }
  49.     }

注意

方法一、方法二需要传递context对象，如果Context为null，获取数据库实例时会导致空指针异常。

方法三的实现不依赖Context对象，可以将Context指定为null。

使用数据库的一些建议

  • 调用getWritableDatabase（）获取数据库时会重新创建数据库实例，一般在程序中复用该数据库实例即可，如果保存多份数据库实例会导致OOM异常。
  • 数据库插入数据时使用SQLiteStatement对数据进行封装，避免sql注入相关问题。
  • 数据库查询中使用方法Cursor rawQuery(String sql, String[] selectionArgs)指定动态参数，防止sql注入及异常字符问题。

再读Android sqlite的更多相关文章

  1. Android+Sqlite 实现古诗阅读应用（二）

    传送门:Android+Sqlite 实现古诗阅读应用(一) Hi,又回来了,最近接到很多热情洋溢的小伙伴们的来信,吼开心哈,我会继续努力的=-=! 上回的东西我们做到了有个textview能随机选择 ...

  2. Android SQLite (一) 数据库简介

    大家好,今天来介绍一下SQLite的相关知识,并结合Java实现对SQLite数据库的操作. SQLite是D.Richard Hipp用C语言编写的开源嵌入式数据库引擎.它支持大多数的SQL92标准 ...

  3. Android SQLite 简单使用演示样例

    SQLite简单介绍 Google为Andriod的较大的数据处理提供了SQLite,他在数据存储.管理.维护等各方面都相当出色,功能也很的强大. 袖珍型的SQLite能够支持高达2TB大小的数据库, ...

  4. android SQLite数据库（转）

    Android数据库 之 SQLite数据库   Android数据库  一.关系型数据库SQLIte 每个应用程序都要使用数据,Android应用程序也不例外,Android使用开源的.与操作系统无 ...

  5. Android SQLite总结(一) （转）

    Android SQLite总结(一)  郑海波 2012-08-21 转载请声明:http://blog.csdn.net/nuptboyzhb/article/details/7891887 前言 ...

  6. Android SQLite 数据库详细介绍

    Android SQLite 数据库详细介绍 我们在编写数据库应用软件时,需要考虑这样的问题:因为我们开发的软件可能会安装在很多用户的手机上,如果应用使用到了SQLite数据库,我们必须在用户初次使用 ...

  7. Android Sqlite 导入CSV文件 .

    http://blog.csdn.net/johnnycode/article/details/7413111 今天遇到 Oracle 导出的12万条CSV格式数据导入 Android Sqlite ...

  8. Android SQLite 数据库 增删改查操作

    Android SQLite 数据库 增删改查操作 转载▼ 一.使用嵌入式关系型SQLite数据库存储数据 在Android平台上,集成了一个嵌入式关系型数据库--SQLite,SQLite3支持NU ...

  9. Android SQLite总结[转载]

    [转载] :http://blog.163.com/zqy216_2008/blog/static/4119371820119954812509/ 最近在做的项目涉及到了SQLite,大学时没有好好学 ...

随机推荐

  1. 告诉大家我是如何在14:00秒杀到 《深入理解Bootstrap》

    1.打开火狐,不用IE,3个评论窗口,层叠在一起,可以点击3次哦. 2.打开一个百度的现在时间,不能看你本机的时间,要互联网的时间. 3.等时间到13:59:59,开始依次点击按钮,总有你预想不到的结 ...

  2. NPOI设置Excel中的单元格识别为日期

    只有月/日/年的格式,才能显示为Date 其他的,都是显示为Custom

  3. bzoj 4337 树的同构

    4337: BJOI2015 树的同构 Description 树是一种很常见的数据结构. 我们把N个点,N-1条边的连通无向图称为树. 若将某个点作为根,从根开始遍历,则其它的点都有一个前驱,这个树 ...

  4. EasyUI Datagrid 分页显示（客户端）

    转自:https://blog.csdn.net/metal1/article/details/17536185 EasyUI Datagrid 分页显示(客户端) By ZYZ 在使用JQuery ...

  5. E20170603-ts

    sanitize vt. 净化; 进行消毒; 使清洁; 审查; omission  n. 遗漏; 疏忽; 省略,删节; [法] 不履行法律责任; separator   n. 分离器,分离装置; 防胀 ...

  6. 基于ASP.Net Core开发一套通用后台框架记录-(总述)

    写在前面 本系列博客是本人在学习的过程中搭建学习的记录,如果对你有所帮助那再好不过.如果您有发现错误,请告知我,我会第一时间修改. 前期我不会公开源码,我想是一点点敲代码,不然复制.粘贴那就没意思了. ...

  7. 最大加权矩形 luogu1719

    题目链接:https://www.luogu.org/problemnew/show/P1719 这道题挺好做的 又是一道练前缀和的题 #include <bits/stdc++.h> # ...

  8. mysql left join 出现的结果会重复

    left join 基本用法 MySQL left join 语句格式 A LEFT JOIN B ON 条件表达式 left join 是以A表为基础,A表即左表,B表即右表. 左表(A)的记录会全 ...

  9. python自动化测试学习笔记-10YAML

    之前学习的编写测试用例的方法,都是从excel中编写接口的测试用例,然后通过读取excel文件进行接口自动化测试,这种方式我们叫做数据驱动的方式,由于excel操作起来不灵活,无法实现关联关系的接口测 ...

  10. [C++ 多线程] 学习前瞻

    1 多线程是什么? 1.1 多线程的概念? 说起多线程,那么就不得不说什么是线程,而说起线程,又不得不说什么是进程. 进程可以简单的理解为一个可以独立运行的程序单位,它是线程的集合,进程就是有一个或多 ...