2. 程式人生 > >Android SQLite 建表 面向物件程式設計 完美封裝 一勞永逸

Android SQLite 建表 面向物件程式設計 完美封裝 一勞永逸

阿新 • • 發佈：2019-01-10

Android專案開發過程中經常使用到SQLite資料對資料進行儲存，每個app都會有各自的資料DB，以及各種表項。這就意味著每次進行app開發都要編寫資料庫以及表項的建立程式碼，而這些建庫建表程式碼量往往不少，但是大多雷同，只是具體資料不一樣。僅僅拷貝後，替換都覺得麻煩。
為何不將建庫建表封裝起來呢？下次建庫或者建表時只用配置對應的資料庫名，表名以及表屬性欄位即可。

1，建庫建表
簡單來說SQLite建表就是利用SQLiteDatabase獲取DBOpenHelper 來執行相應的建表SQL語句即可。SQLiteDatabase物件容易獲取，建庫只用一條拼接後的SQL建庫一句即可，而一個庫中可以存在多張表，每張表的建表語句有些微的不同（應為表字段有差異），故建表語句數對應了需要建立的表數。下面在程式碼中體現與說明建庫建表過程。

package com.ws.coyc.wsnote.SQLiteHelper;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
import com.ws.coyc.wsnote.SQLiteHelper.Utils.l;
import
 
 java.io.File;
import java.io.IOException;
import java.util.ArrayList;

/**
 * Created by coyc on 16-8-23.
 * before use the SDK you should do SQLiteManager.init();
 * then you can create table by SQLiteManager.crateTable();
 */

public class SQLiteManager {


    /*
    member
     */
    // SQLite
    public
 
