数据库封装之app离线缓存

数据库封装  这个网上有很多，这里就借用一下学习（非常感谢）

public class SQLiteManager {

    // 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);
        }
    }

    // DB_name
    private String DB_NAME;
    // DB_version
    private int DB_VERSION = 1;
    //ArrayList <Table>
    private ArrayList<Table> tables = new ArrayList<>();//该库中表对象列表


    //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;
    }
}

/**
 * Created by changquan on 2017/9/15.
 * 基表：所有的表都要继承此类
 */

public class Table {

    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;
    }
}

/**
 * Created by changquan on 2017/9/15.
 * 具体表的参数
 */

public class 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 = "";
    public String type = "";
    public Item(String text,String type)
    {
        this.text = text;
        this.type = type;
    }
    public Item()
    {
    }
}

上面就是数据库的一个封装，下面就学习使用该封装来实现一下简单的app离线缓存

/**
 * Created by changquan on 2017/9/15.
 * app离线缓存表
 */

public class UnLineCacheTable extends Table
{

    public static final String URL = "url";
    public static final String DATA = "json";
    public static final String TIME = "time";

    public UnLineCacheTable()
    {
        init();
    }

    public void init()
    {
        table_name = "unlinecache";
        keyItem = "_id";//默认给予主键为“_id”

        //构建属性
        items.add(new Item(URL, Item.item_type_text));
        items.add(new Item(DATA, Item.item_type_text));
        items.add(new Item(TIME, Item.item_type_text));
    }

    public long insert(ContentValues cv) {
        return SQLiteManager.getInstance().db.insert(table_name, null, cv);
    }


    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);
    }


    public long updateOneByItem(String item, String content, ContentValues contentData) {
        String[] args = {String.valueOf(content)};
        return SQLiteManager.getInstance().db.update(table_name, contentData, item + " =? ", args);
    }


    public String queryData(){
        Cursor query = SQLiteManager.getInstance().db.query(table_name, new String[]{"url"}, "url=?", new String[]{"http//....."}, null, null, null);
        if (query.moveToNext())
        {
            String date = query.getString(query.getColumnIndex("date"));
            return date;
        }
        return "";
    }



    // 对参数进行赋值处理
    public ContentValues getContentValues()
    {
        ContentValues contentValues = new ContentValues();
        contentValues.put("url", "....");
        contentValues.put("json", "....");
        contentValues.put("time", "....");
        return contentValues;
    }

}

用来学习还是很好的