Android 架構之數據庫框架升級
前言：
上一篇講解瞭Android 架構之數據框架搭建 ，裡面含有數據庫最基礎的增刪改查功能，不過隻考慮瞭單數據庫，開發者可以舉一反三按照對應思路設計多數據庫架構。 在本篇裡，將會講解令開發者比較頭疼的數據庫升級。
話不多說，先來看代碼效果，看看是否是想要的
如上圖所示：
- 當前APP版本號為V007；
- V001、V002升級到V007有對應的處理邏輯；
- V003、V004、V005、V006升級到V007也有對應的處理邏輯；
- 同理可實現任意版本可闊多個版本升級到最新數據庫；
開始之前我們先理一下數據庫升級的邏輯
- 任何數據庫在操作之前，我們最好有一個數據庫備份，所以這裡得要備份對應的數據庫File文件；
- 任何數據表在操作之前，也要有一個數據表備份，所以這裡會在原表名加前後綴操作；
- 在數據表升級的時候，有些時候可能會對表名、表列做任意增刪改的操作，所以這裡每次都要創建一個全新的表；
- 全新表創建好瞭，但是一張空表，這裡就需要查詢對應加瞭前後綴的原表數據，將對應數據添加至新表裡；
- 數據全部拷貝完成時，為瞭讓用戶有良好的體驗，我們需要刪除對應加瞭前後綴的原表；
- 對應原表刪除完畢時，我們需要刪除對應備份數據庫的
File文件。
總結：
- 操作【1】和【6】 這倆操作 屬於 java代碼執行
- 其他【2】、【3】、【4】、【5】 這些操作，都屬於SQL操作
- 但SQL操作，通過效果圖發現，是寫在XML文件裡面的，所以需要寫一個XML解析器
現在我們就按照對應步驟一一講解
1、備份原數據庫File文件
/**
* 復制單個文件(可更名復制)
*
* @param oldPathFile 準備復制的文件源
* @param newPathFile 拷貝到新絕對路徑帶文件名(註：目錄路徑需帶文件名)
* @return
*/
public static void CopySingleFile(String oldPathFile, String newPathFile) {
try {
// int bytesum = 0;
int byteread = 0;
File oldfile = new File(oldPathFile);
File newFile = new File(newPathFile);
File parentFile = newFile.getParentFile();
if (!parentFile.exists()) {
parentFile.mkdirs();
}
if (oldfile.exists()) { //文件存在時
InputStream inStream = new FileInputStream(oldPathFile); //讀入原文件
FileOutputStream fs = new FileOutputStream(newPathFile);
byte[] buffer = new byte[1024];
while ((byteread = inStream.read(buffer)) != -1) {
// bytesum += byteread; //字節數 文件大小
fs.write(buffer, 0, byteread);
}
inStream.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
總結：這也沒啥可說的，就一個很簡單的文件復制。
2、數據庫升級XML編寫 updateXml.xml
<?xml version="1.0" encoding="utf-8"?>
<updateXml>
<createVersion version="V007">
<createDb name="hqk"> <!-- 要升級數據庫對應名 ，如果應用含多個數據庫，那麼可以創建多個 createDb 標簽-->
<sql_createTable> <!-- 創建最新的表結構 -->
<!--
@DbFiled("time")
private String time;
@DbFiled("id")
private Long id;
@DbFiled("path")
private String path;
-->
create table if not exists tb_photo ( id Long,tb_time TEXT ,tb_path TEXT,tb_name TEXT);
</sql_createTable>
</createDb>
</createVersion>
<!-- V001,V002對應版本的app升級到 最新V007版本的升級邏輯-->
<updateStep versionFrom="V001,V002" versionTo="V007">
<!-- 對應數據升級邏輯，對應上面的 createDb 標簽name ，如果有多對 createDb，這裡也可執行多對 updateDb-->
<updateDb name="hqk">
<sql_before> <!-- 將V001,V002對應的舊表重命名備份-->
alter table tb_photo rename to bak_tb_photo;
</sql_before>
<sql_after> <!-- 查詢重命名後舊表數據，將對應數據添加至新表裡-->
insert into tb_photo(tb_time,id, tb_path) select tb_time,tb_id,tb_path from bak_tb_photo;
</sql_after>
<sql_after><!-- 刪除舊表備份-->
drop table if exists bak_tb_photo;
</sql_after>
</updateDb>
</updateStep>
<updateStep versionFrom="V003,V004,V005,V006" versionTo="V007">
<updateDb name="hqk">
<sql_before>
alter table tb_photo rename to bak_tb_photo;
</sql_before>
<sql_after>
insert into tb_photo(tb_time,id, tb_path) select tb_time,tb_id,tb_path from
bak_tb_photo;
</sql_after>
<sql_after>
drop table if exists bak_tb_photo;
</sql_after>
</updateDb>
</updateStep>
</updateXml>
總結：
createVersion標簽 ，表示 當前 最新APP版本需要操作的內容createDb標簽，表示當前最新對應的數據庫要操作的內容，可多組標簽，實現多個數據庫升級sql_createTable標簽，表示當前最新對應的數據表要操作的內容，可多組標簽，實現多表升級updateStep標簽，表示不同版本要升級的對象，可多組標簽，達到不同版本數據庫升級到最新數據庫的效果updateDb標簽，表示舊版本要修改的對應數據庫sql_before標簽，表示數據庫升級時優先級最高的SQL，（在新表創建前執行）sql_after標簽，表示數據庫升級時優先級最低並按順序執行的SQL（在新表創建後執行）
3、創建XML解析器
3.1 對應工具類 DomUtils.class
public class DomUtils {
/**
* 讀取升級xml
*
* @param context
* @return
*/
public static UpdateDbXml readDbXml(Context context) {
InputStream is = null;
Document document = null;
try {
is = context.getAssets().open("updateXml.xml");
DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
document = builder.parse(is);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
if (document == null) {
return null;
}
UpdateDbXml xml = new UpdateDbXml(document);
return xml;
}
/**
* 新表插入數據
*
* @param xml
* @param lastVersion 上個版本
* @param thisVersion 當前版本
* @return
*/
public static UpdateStep findStepByVersion(UpdateDbXml xml, String lastVersion, String thisVersion) {
if (lastVersion == null || thisVersion == null) {
return null;
}
// 更新腳本
UpdateStep thisStep = null;
if (xml == null) {
return null;
}
List<UpdateStep> steps = xml.getUpdateSteps();
if (steps == null || steps.size() == 0) {
return null;
}
for (UpdateStep step : steps) {
if (step.getVersionFrom() == null || step.getVersionTo() == null) {
} else {
// 升級來源以逗號分隔
String[] lastVersionArray = step.getVersionFrom().split(",");
if (lastVersionArray != null && lastVersionArray.length > 0) {
for (int i = 0; i < lastVersionArray.length; i++) {
// 有一個配到update節點即升級數據
if (lastVersion.equalsIgnoreCase(lastVersionArray[i]) && step.getVersionTo().equalsIgnoreCase(thisVersion)) {
thisStep = step;
break;
}
}
}
}
}
return thisStep;
}
/**
* 解析出對應版本的建表腳本
*
* @return
*/
public static CreateVersion findCreateByVersion(UpdateDbXml xml, String version) {
CreateVersion cv = null;
if (xml == null || version == null) {
return cv;
}
List<CreateVersion> createVersions = xml.getCreateVersions();
if (createVersions != null) {
for (CreateVersion item : createVersions) {
Log.i("david", "item=" + item.toString());
// 如果表相同則要支持xml中逗號分隔
String[] createVersion = item.getVersion().trim().split(",");
for (int i = 0; i < createVersion.length; i++) {
if (createVersion[i].trim().equalsIgnoreCase(version)) {
cv = item;
break;
}
}
}
}
return cv;
}
}
3.2 對應XML的實體類
UpdateDbXml
/**
* @ClassName: UpdateDbXml
* @Description: 升級更新數據庫
*
*/
public class UpdateDbXml {
/**
* 升級腳本列表
*/
private List<UpdateStep> updateSteps;
/**
* 升級版本
*/
private List<CreateVersion> createVersions;
public UpdateDbXml(Document document) {
{
// 獲取升級腳本
NodeList updateSteps = document.getElementsByTagName("updateStep");
this.updateSteps = new ArrayList<UpdateStep>();
for (int i = 0; i < updateSteps.getLength(); i++) {
Element ele = (Element) (updateSteps.item(i));
Log.i("jett","updateSteps 各個升級的版本:"+ele.toString());
UpdateStep step = new UpdateStep(ele);
this.updateSteps.add(step);
}
}
{
/**
* 獲取各升級版本
*/
NodeList createVersions = document.getElementsByTagName("createVersion");
this.createVersions = new ArrayList<CreateVersion>();
for (int i = 0; i < createVersions.getLength(); i++) {
Element ele = (Element) (createVersions.item(i));
Log.i("jett","各個升級的版本:"+ele.toString());
CreateVersion cv = new CreateVersion(ele);
this.createVersions.add(cv);
}
}
}
public List<UpdateStep> getUpdateSteps() {
return updateSteps;
}
public void setUpdateSteps(List<UpdateStep> updateSteps) {
this.updateSteps = updateSteps;
}
public List<CreateVersion> getCreateVersions() {
return createVersions;
}
public void setCreateVersions(List<CreateVersion> createVersions) {
this.createVersions = createVersions;
}
}
UpdateStep.class
/**
* @ClassName: UpdateStep
* @Description: 數據庫升級腳本信息
*/
public class UpdateStep
{
/**
* 舊版本
*/
private String versionFrom;
/**
* 新版本
*/
private String versionTo;
/**
* 更新數據庫腳本
*/
private List<UpdateDb> updateDbs;
// ==================================================
public UpdateStep(Element ele)
{
versionFrom = ele.getAttribute("versionFrom");
versionTo = ele.getAttribute("versionTo");
updateDbs = new ArrayList<UpdateDb>();
NodeList dbs = ele.getElementsByTagName("updateDb");
for (int i = 0; i < dbs.getLength(); i++)
{
Element db = (Element) (dbs.item(i));
UpdateDb updateDb = new UpdateDb(db);
this.updateDbs.add(updateDb);
}
}
public List<UpdateDb> getUpdateDbs()
{
return updateDbs;
}
public void setUpdateDbs(List<UpdateDb> updateDbs)
{
this.updateDbs = updateDbs;
}
public String getVersionFrom()
{
return versionFrom;
}
public void setVersionFrom(String versionFrom)
{
this.versionFrom = versionFrom;
}
public String getVersionTo()
{
return versionTo;
}
public void setVersionTo(String versionTo)
{
this.versionTo = versionTo;
}
}
UpdateDb.class
**
* @ClassName: UpdateDb
* @Description: 更新數據庫腳本
*
*/
public class UpdateDb
{
/**
* 數據庫名稱
*/
private String dbName;
/**
*
*/
private List<String> sqlBefores;
/**
*
*/
private List<String> sqlAfters;
public UpdateDb(Element ele)
{
dbName = ele.getAttribute("name");
sqlBefores = new ArrayList<String>();
sqlAfters = new ArrayList<String>();
{
NodeList sqls = ele.getElementsByTagName("sql_before");
for (int i = 0; i < sqls.getLength(); i++)
{
String sql_before = sqls.item(i).getTextContent();
this.sqlBefores.add(sql_before);
}
}
{
NodeList sqls = ele.getElementsByTagName("sql_after");
for (int i = 0; i < sqls.getLength(); i++)
{
String sql_after = sqls.item(i).getTextContent();
this.sqlAfters.add(sql_after);
}
}
}
public String getName()
{
return dbName;
}
public void setDbName(String dbName)
{
this.dbName = dbName;
}
public List<String> getSqlBefores()
{
return sqlBefores;
}
public void setSqlBefores(List<String> sqlBefores)
{
this.sqlBefores = sqlBefores;
}
public List<String> getSqlAfters()
{
return sqlAfters;
}
public void setSqlAfters(List<String> sqlAfters)
{
this.sqlAfters = sqlAfters;
}
}
CreateVersion.class
public class CreateVersion
{
/**
* 版本信息
*/
private String version;
/**
* 創建數據庫表腳本
*/
private List<CreateDb> createDbs;
public CreateVersion(Element ele)
{
version = ele.getAttribute("version");
Log.i("jett","CreateVersion="+version);
{
createDbs = new ArrayList<CreateDb>();
NodeList cs = ele.getElementsByTagName("createDb");
for (int i = 0; i < cs.getLength(); i++)
{
Element ci = (Element) (cs.item(i));
CreateDb cd = new CreateDb(ci);
this.createDbs.add(cd);
}
}
}
public String getVersion()
{
return version;
}
public void setVersion(String version)
{
this.version = version;
}
public List<CreateDb> getCreateDbs()
{
return createDbs;
}
public void setCreateDbs(List<CreateDb> createDbs)
{
this.createDbs = createDbs;
}
}
CreateDb.class
/**
* @ClassName: CreateDb
* @Description: 創建數據庫腳本
*
*/
public class CreateDb
{
/**
* 數據庫表名
*/
private String name;
/**
* 創建表的sql語句集合
*/
private List<String> sqlCreates;
public CreateDb(Element ele)
{
name = ele.getAttribute("name");
{
sqlCreates = new ArrayList<String>();
NodeList sqls = ele.getElementsByTagName("sql_createTable");
for (int i = 0; i < sqls.getLength(); i++)
{
String sqlCreate = sqls.item(i).getTextContent();
this.sqlCreates.add(sqlCreate);
}
}
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public List<String> getSqlCreates()
{
return sqlCreates;
}
public void setSqlCreates(List<String> sqlCreates)
{
this.sqlCreates = sqlCreates;
}
}
4、萬事俱備隻欠東風： UpdateManager.class
public class UpdateManager {
private File parentFile = ContUtils.parentFile;
private File bakFile = ContUtils.bakFile;
private List<User> userList;
public void startUpdateDb(Context context) {
//讀取XML文件，將XML內容轉化為對應對象
UpdateDbXml updateDbxml = DomUtils.readDbXml(context);
// 下載 上一個版本 --》下一個版本 【註：在下載時，需要將舊版本、新版本以逗號的形式寫入文件緩存】
String[] versions = FileUtil.getLocalVersionInfo(new File(parentFile,
"update.txt"));
String lastVersion = versions[0];//拿到上一個版本
String thisVersion = versions[1];//拿到當前版本
//數據庫File原地址
String userFile = ContUtils.sqliteDatabasePath;
//數據庫File備份地址
String user_bak = ContUtils.copySqliteDatabasePath;
//升級前，數據庫File備份
FileUtil.CopySingleFile(userFile, user_bak);
//根據對應新舊版本號查詢XML轉化對象裡面的腳本，得到對應升級腳本
UpdateStep updateStep = DomUtils.findStepByVersion(updateDbxml, lastVersion, thisVersion);
if (updateStep == null) {
return;
}
//拿到對應升級腳本
List<UpdateDb> updateDbs = updateStep.getUpdateDbs();
try {
//將原始數據庫中所有的表名 更改成 bak_表名(數據還在)
executeBeforesSql(updateDbs);
//檢查新表，創建新表
CreateVersion createVersion = DomUtils.findCreateByVersion(updateDbxml, thisVersion);
executeCreateVersion(createVersion);
//將原來bak_表名 的數據遷移到 新表中
executeAftersSql(updateDbs);
} catch (Exception e) {
e.printStackTrace();
}
}
private void executeAftersSql(List<UpdateDb> updateDbs) throws Exception {
for (UpdateDb db : updateDbs) {
if (db == null || db.getName() == null) {
throw new Exception("db or dbName is null;");
}
List<String> sqls = db.getSqlAfters();
SQLiteDatabase sqlitedb = getDb();
//執行數據庫語句
executeSql(sqlitedb, sqls);
sqlitedb.close();
}
}
private void executeCreateVersion(CreateVersion createVersion) throws Exception {
if (createVersion == null || createVersion.getCreateDbs() == null) {
throw new Exception("createVersion or createDbs is null;");
}
for (CreateDb cd : createVersion.getCreateDbs()) {
if (cd == null || cd.getName() == null) {
throw new Exception("db or dbName is null when createVersion;");
}
// 創建數據庫表sql
List<String> sqls = cd.getSqlCreates();
SQLiteDatabase sqlitedb = getDb();
executeSql(sqlitedb, sqls);
sqlitedb.close();
}
}
//所有的表名 更改成 bak_表名(數據還在)
private void executeBeforesSql(List<UpdateDb> updateDbs) throws Exception {
for (UpdateDb db : updateDbs) {
if (db == null || db.getName() == null) {
throw new Exception("db or dbName is null;");
}
List<String> sqls = db.getSqlBefores();
SQLiteDatabase sqlitedb = getDb();
//執行數據庫語句
executeSql(sqlitedb, sqls);
sqlitedb.close();
}
}
private SQLiteDatabase getDb() {
String dbfilepath = null;
SQLiteDatabase sqlitedb = null;
dbfilepath = ContUtils.sqliteDatabasePath;// logic對應的數據庫路徑
if (dbfilepath != null) {
File f = new File(dbfilepath);
f.mkdirs();
if (f.isDirectory()) {
f.delete();
}
sqlitedb = SQLiteDatabase.openOrCreateDatabase(dbfilepath, null);
}
return sqlitedb;
}
private void executeSql(SQLiteDatabase sqlitedb, List<String> sqls) {
// 檢查參數
if (sqls == null || sqls.size() == 0) {
return;
}
sqlitedb.beginTransaction();
for (String sql : sqls) {
sql = sql.replaceAll("\r\n", " ");
sql = sql.replaceAll("\n", " ");
if (!"".equals(sql.trim())) {
try {
// Logger.i(TAG, "執行sql：" + sql, false);
sqlitedb.execSQL(sql);
} catch (SQLException e) {
}
}
}
sqlitedb.setTransactionSuccessful();
sqlitedb.endTransaction();
}
}
到此這篇關於Android 架構之數據庫框架升級的文章就介紹到這瞭,更多相關Android 架構之數據庫框架內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！
推薦閱讀：
- Java實現赫夫曼樹(哈夫曼樹)的創建
- java數據結構基礎:單,雙向鏈表
- Android源碼探究之BaseDexClassLoader的使用
- Android整理需要翻譯的strings資源詳情
- Java中使用DOM4J生成xml文件並解析xml文件的操作