 SQLiteDatabase db;//資料庫操作物件
    private Context context; //上下文
    private DBOpenHelper dbOpenHelper;//建表所需的幫助類（不懂的另外百度）
    private 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) {
            int size = tables.size();//獲取當前需要建表的數量
            for(int i = 0;i<size;i++)//拼接建表SQL語句
            {
                String sql = getTableCreateSQLString(tables.get(i));
                _db.execSQL(sql);//執行建庫建表語句
            }
        }

        @Override
        public void onUpgrade(SQLiteDatabase _db, int _oldVersion,int _newVersion) {
            int size = tables.size();//同建立表機制，拼接跟新表SQL語句
            for(int i = 0;i<size;i++)
            {
                _db.execSQL("DROP TABLE IF EXISTS " + getTableCreateSQLString(tables.get(i)));
            }
            onCreate(_db);
        }// end for private static class DBOpenHelper extends SQLiteOpenHelper
    }

    // DB_name
    private String DB_NAME;

    // DB_version
    private int DB_VERSION = 1;

    //ArrayList <Table>
    private ArrayList<Table> tables = new ArrayList<>();//該庫中表物件列表

    /*
    fun
     */
    //constrat
    public SQLiteManager()
    {

    }

    //init 初始化建庫工作，傳入庫名
    public void init(Context context,String DB_name)
    {
        tables.clear();
        this.context = context;
        this.DB_NAME = DB_name;
    }

    private static SQLiteManager instance = null;

    public static SQLiteManager getInstance()//單例模式 方便外部呼叫
    {
        if(instance == null)
        {
            synchronized (SQLiteManager.class)
            {
                if(instance == null)
                {
                    instance = new SQLiteManager();
                }
            }
        }
        return instance;
    }


    //open 做資料庫操作之前都要呼叫open方法
    public void open() {

        dbOpenHelper = new DBOpenHelper(context, DB_NAME, null, DB_VERSION);
        try {
            db = dbOpenHelper.getWritableDatabase();
        } catch (SQLiteException ex) {
            ex.printStackTrace();
            exceptionHandler();
        }
        db.beginTransaction();
    }
    /**
     * 資料庫檔案損壞刪除異常處理
     * 
     */
    private void exceptionHandler() {
        if(db == null)
        {
            return;
        }
        File file = new File(db.getPath());
        if (!file.exists()) {
            try {
                if (file.createNewFile()) {
                    open();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //close 長時間不適用資料庫可執行close方法關閉資料庫
    public void close() {

        db.setTransactionSuccessful();
        db.endTransaction();
        if (db != null) {
            db.close();
            db = null;

        }
    }




    //create table 登錄檔 外界任何想在該庫下建立的表都必須註冊 註冊後tables列表會增加，這回作用到建表時SQL語句的生成
    public void registerTable(String table_name, ArrayList<Item> items)
    {
        Table table = new Table(table_name,"_id",items);

        tables.add(table);
    }
    //兩種不同的註冊方式 建議使用第二種方式進行註冊，因為第二種方式的表物件是外界傳入的，外界可以利用該物件進行更多的操作。詳情見下
    public void registerTable(Table table)
    {
        tables.add(table);
    }

    // get table create sql by items 建表語句拼接程式碼 遍歷tables列表，由於每個表又可以有多個欄位，故欄位型別不同又有對應的語句區別。
    private static String getTableCreateSQLString(Table table) {
        String sql = "create table "+table.table_name;//表名 下面依次是“主鍵”+“item1”+“item2”+.....+"item n" 拼接程式碼原理不熟的百度能搜出一大把，這裡只是稍微換了一種形式的寫法。

        sql += "("+table.keyItem+" integer primary key autoincrement";

        int size = table.items.size();

        for(int i = 0;i<size;i++)
        {
            sql += ",";
            if(table.items.get(i).type.equals(Item.item_type_integer))
            {
                sql += table.items.get(i).text+" integer not null";
            }else if(table.items.get(i).type.equals(Item.item_type_text))
            {
                sql += table.items.get(i).text+" text not null";
            }else if(table.items.get(i).type.equals(Item.item_type_boolen))
            {
                sql += table.items.get(i).text+" bool not null";
            }else if(table.items.get(i).type.equals(Item.item_type_long))
            {
                sql += table.items.get(i).text+" long not null";
            }
            // TODO: 16-8-23 add other data type 可能有別的資料屬性 要看SQLite還支援那些資料的儲存



        }
        sql += ");";
        Log.i("coyc","getTableCreateSQLString"+sql);
        return sql;
    }


    //如果是使用第一種方式註冊的 這裡提供一個介面獲取本類中tables列表中的某個表，傳入所需要獲取的表名即可（不是重點）
    public Table getTableByName(String tableName)
    {
        int size = tables.size();
        if(size == 0)
        {
            return null;
        }else
        {
            for(int i = 0;i<size;i++)
            {
                if(tableName.equalsIgnoreCase(tables.get(i).table_name))
                {
                    return tables.get(i);
                }
            }
        }
        return null;
    }

}

上面程式碼中引用了Table物件以及Item物件，Table物件好理解就是表物件。而Item對是各個表中每個欄位對應的物件。比如說商品表中可能含有“商品名”，這個商品名就是一個item物件。程式碼如下：

package com.ws.coyc.wsnote.SQLiteHelper;

import android.content.ContentValues;
import android.database.Cursor;
import android.support.annotation.NonNull;

import java.util.ArrayList;

/**
 * Created by coyc on 16-8-23.
 */

public class Table {
    /*
    member
     */
    //table name
    public String table_name;

    //table strings 表屬性列表
    public ArrayList<Item> items = new ArrayList<>();

    //key 自定主鍵項 一般預設為“_id”
    public String keyItem;

    //db

    public Table()
    {

    }

    public Table(String table_name,String keyItem)
    {
        this.keyItem = keyItem;
        this.table_name = table_name;
    }

    public Table(String table_name,String keyItem,ArrayList<Item> items)
    {
        this.keyItem = keyItem;
        this.table_name = table_name;
        this.items = items;
    }

    /*
    fun 查改增刪 方法的具體實現  這裡強烈建議具體方法由子類區實現，因為不同的表所對應的查改增刪方法都有不同。
    以後我們在使用的時候，我們可以讓自己的表物件繼承與Table物件，這樣專案中就很好區分各個表物件，也可以很好的管理專案中的表。
     */

    //create table

    //delete table

    //inserte item


    }
 }

item類

package com.ws.coyc.wsnote.SQLiteHelper;

/**
 * Created by coyc on 16-8-23.
 */

public class Item {

//屬性儲存型別 比如說商品名這個屬性儲存格式可能是文字，而商品價格屬性儲存型別就可能是integer型，這個根據具體情況合理初始化item物件即可
    public static final String item_type_integer = "item_type_integer";
    public static final String item_type_text = "item_type_text";
    public static final String item_type_long = "item_type_long";
    public static final String item_type_boolen = "item_type_boolen";

    public String text = "";//用於SQL拼接的關鍵字（要是無法理解可見接下來的例子）
    public String type = "";//該item的型別

    public Item(String text,String type)
    {
        this.text = text;
        this.type = type;
    }
    public Item()
    {
    }
}

上面就完成了對SQLite建庫建表的封裝過程，接下來只需在專案中進行簡單的配置，即可使用。做到程式碼的可移植性，以及可複用性。
目前來說程式碼結構如下：（utils包是工具包，不用管）
這裡寫圖片描述
2，專案引用
接下來看具體的操作程式碼：
使用流程如下：
1 ，初始化SQLiteManager
2，編寫自己的Table類繼承與Table，並建立。
3，在SQLiteManager中註冊
4，執行建立表語句（SQLite在首次使用是進行建立）
5，open資料庫，進行操作

    public BillTable billTable;//賬單表（這裡什麼表都行，看自己需求）
    public PersonTable personTable;//使用者表
    private void initSQL(Context context) {
        //init table
        billTable = new BillTable();
        personTable = new PersonTable();
        //init SQL
        SQLiteManager.getInstance().init(context,DB_NAME);

        SQLiteManager.getInstance().registerTable(billTable);
        SQLiteManager.getInstance().registerTable(personTable);
//在執行open方法時 如果是第一次呼叫 系統則會執行建表語句
        SQLiteManager.getInstance().open();//when the app close you should to close the SQL
    }
//該方法呼叫完成後建表工作就都完成了

我們對比一下如果不使用封裝的方法則每次專案中需要SQLite時可能效果是這樣的（這裡只是部分截圖，程式碼太多根本截不下來）：
這裡寫圖片描述
如果使用面向物件的方法的效果就會這樣的：
這裡寫圖片描述
是不是簡單了很多！
當然我們還有寫程式碼未展示出來，接下來以personTable為例展示如何繼承Table類，重寫關鍵方法，以及Item屬性的構建。

package com.ws.coyc.wsnote.Data.Table;

import com.ws.coyc.wsnote.SQLiteHelper.Item;
import com.ws.coyc.wsnote.SQLiteHelper.Table;

/**
 * Created by coyc on 16-9-9.
 */

public class PersonTable extends Table{

    public static final String name = "name";
    public static final String address1 = "address1";
    public static final String address2 = "address2";
    public static final String phone = "phone";
    public static final String src_photo = "src_photo";

    public PersonTable()
    {
        init();
    }
    public void init()
    {
        table_name = "person";
        keyItem = "_id";//預設給予主鍵為“_id”
    //構建屬性
        items.add(new Item(name  , Item.item_type_text));
        items.add(new Item(address1  , Item.item_type_text));
        items.add(new Item(address2  , Item.item_type_text));
        items.add(new Item(phone  , Item.item_type_text));
        items.add(new Item(src_photo  , Item.item_type_text));
    }
}
    public long insert(ContentValues cv)
    {
        return SQLiteManager.getInstance().db.insert(table_name,null,cv);
    }

    //delete item
    public long deleteAllItem()
    {
        return SQLiteManager.getInstance().db.delete(table_name,null,null);
    }
    //
    public long deleteOneByItem(String item,String content)
    {
        String[] args = {String.valueOf(content)};
        return SQLiteManager.getInstance().db.delete(table_name,item+" =?",args);
    }

    //update item
    public long updateOneByItem(String item,String content,ContentValues contentData)
    {
        String[] args = {String.valueOf(content)};
        return SQLiteManager.getInstance().db.update(table_name,contentData, item+" =? ",args);
    }
//上述的deleteAllItem方法可以將其放入到父類Table中去，因為這個方法可以共用，甚至insert方法也可以，這裡我就不寫回去了。但是下面這個getContentValues方法是每個類獨有的，必須重寫。因為每個表的屬性都不同。
public ContentValues getContentValues() {
        ContentValues contentValues = new ContentValues();
        contentValues.put("name","coyc");
        contentValues.put("address1","長沙");
        contentValues.put("phone","10086");
        contentValues.put("src_photo","");
        return contentValues;
    }

寫到這裡基本上就算完成了 ，想要操作某個表時，直接使用該表物件的特定方法即可。eg：
personTable.insert(personTable.getContentValues);

3，總結：程式設計師都是很懶的，所以他們想到了封裝。寫一次程式碼以後都用現成的，想想都很好。本文中是對SQLite的建庫建表，以及對錶項的操作都使用面向物件的思想進行封裝，極大的方便以後的使用，並且讓程式碼的邏輯性更好，可讀性更高。

相關推薦

Android SQLite 建表 面向物件程式設計 完美封裝 一勞永逸

Android專案開發過程中經常使用到SQLite資料對資料進行儲存，每個app都會有各自的資料DB，以及各種表項。這就意味著每次進行app開發都要編寫資料庫以及表項的建立程式碼，而這些建庫建表程式碼量往往不少，但是大多雷同，只是具體資料不一樣。僅僅拷貝後，替換

C語言面向物件程式設計：封裝與繼承（1）

最近在用 C 做專案，之前用慣了 C++ ，轉回頭來用C 還真有點不適應。 C++ 語言中自帶面向物件支援，如封裝、繼承、多型等面向物件的基本特徵。 C 原本是面向過程的語言，自身沒有內建這些特性，但我們還是可以利用 C 語言本身已有的特性來實現面向物件的一些基本特徵。接下來我們就一一來細說封裝、繼

C語言面向物件程式設計 一 封裝與繼承

                    最近在用 C 做專案，之前用慣了 C++ ，轉回頭來用C 還真有點不適應。 C++ 語言中自帶面向物件支援，如封裝、繼承、多型等面向物件的基本特徵。 C 原本是面向過程的語言，自身沒有內建這些特性，但我們還是可以利用 C 語言本身已有的特性來實現面向物件的一些基本特徵。

面向物件程式設計：封裝，繼承，多型

面向物件的三大特徵：封裝，繼承，多型 封裝 封裝概述 類 方法 程式碼塊 封裝的好處 繼承 繼承概述 關鍵字this與super final關鍵字 繼承的優點與弊端

python面向物件程式設計之封裝-繫結方法與非繫結方法

1.繫結方法    特性：繫結給誰就應該由誰來呼叫，誰來呼叫就會將誰當做第一個引數自動傳入    （精髓在於自動傳入）    繫結方法分為兩類：        1.繫結給物件方法            在類內部定義的函式（沒有被任何封裝器修飾的），預設就是繫結給物件用的   

理解繼承（一）：JS面向物件程式設計（封裝）

依然是向阮前輩（阮一峰）學習的部落格原文 學了這一階段和峰大神的幾篇文章，打算下一階段滾回去把指標好好學一下 JS 中，萬物皆物件，但是它又不是一門真正的面向物件程式語言。 那如果我們要把“屬性(prototype)”和方法(“method”)封裝成一個物

C語言面向物件程式設計：單鏈表實現（5）

 前面我們介紹瞭如何在 C 語言中引入面嚮物件語言的一些特性來進行面向物件程式設計，從本篇開始，我們使用前面提到的技巧，陸續實現幾個例子，最後呢，會提供一個基本的 http server 實現（使用 libevent ）。在這篇文章裡，我們實現一個通用的資料結構：單鏈表。  

Day6-Python3基礎-面向物件程式設計

面向過程 VS 面向物件 程式設計正規化 程式設計是 程式 員 用特定的語法+資料結構+演算法組成的程式碼來告訴計算機如何執行任務的過程 ， 一個程式是程式設計師為了得到一個任務結果而編寫的一組指令的集合，正所謂條條大路通羅馬，實現一個任務的方式有很多種不同的方式， 對這些不同的程式設計方式的特點進行歸納

【小家java】POP（面向過程程式設計）、OOP（面向物件程式設計）、AOP（面向切面程式設計）三種程式設計思想的區別和聯絡

相關閱讀 【小家java】java5新特性（簡述十大新特性） 重要一躍 【小家java】java6新特性（簡述十大新特性） 雞肋升級 【小家java】java7新特性（簡述八大新特性） 不溫不火 【小家java】java8新特性（簡述十大新特性） 飽受讚譽 【小家java】java9

JavaScript 面向物件程式設計實現

JavaScript 面向物件程式設計實現 本文主要講述js面向物件的實現方式（繼承） 面向物件本來就是把某些問題（邏輯），用物件的方式描述，使得業務邏輯能更加清晰，提高維護性，降低實現複雜度。 面向物件的三大特徵：封裝，多型，繼承。（JavaScript 是沒有多型的特性的

Spark學習筆記11面向物件程式設計

面向物件程式設計   11.1 object類 11.1.1定義一個簡單的類   11.1.2 field的getter與setter 定義類包含，定義類的field及方法。其格式如下 class ClassName{ // 其中類名首字母要大寫 private v

3.Java面向物件程式設計OOA/OOP/OOD/OOAD()/UML類圖、函數語言程式設計Scala(JVM)---類與物件、封裝繼承多型、構造方法、覆寫/重寫/override

一、緒論 1.面向物件程式設計正規化（C++、Java、Go）------能進行現實生活的抽象。             每個物件都是一個類。類中包含屬性與方法。 OOA：面向物件分析 OOP：面向物件程式設計

一文看懂Python的面向物件程式設計，這是真正的一篇非常棒的教程！

  之前在網路上看了很多關於面向物件的程式設計詳解，還是不夠過癮，所以決定自己動手寫一篇。 面向物件：Object Oriented Programming，簡稱OOP，即面向物件程式設計。           &nbs

《C++面向物件程式設計-基於Visual C++ 2010》讀書筆記

資料型別與基本運算 字串常量按字元書寫順序依次儲存在記憶體中，並在最後存放空字元’\0’表示字串常量的結束。ASCII字元在記憶體中佔1個位元組，而中文字元佔2個位元組 有名常量是指用關鍵字const修飾的變數。由於該變數只能讀取，而不能被修改，所以 也稱為常變數。有名

JAVA面向物件程式設計之購物車介面的設計與功能的實現

1、小組成員及分工 小組成員 負責工作 蘭澤祥 負責總體介面、Git程式碼庫 吳修恩 負責MVC模式、類名包名的規範化 2、Git 倉庫地址 倉庫地址：https://gitee

如何把js的程式碼寫的更加容易維護(一)--面向物件程式設計

總是頭疼javascript的程式碼寫起來不可維護，那麼看看下面的程式碼： 1 (function (w, $) { 2 var app = { 3 init: function () { 4 var me = this; 5 me.render(

原生js面向物件程式設計-選項卡(自動輪播)

<!DOCTYPE html> <html> <head lang="en"> <meta charset="UTF-8"> <title>原生js面向物件程式設計-選項卡(自動輪播)</title> <

javascript面向物件程式設計--惰性載入函式（瀏覽器相容性處理）

因為各大瀏覽器所使用的JS引擎不同，所以在實現某一個功能時都或多或少的存在差異，導致在寫程式碼時要針對每一個功能給出相容瀏覽器的不同實現方式，這樣在執行程式碼時就會造成效能的損耗。所以就出現了惰性載入函式的概念。原理就是：當前瀏覽器第一次支援以該方法實現某功能，那麼在這個頁面執行期間會一直都支援該方

javascript面向物件程式設計--繼承--多重繼承+摻元類（多親繼承）

繼承一般包括 單向繼承 和 多重繼承   多重繼承：一個子類繼承多個超類 function A(x){this.x=x;} A.prototype.getx=function(){return  this.x;} function B(y){this.y=y;}

javascript面向物件程式設計--設計超類和子類，設計元類

在javascript中，Object物件是通用類，其他所有內建物件和自定義構造物件都是專用類，即Object物件是超類，其他內建物件和自定義物件都是Object的子類，所有在javascript語言中，所有的物件都繼承Object定義的屬性和方法 Object.prototype.name='