Android应用开发技巧之更方便的使用Sqlite

做应用的大多离不开数据库的支持，但是就是这么常用的对象，你有没有想过让他更方便的使用呢？什么是更方便，我的定义就是不用在每次需要用它的时候对SQL语句做过多的关心，我们应该更多的关心每一个字段的含义；也就是我们应用开发更多的关心应该在业务上，而不是在SQL语句的拼接中。
因此本人要带领大家从0到1到开始一步步优化SQLite的使用。
整体思路如下：
首先，对于SQL语句，我们发现他是不是很有规律，因此在SQL的拼接上完全可以实现部分自动化；
其次，我们应该直接将数据库字段实体类和数据库的建表，查询等关联起来；这样，我们才能最大化的达到资源的复用。
因此我结合Java的相关知识设计如下：
首先，我们必须继承SQLiteOpenHelper来实现一个建库建表的基类；
代码如下：

/**
* @author 徐晔
* @note 数据库操作类
*/
@SuppressWarnings(“rawtypes”)
public class XYDBhelper extends SQLiteOpenHelper {

private List<Class<? extends XYCreatMethod>> clslist = new ArrayList<Class<? extends XYCreatMethod>>();
private XYversionchange xYversionchange;

public XYDBhelper(Context context, String name, CursorFactory factory,
        int version) {
    super(context, name, factory, version);
}

public void setXYversionchange(XYversionchange xYversionchange) {
    this.xYversionchange = xYversionchange;
}

/**
 * 添加想要建表的类
 * 
 * @param cMethord
 */
public void addCreatMethord(Class<? extends XYCreatMethod> cls) {
    if (cls != null) {
        clslist.add(cls);
    }
}

@Override
public void onCreate(SQLiteDatabase db) {
    // 利用反射机制来建立表格
    db.beginTransaction();
    try {
        for (Class<? extends XYCreatMethod> cls : clslist) {
            Constructor[] constructors = cls.getDeclaredConstructors();
            AccessibleObject.setAccessible(constructors, true);
            for (Constructor con : constructors) {
                if (con.isAccessible()) {
                    Object classObject = con.newInstance();
                    Method method = cls
                            .getMethod(XYCreatMethod.CREATTABLEMETHORD_NAME);
                    String creatsql = (String) method.invoke(classObject);
                    db.execSQL(creatsql);
                }
            }
        }
        db.setTransactionSuccessful();

    } catch (Exception e) {
        e.printStackTrace();
    }finally{
                db.endTransaction();
    }
}

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    if (xYversionchange != null) {
        xYversionchange.onUpgrade(db, oldVersion, newVersion);
    }

}

@Override
public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    if (xYversionchange != null) {
        xYversionchange.onDowngrade(db, oldVersion, newVersion);
    }

}

}
我将里面的建表语句利用反射机制实现，将建表语句的实现延迟实现，为我们下一步做一个准备。
再看看这里面牵扯到的两个类：
/**
*
* @author 徐晔 需要建表实现的接口
*/
abstract public class XYCreatMethod {
/* 获取建立表格的SQL语句 /
abstract public String getcreattablesql();

/** 建立表格方法名，利于DBhelper进行建立表格操作 */
public final static String CREATTABLEMETHORD_NAME = "getcreattablesql";

}
/**
*
* @author xuye
* @not 版本号变化时需要实现的接口方法
*/
public interface XYversionchange {
/* 版本升级时 /
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion);

/** 版本降级时 */
public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion);

}
这两个一个是建表语句需要继承的基类，一个是版本发生升级或者降级需要执行的方法。
在此我们可以直接将所有需要建立表格的语句继承XYCreatMethod类实现，这里就是一个灵活的地方，我们可以按照传统的实现方法，也可以自己在getcreattablesql()方法里面玩一些猫腻；
如果要将字段实体类和建表结合起来，那么可以利用注解的特点结合反射的特点来实现，我的实现如下：
首先自定义一个类的注解类：
@Retention(RetentionPolicy.RUNTIME)//注解会在class中存在，运行时可通过反射获取
@Target(ElementType.TYPE)//目标是接口、类、枚举、注解
@Documented//文档生成时，该注解将被包
public @interface XYTable {

/**表名字*/
public String tablename() default "className";
/** 唯一约束，指定某列和几列组合的数据不能重复 */
public String[]  unique() default "";
/**主键约束，指定某列的数据不能重复、唯*/
public String  primary_key() default "id";
/**主键的类型*/
public String primary_key_type() default "integer";
/**主键是否自增*/
public boolean is_auto_increase_primarykey() default false;
/**主键是否非空*/
public boolean primary_notnull() default true;

/**外键，指定该列记录属于主表中的一条记录，参照另一条数据 */
public String  foreign_key() default "";
/**检查，指定一个表达式，用于检验指定数据 */
public String  check() default "";

}
在定义一个字段的注解类：

