数据库封装

首先要感谢下面的这篇文章

http://blog.csdn.net/feiduclear_up/article/details/50557590

接下来贴上自己写好的代码

1.MyApplication.java

public class MyApplication extends Application {
private DBOperator mDBOperator;
private static MyApplication mApp;
@Override
public void onCreate() {
super.onCreate();
mApp = this;
}
/**
* 获取Application实例
* @return
*/
public static MyApplication getSelf(){
return mApp;
}
/**
* 创建线程安全的数据库实例
* @return
*/
public synchronized DBOperator getDBOperator(){
if(mDBOperator == null){
mDBOperator = DBOperator.getInstance(this);
}
return mDBOperator;
}
}

两个实体类如下

public class Student {
private String name;
private String sex;
private int age;

public Student(){

}
public Student(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}

@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}

public String getName() {
return name;
}
//注意：set和get方法必须提供，因为DBOperator的方法里面会通过反射获取
public void setName(String name) {
this.name = name;
}

public String getSex() {
return sex;
}

public void setSex(String sex) {
this.sex = sex;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}

public class Teacher {
private String name;
private int age;

public Teacher(){

}
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}

@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//注意：set和get方法必须提供，因为DBOperator的方法里面会通过反射获取
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}

DBUtil .java 数据库工具类

public class DBUtil {
/**
* 获得表名
* @param clazz 实体类
* @return 表名
*/
public static String getTableName(Class<?> clazz){
return clazz.getSimpleName().toLowerCase();
}

/**
* 获取表字段类型
* @param fileType 字段类型
* @return 数据库表字段类型
*/
public static String getColumnType(String fileType){
String value = null;
if (fileType.contains("String")) {
value = " text";//注意：前面有个空格，目的是为了拼接
} else if (fileType.contains("int")) {
value = " integer";
} else if (fileType.contains("boolean")) {
value = " boolean ";
} else if (fileType.contains("float")) {
value = " float";
} else if (fileType.contains("double")) {
value = " double";
} else if (fileType.contains("char")) {
value = " varchar";
} else if (fileType.contains("long")) {
value = " long";
}
return value;
}

/**
* 首字母大写
* @param string
* @return
*/
public static String capitalize(String string) {
if (!TextUtils.isEmpty(string)) {
return string.substring(0, 1).toUpperCase(Locale.US) + string.substring(1);
}
return string == null ? null : "";
}
}

DBHelper .java 创建数据库表

