sqlite 数据库源码 调用顺序，版本执行

从注释源码中可以看出,sqliteOpenHelper实现的onCreate和onUpgrade函数并不是在构造函数中被调用的.而是当需要获取数据库句柄时,即调用getWritableDatabase或者getReadableDatabase时被调用的.
getWritableDatabase和getReadableDatabase都是对getDatabaseLocked的加锁封装.在getDatabaseLocked中,也并非每次都会调用onCreate或者onUpgrade函数,只是当之前数据库版本号和当前数据库版本号不一致时才会根据情况调用,其他情况下只是打开可读写的文件句柄而已.
public abstract class sqliteOpenHelper {
    /**
     * 为true时,当数据库句柄已经打开,返回read-only句柄.
     */
    private static final boolean DEBUG_STRICT_READONLY = false;

    private final Context mContext;

    /**
     * 数据库文件名称.
     */
    private final String mName;
    private final CursorFactory mFactory;

    /**
     * 数据库版本号.
     */
    private final int mNewVersion;
    private final DatabaseErrorHandler mErrorHandler;

    /**
     * 数据库句柄.
     */
    private sqliteDatabase mDatabase;

    /**
     * 数据库打开进行时标记.
     */
    private boolean mIsInitializing;

    /**
     * sqliteOpenHelper的构造函数,用来创建,打开,操作sqlite数据库.
     * 这个方法会被很快返回.因为这个方法只是参数赋值,并没有真正的创建sqlite数据库.
     * 只有当getWritableDatabase或者getReadableDatabase被调用时,sqlite数据库才会被真正的创建或打开.
     *
     * @param context      进程上下文
     * @param name         文件系统存储的数据库文件名称
     * @param factory      to use for creating cursor objects,or null for the default
     * @param version      数据库版本号,初始版本为1
     * @param errorHandler 处理sqlite异常类,默认为null.
     */
    public sqliteOpenHelper(Context context,String name,CursorFactory factory,int version,DatabaseErrorHandler errorHandler) {
        if (version < 1) throw new IllegalArgumentException("Version must be >= 1,was " + version);

        mContext = context;
        mName = name;
        mFactory = factory;
        mNewVersion = version;
        mErrorHandler = errorHandler;
    }

    /**
     * 返回数据库文件名称
     */
    public String getDatabaseName() {
        return mName;
    }

    /**
     * 创建可读可写的数据库句柄.这个函数第一次调用时,会调用onCreate方法或者onUpgrade方法.
     */
    public sqliteDatabase getWritableDatabase() {
        synchronized (this) {
            return getDatabaseLocked(true);
        }
    }

    /**
     * 创建只读数据库句柄.
     */
    public sqliteDatabase getReadableDatabase() {
        synchronized (this) {
            return getDatabaseLocked(false);
        }
    }

    private sqliteDatabase getDatabaseLocked(boolean writable) {
        if (mDatabase != null) {
            if (!mDatabase.isopen()) {
                // 说明用户手动调用close方法将mDatabase关闭了,需要重启打开
                mDatabase = null;
            } else if (!writable || !mDatabase.isReadOnly()) {
                // The database is already open for business.
                return mDatabase;
            }
        }

        if (mIsInitializing) {
            // 防止递归调用.
            throw new IllegalStateException("getDatabase called recursively");
        }

        sqliteDatabase db = mDatabase;
        try {
            // 打开数据库前将mIsInitializing置为true,结束时置为false.
            mIsInitializing = true;

            if (db != null) {
                if (writable && db.isReadOnly()) {
                    db.reopenReadWrite();
                }
            } else if (mName == null) {
                db = sqliteDatabase.create(null);
            } else {
                // mName不存在则创建数据库文件.
                try {
                    if (DEBUG_STRICT_READONLY && !writable) {
                        final String path = mContext.getDatabasePath(mName).getPath();
                        db = sqliteDatabase.openDatabase(path,mFactory,sqliteDatabase.OPEN_READONLY,mErrorHandler);
                    } else {
                        db = mContext.openorCreateDatabase(mName,mErrorHandler);
                    }
                } catch (sqliteException ex) {
                    if (writable) {
                        throw ex;
                    }
                    final String path = mContext.getDatabasePath(mName).getPath();
                    db = sqliteDatabase.openDatabase(path,mErrorHandler);
                }
            }

            // 获取当前数据库版本号,第一次创建版本号为0
            final int version = db.getVersion();
            // 版本号不一致,则进行onCreate或者onUpgrade操作.
            if (version != mNewVersion) {
                if (db.isReadOnly()) {
                    throw new sqliteException("Can't upgrade read-only database from version " +
                            db.getVersion() + " to " + mNewVersion + ": " + mName);
                }

                db.beginTransaction();
                try {
                    if (version == 0) {
                        // 第一次创建数据库调用onCreate方法
                        onCreate(db);
                    } else {
                        if (version > mNewVersion) {
                            // 数据库版本大于当前版本,执行降级操作
                            onDowngrade(db,version,mNewVersion);
                        } else {
                            // 数据库版本小于当前版本,执行升级操作
                            onUpgrade(db,mNewVersion);
                        }
                    }
                    db.setVersion(mNewVersion);
                    db.setTransactionSuccessful();
                } finally {
                    db.endTransaction();
                }
            }

            mDatabase = db;
            return db;
        } finally {
            mIsInitializing = false;
            if (db != null && db != mDatabase) {
                db.close();
            }
        }
    }

    /**
     * 关闭数据库句柄.
     */
    public synchronized void close() {
        if (mIsInitializing) throw new IllegalStateException("Closed during initialization");

        if (mDatabase != null && mDatabase.isopen()) {
            mDatabase.close();
            mDatabase = null;
        }
    }

    /**
     * 创建数据库.
     */
    public abstract void onCreate(sqliteDatabase db);

    /**
     * 数据库升级.
     */
    public abstract void onUpgrade(sqliteDatabase db,int oldVersion,int newVersion);

    /**
     * 数据库降级.
     */
    public void onDowngrade(sqliteDatabase db,int newVersion) {
        throw new sqliteException("Can't downgrade database from version " +
                oldVersion + " to " + newVersion);
    }
}