@Retention(RetentionPolicy.RUNTIME)//注解会在class中存在，运行时可通过反射获取  
@Target(ElementType.FIELD)//目标是字段
@Documented//文档生成时，该注解将被包
public @interface XYTableField {
    /**是什么类型的字段 */
    public String  Type() default "varchar";
    /**非空约束 */
    public boolean  not_null() default false;
}

然后是将带有注解的字段表和字段和建表语句结合起来的方法：
/**
* @author 徐晔
* 利用反射机制进行建立表操作
*/
public class XYBaseCreatMethod extends XYCreatMethod {

private Class<?> cls;
public XYBaseCreatMethod(Class<?> cls){
    this.cls=cls;
}

@Override
public String getcreattablesql() {
    try {
        return getcreattablesql(cls);
    } catch (Exception e) {
        e.printStackTrace();
        return "";
    }
}

/**
 * 获取建表SQL
 * @param cls
 * @return
 * @throws NullPointerException
 */
public String getcreattablesql(Class<?> cls) throws NullPointerException{
    StringBuilder mBuilder = new StringBuilder();
    XYTable table = cls.getAnnotation(XYTable.class);
    if (table == null || table.tablename() == null) {
        throw new NullPointerException("没有添加应该有的数据库注释");
    }
    mBuilder.append("create table " + table.tablename());
    mBuilder.append("(" + table.primary_key() + " "
            + table.primary_key_type() + " primary key");
    if (table.is_auto_increase_primarykey()) {
        mBuilder.append(" autoincrement");
    }
    if(table.primary_notnull()){
        mBuilder.append(" not null");
    }
    mBuilder.append(",");
    for (Field field : cls.getFields()) {
        XYTableField mField = field.getAnnotation(XYTableField.class);
        if (mField == null || mField.Type() == null
                || mField.Type().length() == 0) {
            continue;
        }
        String name = field.getName();
        mBuilder.append(name);
        mBuilder.append(" " + mField.Type());
        if(mField.not_null()){
            mBuilder.append(" not null");
        }
        mBuilder.append(",");
    }
    if (table.unique() == null || table.unique().length == 0) {
        mBuilder.deleteCharAt(mBuilder.length() - 1);
    } else {
        mBuilder.append("unique(");
        for (String fie : table.unique()) {
            mBuilder.append(fie + ",");
        }
        mBuilder.deleteCharAt(mBuilder.length() - 1);
        mBuilder.append(")");
    }
    mBuilder.append(")");
    return mBuilder.toString();

}

}
下面举一个字段实体类的例子：

/**
 * @author 徐晔
 */
@XYTable(tablename = "DownloadHsitory", primary_key = "id", foreign_key = "", unique = { "url" }, is_auto_increase_primarykey = true, primary_notnull = true)
public class DownloadHsitory {
    /**
     * 下载地址
     * 
     * @note
     * */
    @XYTableField(Type = "varchar", not_null = true)
    public String url;
    /**
     * 下载文件存储的绝对路径
     * 
     * @note
     * */
    @XYTableField(Type = "varchar", not_null = true)
    public String savepath;
    /**
     * 已经下载的文件大小
     * 
     * @note
     * */
    @XYTableField(Type = "integer", not_null = true)
    public long downlength;
    /**
     * 整个文件的大小
     * 
     * @note
     * */
    @XYTableField(Type = "integer", not_null = true)
    public long totallength;
}

