一、SQLiteOpenHelper 调用入口
/**
* Open the database according to the flags {@link #OPEN_READWRITE}
* {@link #OPEN_READONLY} {@link #CREATE_IF_NECESSARY} and/or {@link #NO_LOCALIZED_COLLATORS}.
*
* <p>Sets the locale of the database to the the system's current locale.
* Call {@link #setLocale} if you would like something else.</p>
*
* <p>Accepts input param: a concrete instance of {@link DatabaseErrorHandler} to be
* used to handle corruption when sqlite reports database corruption.</p>
*
* @param path to database file to open and/or create
* @param factory an optional factory class that is called to instantiate a
* cursor when query is called, or null for default
* @param flags to control database access mode
* @param errorHandler the {@link DatabaseErrorHandler} obj to be used to handle corruption
* when sqlite reports database corruption
* @return the newly opened database
* @throws SQLiteException if the database cannot be opened
*/
public static SQLiteDatabase openDatabase(String path, CursorFactory factory, int flags, DatabaseErrorHandler errorHandler) {
// 创建 SQLiteDatabase 对象
SQLiteDatabase db = new SQLiteDatabase(path, flags, factory, errorHandler);
// 创建连接池，打开主连接
db.open();
return db;
}
1. SQLiteDatabase 构造方法，创建 SQLiteDatabase 对象
private SQLiteDatabase(String path, int openFlags, CursorFactory cursorFactory, DatabaseErrorHandler errorHandler) {
// mCursorFactory 默认为 null
mCursorFactory = cursorFactory;
// 创建 onCorruption 的回调处理对象，DefaultDatabaseErrorHandler 的处理是删除数据库文件
// 可以通过 SQLiteOpenHelper 的构造方法传入，用于自定义数据库损坏时的操作
mErrorHandler = errorHandler != null ? errorHandler : new DefaultDatabaseErrorHandler();
mConfigurationLocked = new SQLiteDatabaseConfiguration(path, openFlags);
}
2. db.open() 初始化连接池
private void open() {
try {
try {
// 创建连接池，打开主连接
openInner();
} catch (SQLiteDatabaseCorruptException ex) {
// 默认处理是，若数据库已关闭(连接池赋值为 null)，则删除数据库文件
onCorruption();
// 再次尝试
openInner();
}
} catch (SQLiteException ex) {
Log.e(TAG, "Failed to open database '" + getLabel() + "'.", ex);
// 如果连接池不为 null，则关闭连接池
close();
throw ex;
}
}
private void openInner() {
synchronized (mLock) {
// assert 断言，为 true 时则继续执行
assert mConnectionPoolLocked == null;
// 创建连接池，打开主连接
mConnectionPoolLocked = SQLiteConnectionPool.open(mConfigurationLocked);
mCloseGuardLocked.open("close");
}
synchronized (sActiveDatabases) {
sActiveDatabases.put(this, null);
}
}
二、初始化 SQLiteConnectionPool
1. SQLiteConnectionPool.open() 调用入口
/**
* 创建连接池，打开主连接
* Opens a connection pool for the specified database.
*
* @param configuration The database configuration.
* @return The connection pool.
*
* @throws SQLiteException if a database error occurs.
*/
public static SQLiteConnectionPool open(SQLiteDatabaseConfiguration configuration) {
if (configuration == null) {
throw new IllegalArgumentException("configuration must not be null.");
}
// Create the pool.
SQLiteConnectionPool pool = new SQLiteConnectionPool(configuration);
// 打开主连接
pool.open(); // might throw
return pool;
}
2. SQLiteConnectionPool 构造方法，创建连接池对象
private SQLiteConnectionPool(SQLiteDatabaseConfiguration configuration) {
// 保存数据库配置项
mConfiguration = new SQLiteDatabaseConfiguration(configuration);
// 设置连接池最大连接数
// 1. 默认情况下，连接数量为 1
// 2. 开启多线程并发功能后，连接数量由系统配置，最少有两条
setMaxConnectionPoolSizeLocked();
}
/**
* 设置连接池最大连接数
* 1. 默认情况下，连接数量为 1
* 2. 开启多线程并发功能后，连接数量由系统配置，最少有两条
*/
private void setMaxConnectionPoolSizeLocked() {
if ((mConfiguration.openFlags & SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING) != 0) {
// 开启了多线程并发功能，该功能默认不开启
// 连接数量由系统配置，最少有两条
mMaxConnectionPoolSize = SQLiteGlobal.getWALConnectionPoolSize();
} else {
// TODO: We don't actually need to restrict the connection pool size to 1
// for non-WAL databases. There might be reasons to use connection pooling
// with other journal modes. For now, enabling connection pooling and
// using WAL are the same thing in the API.
// 注意此处，连接数量默认为 1
mMaxConnectionPoolSize = 1;
}
}
/**
* 返回值 >= 2
* Gets the connection pool size when in WAL mode.
*/
public static int getWALConnectionPoolSize() {
int value = SystemProperties.getInt("debug.sqlite.wal.poolsize",
Resources.getSystem().getInteger(com.android.internal.R.integer.db_connection_pool_size));
return Math.max(2, value);
}
三、 打开连接池主连接
/**
* 打开主连接
* Might throw
*/
private void open() {
// Open the primary connection.
// This might throw if the database is corrupt.
// 打开主连接
mAvailablePrimaryConnection = openConnectionLocked(mConfiguration, true /*primaryConnection*/); // might throw
// Mark the pool as being open for business.
mIsOpen = true;
mCloseGuard.open("close");
}
// Might throw.
private SQLiteConnection openConnectionLocked(SQLiteDatabaseConfiguration configuration, boolean primaryConnection) {
final int connectionId = mNextConnectionId++;
return SQLiteConnection.open(this, configuration, connectionId, primaryConnection); // might throw
}
1. 创建连接(主连接)
/**
* 1. 创建连接
* 2. 打开连接
*
* @param pool
* @param configuration
* @param connectionId
* @param primaryConnection 是否是主连接
* @return
*/
// Called by SQLiteConnectionPool only.
static SQLiteConnection open(SQLiteConnectionPool pool, SQLiteDatabaseConfiguration configuration, int connectionId, boolean primaryConnection) {
// 创建连接
SQLiteConnection connection = new SQLiteConnection(pool, configuration, connectionId, primaryConnection);
try {
// 打开连接
connection.open();
return connection;
} catch (SQLiteException ex) {
connection.dispose(false);
throw ex;
}
}
2. SQLiteConnection 构造方法
private SQLiteConnection(SQLiteConnectionPool pool, SQLiteDatabaseConfiguration configuration, int connectionId, boolean primaryConnection) {
mPool = pool;
mConfiguration = new SQLiteDatabaseConfiguration(configuration);
mConnectionId = connectionId;
// 是否为主连接
mIsPrimaryConnection = primaryConnection;
// 是否是只读连接
mIsReadOnlyConnection = (configuration.openFlags & SQLiteDatabase.OPEN_READONLY) != 0;
mPreparedStatementCache = new SQLiteConnection.PreparedStatementCache(mConfiguration.maxSqlCacheSize);
mCloseGuard.open("close");
}
3. 打开连接
private void open() {
// 调用 native 方法打开连接
mConnectionPtr = nativeOpen(mConfiguration.path, mConfiguration.openFlags, mConfiguration.label, SQLiteDebug.DEBUG_SQL_STATEMENTS, SQLiteDebug.DEBUG_SQL_TIME);
// 如果是只读连接或者数据库只存在于内存中，则不做任何处理
setPageSize();
// 如果是只读连接则不做任何处理
setForeignKeyModeFromConfiguration();
// 如果是只读连接或者数据库只存在于内存中，则不做任何处理
setWalModeFromConfiguration();
// 如果是只读连接或者数据库只存在于内存中，则不做任何处理
setJournalSizeLimit();
// 如果是只读连接或者数据库只存在于内存中，则不做任何处理
setAutoCheckpointInterval();
setLocaleFromConfiguration();
// Register custom functions.
final int functionCount = mConfiguration.customFunctions.size();
for (int i = 0; i < functionCount; i++) {
SQLiteCustomFunction function = mConfiguration.customFunctions.get(i);
nativeRegisterCustomFunction(mConnectionPtr, function);
}
}