public class DBHelper extends SQLiteOpenHelper {
private static final String TAG = "DBHelper";
private static final String DB_NAME = "person.db";//数据库名称
private static final int DB_VERSION = 1;//数据库版本，从1开始
public DBHelper(Context context) {
super(context,DB_NAME,null,DB_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {//数据库第一次创建执行，只执行一次，以后不再执行
Log.d(TAG, "onCreate: ");
db.execSQL(getCreateTableSql(Student.class));
db.execSQL(getCreateTableSql(Teacher.class));
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {//只有当数据库版本号发生变化的时候才会执行
}

/**
* 获取创建表的语句
* @param clazz
* @return
*/
private String getCreateTableSql(Class<?> clazz){
StringBuilder sb = new StringBuilder();
String tableName = DBUtil.getTableName(clazz);
sb.append("create table "+tableName+" (ID INTEGER PRIMARY KEY AUTOINCREMENT,");
Field[] fields = clazz.getDeclaredFields();//通过反射获取所有字段
for (Field fd:fields){
String fieldName = fd.getName();//字段名
String fieldType = fd.getType().getName();//字段类型名
//不需要字段中的id，因为数据库表有自增id
if(fieldName.equalsIgnoreCase("id")||fieldName.equalsIgnoreCase("_id")){
continue;
}else{//拼接字段名和类型，例如 age int,name text,
sb.append(fieldName).append(DBUtil.getColumnType(fieldType)).append(",");
}
}
int length = sb.length();
sb.replace(length-1,length,")");//删除最后一个，age int,name text
Log.d(TAG, "getCreateTableSql: "+sb.toString());
return sb.toString();
}
}

DBOperator .java 对数据库进行各种操作

public class DBOperator {

private static final String TAG = "DBOperator";
private static Context mContext;
private  SQLiteDatabase mDatabase;

private DBOperator() {
DBHelper dbHelper = new DBHelper(mContext);
mDatabase = dbHelper.getReadableDatabase();//获取数据库对象
}
//静态内部类实现单例
public static DBOperator getInstance(Context context) {
mContext = context;
return DBOperatorHolder.mOperator;
}
//静态内部类，创建单例对象
public static class DBOperatorHolder {
private static final DBOperator mOperator = new DBOperator();
}

/**
* 关闭数据库
*/
public void closeDatabase(){
mDatabase.close();
mDatabase = null;
}

/**
* 删除数据库
* @param dataBaseName 数据库名称
*/
public void deleteDatabase(String dataBaseName){
mContext.deleteDatabase(dataBaseName);
}

/**
* 删除表
* @param clazz 表对应的实体类
*/
public void deleteTable(Class<?> clazz){
mDatabase.execSQL("DROP TABLE IF EXISTS "+ clazz.getSimpleName());
}

/**
* 向指定的表中插入数据
* @param object 实体
* @param tableName 表名
* @return 插入行所在的id，如果返回-1，说明发生了错误
*/
public long insert(Object object, String tableName) {
ContentValues values = new ContentValues();
Cursor cursor = mDatabase.rawQuery("SELECT * FROM " + tableName, null);
for (int i = 0; i < cursor.getColumnCount(); i++) {
String name = cursor.getColumnName(i);//表中字段的名称
try {
//去除从表中获取的id字段，因为实体类中没有此字段
if (!"id".equalsIgnoreCase(name) && !"_id".equalsIgnoreCase(name)) {
Field field = object.getClass().getDeclaredField(name);//根据字段名称获取代表的Field对象
field.setAccessible(true);//让私有变量也可以访问
//当所有字段为String类型时可以用下面两行代码这种方式插入
//                    String value = (String) field.get(object);
//                    values.put(name,value);
putValues(values, field, object);//插入数据
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 第一个参数 表名
* 第二个参数 nullColumnHack （作用）当values参数为空或者里面没有内容的时候，insert是会失败的(底层数据库不允许插入一个空行)，
* 为了防止这种情况，要在这里指定一个列名，到时候如果发现将要插入的行为空行时，
* 就会将你指定的这个列名的值设为null，然后再向数据库中插入。
* 源码如下
*   int size = (initialValues != null && initialValues.size() > 0)
? initialValues.size() : 0;
if (size > 0) {
bindArgs = new Object[size];
int i = 0;
for (String colName : initialValues.keySet()) {
sql.append((i > 0) ? "," : "");
sql.append(colName);
bindArgs[i++] = initialValues.get(colName);
}
sql.append(')');
sql.append(" VALUES (");
for (i = 0; i < size; i++) {
sql.append((i > 0) ? ",?" : "?");
}
} else {
sql.append(nullColumnHack + ") VALUES (NULL");
}
*/
return mDatabase.insert(tableName, null, values);
}

/**
* 插入数据
* @param values 内容
* @param fd 字段对象
* @param obj 实体类
*/
private void putValues(ContentValues values, Field fd, Object obj) {
Class<?> clazz = values.getClass();
try {
Object[] parameters = new Object[]{fd.getName(), fd.get(obj)};//创建包含字段名称和值的数组
Class<?>[] parameterTypes = getParameterTypes(fd, fd.get(obj), parameters);
//根据方法名称和方法参数类型获得方法
Method method = clazz.getDeclaredMethod("put", parameterTypes);
method.setAccessible(true);
//调用方法，values调用方法的对象，parameters方法的参数
method.invoke(values, parameters);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}

/**
* 获取参数类型
* @param field 字段
* @param fieldValue 字段值，
* @param parameters 保存字段名和字段值的数组
* @return 参数类型
*/
private Class<?>[] getParameterTypes(Field field, Object fieldValue, Object[] parameters) {
Class<?>[] parameterTypes;
if (isCharType(field)) {//如果是字符类型,第二个参数当String处理
parameters[1] = String.valueOf(fieldValue);
parameterTypes = new Class[]{String.class, String.class};
} else {
//如果字段是基本数据类型，比如int,long,float，第二个参数为对应的class对象
if (field.getType().isPrimitive()) {
parameterTypes = new Class[]{String.class, getObjectType(field.getType())};
//如果是Date类型，第二个参数为long类型
} else if ("java.util.Date".equals(field.getType().getName())) {
parameterTypes = new Class[]{String.class, Long.class};
} else {
parameterTypes = new Class[]{String.class, field.getType()};
}
}
return parameterTypes;
}

/**
* 判断字段类型是否是字符
* @param field 字段
* @return true 是字符
*/
private boolean isCharType(Field field) {
//获得字段类型名称
String type = field.getType().getName();
return type.equals("char") || type.endsWith("Character");
}

/**
* 根据字段类型获取对象
* @param primitiveType
* @return
*/
private Class<?> getObjectType(Class<?> primitiveType) {
if (primitiveType != null) {
if (primitiveType.isPrimitive()) {
String basicTypeName = primitiveType.getName();
if ("int".equals(basicTypeName)) {
return Integer.class;
} else if ("short".equals(basicTypeName)) {
return Short.class;
} else if ("long".equals(basicTypeName)) {
return Long.class;
} else if ("float".equals(basicTypeName)) {
return Float.class;
} else if ("double".equals(basicTypeName)) {
return Double.class;
} else if ("boolean".equals(basicTypeName)) {
return Boolean.class;
} else if ("char".equals(basicTypeName)) {
return Character.class;
}
}
}
return null;
}

/**
* 查询所有数据
* @param clazz 实体类对象
* @param <T> 实体类
* @return 数据集合
*/
public <T> List<T> findAll(Class<T> clazz) {
//参数：表名，
//columns，需要查询那些列，传入null会查询所有列的数据
//select 条件语句
//selectionargs 条件参数
//groupby 分组
//having
//orderby
Cursor cursor = mDatabase.query(clazz.getSimpleName(), null, null, null, null, null, null);
return getEntity(cursor, clazz);
}

/**
* 根据参数获取结果
* @param clazz 实体类对象
* @param select 条件语句 id = ?
* @param selectArgs 条件参数 new String[]{"1"}
* @param <T> 实体类
* @return
*/
public <T> List<T> findByArgs(Class<T> clazz,String select,String[] selectArgs){
Cursor cursor = mDatabase.query(clazz.getSimpleName(), null, select, selectArgs, null, null, null);
return getEntity(cursor,clazz);
}

public <T> T findById(Class<T> clazz,int id){
Cursor cursor = mDatabase.query(clazz.getSimpleName(), null, "id=" + id, null, null, null, null);
List<T> list = getEntity(cursor, clazz);
android.util.Log.d(TAG, "findById: "+list);
return list.get(0);
}

public int deleteById(Class<?> clazz,int id){
return mDatabase.delete(clazz.getSimpleName(),"id="+id,null);
}
public int deleteByArgs(Class<?> clazz,String select,String[] args){
return mDatabase.delete(clazz.getSimpleName(),select,args);
}

public int deleteAll(Class<?> clazz){
return mDatabase.delete(clazz.getSimpleName(),null,null);
}
public void updateById(Class<?> clazz,ContentValues values,int id){
mDatabase.update(clazz.getSimpleName(),values,"id="+id,null);
}
public <T> List<T> getEntity(Cursor cursor, Class<T> clazz) {
List<T> list = new ArrayList<>();
try {
if (cursor != null && cursor.moveToFirst()) {
do {
Field[] fields = clazz.getDeclaredFields();
T moduleClass = clazz.newInstance();
for (Field field : fields) {
Class<?> cursorClass = cursor.getClass();
String columnMethodName = getColumnMethodName(field.getType());
Method cursorClassMethod = cursorClass.getMethod(columnMethodName, int.class);
Object value = cursorClassMethod.invoke(cursor, cursor.getColumnIndex(field.getName()));
if (field.getType() == boolean.class || field.getType() == Boolean.class) {
if ("0".equals(String.valueOf(value))) {
value = false;
} else if ("1".equals(String.valueOf(value))) {
value = true;
}
} else if (field.getType() == char.class || field.getType() == Character.class) {
value = ((String) value).charAt(0);
} else if (field.getType() == Date.class) {
long date = (Long) value;
if (date <= 0) {
value = null;
} else {
value = new Date(date);
}
}
String methodName = makeSetterMethodName(field);
Method method = clazz.getDeclaredMethod(methodName, field.getType());
method.invoke(moduleClass, value);
}
list.add(moduleClass);
} while (cursor.moveToNext());

}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (cursor != null) {
cursor.close();
}
}
return list;
}

private String getColumnMethodName(Class<?> fieldType) {
String typeName;
if (fieldType.isPrimitive()) {//如果此类代表的是基本数据类型
typeName = DBUtil.capitalize(fieldType.getName());
} else {
typeName = fieldType.getSimpleName();
}
String methodName = "get" + typeName;
if ("getBoolean".equals(methodName)) {
methodName = "getInt";
} else if ("getChar".equals(methodName) || "getCharacter".equals(methodName)) {
methodName = "getString";
} else if ("getDate".equals(methodName)) {
methodName = "getLong";
} else if ("getInteger".equals(methodName)) {
methodName = "getInt";
}
return methodName;
}

private String makeSetterMethodName(Field field) {
String setterMethodName;
String setterMethodPrefix = "set";
if (isPrimitiveBooleanType(field) && field.getName().matches("^is[A-Z]{1}.*$")) {
setterMethodName = setterMethodPrefix + field.getName().substring(2);
} else if (field.getName().matches("^[a-z]{1}[A-Z]{1}.*")) {
setterMethodName = setterMethodPrefix + field.getName();
} else {
setterMethodName = setterMethodPrefix + DBUtil.capitalize(field.getName());
}
return setterMethodName;
}

private boolean isPrimitiveBooleanType(Field field) {
Class<?> fieldType = field.getType();
if ("boolean".equals(fieldType.getName())) {
return true;
}
return false;
}
}