然后该实现查询的相关方法了；主要是根据字段类进行查询。
/**
* @author 徐晔
* @note 数据库操作方法的实现
*/
public class XYDBmanage {

public XYDBhelper dBhelper;
private SQLiteDatabase database;
private Context context;
private int version;
private String dbname;
private CursorFactory factory;

private static XYDBmanage xydBmanage = null;

public static XYDBmanage getInstance(Context context, String name,
        CursorFactory factory, int version) {
    if (xydBmanage == null) {
        synchronized (XYDBmanage.class) {
            if (xydBmanage == null) {
                xydBmanage = new XYDBmanage(context, name, factory, version);
            }
        }
    }
    return xydBmanage;
}

private XYDBmanage(Context context, String name, CursorFactory factory,
        int version) {
    this.context = context;
    this.version = version;
    this.dbname = name;
    this.factory = factory;
}

/**
 * 打开数据库
 */
private void openDB() {
    if (dBhelper == null) {
        dBhelper = new XYDBhelper(context, dbname, factory, version);
    }
    if (database == null) {
        database = dBhelper.getWritableDatabase();
    }
}

/**
 * 关闭数据库
 */
private void closeDB() {
    if (database.isOpen()) {
        database.close();
        database.releaseReference();
        database = null;
    }
}

/**
 * 根据Class获取表名字
 */
private String getTablename(Class<?> cls) {
    String tablename = "";
    XYTable mani = cls.getAnnotation(XYTable.class);
    if (mani == null) {
        return null;
    }
    tablename = mani.tablename();
    return tablename;
}

/**
 * 查询数据
 */
public synchronized List<?> getObjects(String columeName, String where,
        String order, Class<?> cls) throws Exception {
    String tablename = getTablename(cls);
    if (tablename == null || columeName == null) {
        return null;
    }
    List<Object> mList = new ArrayList<Object>();
    Object obj = null;
    StringBuilder mBuilder = new StringBuilder();
    mBuilder.append("select " + columeName + " from " + tablename);
    if (where != null) {
        mBuilder.append(" where " + where);
    }
    if (order != null) {
        mBuilder.append(" order by" + order);
    }
    openDB();
    Cursor mCursor = database.rawQuery(mBuilder.toString(), null);
    Field[] fields = cls.getFields();
    if (mCursor != null) {
        while (mCursor.moveToNext()) {
            obj = cls.newInstance();
            for (Field field : fields) {
                try {
                    setValue(obj, field, mCursor.getString(mCursor
                            .getColumnIndex(field.getName())));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            mList.add(obj);
        }
    }
    if (!mCursor.isClosed()) {
        mCursor.close();
    }
    closeDB();
    return mList;
}

/**
 * 插入数据库
 */
public synchronized void insert(List<?> liss, Class<?> cls)
        throws Exception {
    ContentValues values = null;
    String tablename = getTablename(cls);
    openDB();
    for (Object temp : liss) {
        Field[] fields = cls.getFields();
        values = new ContentValues();
        for (Field field : fields) {
            if (temp.getClass().getField(field.getName()).get(temp) != null) {
                values.put(field.getName(),
                        temp.getClass().getField(field.getName()).get(temp)
                                .toString());
            }
        }
        Log.v("values", values + "");
        database.insert(tablename, null, values);
    }
    closeDB();
}

/**
 * 使用事物插入数据库
 */
public synchronized void insertwithTransaction(List<?> liss, Class<?> cls)
        throws Exception {

    ContentValues values = null;
    String tablename = getTablename(cls);
    openDB();
    database.beginTransaction();
    for (Object temp : liss) {
        Field[] fields = cls.getFields();
        values = new ContentValues();
        for (Field field : fields) {
            if (temp.getClass().getField(field.getName()).get(temp) != null) {
                values.put(field.getName(),
                        temp.getClass().getField(field.getName()).get(temp)
                                .toString());
            }
        }
        Log.v("values", values + "");
        database.insert(tablename, null, values);
    }
    database.setTransactionSuccessful();
    database.endTransaction();
    closeDB();
}

/**
 * 更新数据库
 */
public synchronized void updateState(Object obj, String where, Class<?> cls)
        throws Exception {
    StringBuilder SQL = new StringBuilder(" update ");
    StringBuilder value = new StringBuilder();
    String tablename = getTablename(cls);

    SQL.append(tablename);
    SQL.append(" set ");
    // 获得obj的所有属性
    Field[] fields = obj.getClass().getFields();
    for (Field field : fields) {
        // 如果属性的值不为空则存入values
        if (!field.getName().equals(tablename)) {
            if (null != field.get(obj)) {
                value.append(field.getName() + " = '"
                        + String.valueOf(field.get(obj) + "' ,"));
            }
        }
    }
    if (value.length() <= 0) {
        return;
    }
    value.delete(value.length() - 1, value.length());
    SQL.append(value);
    if (where != null && where.length() > 0) {
        SQL.append(" where " + where);
    }
    openDB();
    Log.v("updateState SQL=>", SQL.toString());
    database.execSQL(SQL.toString());
    clone();
}

/**
 * 删除数据库中指定的记录
 * 
 * @param listObj
 * @throws Exception
 */
public synchronized void delete(String where, Class<?> cls)
        throws Exception {
    String tablename = getTablename(cls);
    String sql = "delete from " + tablename;
    if (where != null && !where.equals("")) {
        sql = sql + " where " + where;
    }
    Log.v("sql=>", sql);
    openDB();
    database.execSQL(sql);
    closeDB();
}

/**
 * 执行自己的sql
 */
public synchronized void execSQL(String SQL) {
    // 获取数据库操作
    openDB();
    database = dBhelper.getWritableDatabase();
    database.execSQL(SQL);
    Log.v("sql=>", SQL);
    closeDB();
}

/**
 * 给obj对象的field属性赋值
 * 
 * @param obj
 *            对象
 * @param field
 *            属性
 * @param value
 *            值
 */
public void setValue(Object obj, Field field, String value) {
    try {
        // 获得field属性的类型名
        String class_type = field.getType().getName();
        // 将value转换成和属性类型一样的数据类型
        if (class_type.equals(String.class.getName())) {
            field.set(obj, value);
        } else if (class_type.equals("int")
                || class_type.equals(Integer.class.getName())) {
            field.set(obj, Integer.parseInt(value));
        } else if (class_type.equals("double")
                || class_type.equals(Double.class.getName())) {
            field.set(obj, Double.parseDouble(value));
        } else if (class_type.equals("boolean")
                || class_type.equals(Boolean.class.getName())) {
            field.set(obj, Boolean.parseBoolean(value));
        } else if (class_type.equals("float")
                || class_type.equals(Float.class.getName())) {
            field.set(obj, Float.parseFloat(value));
        } else if (class_type.equals("short")
                || class_type.equals(Short.class.getName())) {
            field.set(obj, Short.parseShort(value));
        } else if (class_type.equals("long")
                || class_type.equals(Long.class.getName())) {
            field.set(obj, Integer.parseInt(value));
        } else if (class_type.equals("char")
                || class_type.equals(Character.class.getName())) {
            field.set(obj, value);
        } else if (class_type.equals("byte")
                || class_type.equals(Byte.class.getName())) {
            field.set(obj, Byte.parseByte(value));
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

}

，好了，大家按照这个思路完这些代码，后面使用数据库就会变得很简单。并且这一套实现思路不仅仅是只可以用反射实现，对于复杂的业务也支持自己写SQL语句来实现。不过要大家再次完美一下，实现相应的接口而已。抛砖引玉，希望大家指导。