Android对SQLite数据库进行封装使用反射来进行表的增删改查

骑猪看日落 2022-06-03 07:43 227阅读 0赞

**一、介绍**  
1.首先该操作类由三部分组成：DBOperHelper、AppDao、DBProvider

DBOperHelper：用来管理表的创建和版本升级 
    
    AppDao：数据库的操作类，该方法进行数据库的增、删、改、查
    
    DBProvider：数据库内容变化监听器

2、使用  
比如说我们现在需要建个Student表  
(1).创建Student的bean对象

package lc.com.car.bean;
    
    import java.io.Serializable;
    
    /** * @author lingfeng 2017/12/22 11:39 */
    
    public class StudentBean implements Serializable { 
        private String name;
        private String id;
        private int age;
    
        public Student(String name,String id,String age){
            this.name = name;
            this.id = id;
            this.age=age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

(2).在DBOperHelper下的onCreate()中创建Student 表

@Override
        public void onCreate(SQLiteDatabase db) {
    
            // Student表
            db.execSQL("CREATE TABLE " +"StudentBeanTable " +"(_ID INTEGER primary key autoincrement,name varchar(40),id varchar(40),age varchar(10))"); }

**注意：这里表名必须遵守一定规范 例如：类名为StudentBean时 StudentBean在数据库中的表名必须是 StudentBeanTable（包括大小写）**

(3)调用

/** 插入数据 */
    
    //StudentBean表下插入两条数据
    List<StudentBean> list = new ArrayList<>();
    list.add(new StudentBean("张三","123","18"));
    list.add(new StudentBean("李四","456","19"));
    AppDao.getInstance().insertAll(list);
    
    /** 查询 */
    //查询StudentBean表下的所有数据
     List<StudentBean> list = AppDao.getInstance().findAll(StudentBean.class);
     //查询StudentBean表下年龄为18的所有数据
     List<StudentBean> list = AppDao.getInstance().findAll(StudentBean.class,"age=?",new String);
    
    /** 修改数据 */
    
    //将StudentBean表下的age = 18改为20
    ContentValues value = new ContentValues();
    value.put("age", "20");
    AppDao.getInstance().update(StudentBean.class,"age=?",new String[]{
       "20"},value);
    
    /** 删除 */
    //删除StudentBean表下的age = 19的的数据
    AppDao.getInstance().delete(StudentBean.class,"age=?",new String[]{
       "19"});
    
    //删除StudentBean表下的所有数据
    AppDao.getInstance().deleteAll(StudentBean.class);

**三、重点来啦啊啊**

AppDao:

package lc.com.car.base.db;
    
    import android.content.ContentValues;
    import android.content.pm.PackageManager.NameNotFoundException;
    import android.database.Cursor;
    import android.database.sqlite.SQLiteDatabase;
    import android.util.Log;
    
    
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Locale;
    
    import lc.com.car.MyApplication;
    import lc.com.car.utils.LogData;
    
    
    /** * 使用反射来进行表的增删改查操作 * <p> * <p> * 使用方法： * <p> * 1.在创建表时：表名需要遵守一定规范 例如：类名为User时 User在数据库中的表名必须是 UserTable（包括大小写） * ,这样便于查找到相对应的表进行操作 2.在创建表时：字段名需要遵守一定规范 * 例如：在类中字段名为userName，那么这个字段的get方法名应该是getUserName()，那么表中的字段名，必须是userName，（包括大小写） * * @author lingfeng */
    public final class AppDao { 
        private DBOperHelper operHelper;
    
        /** * 在类名后追加的字符串，以此就知道这个类相对应的表名 */
        private final static String endTableName = "Table";
    
        private AppDao() {
    
            // 在这里初始化数据库版本，其版本号与应用的versionCode一致，这样在升级的时候就不用考虑这些细节问题
            int version = 1;
            try {
                version = MyApplication.getInstance().getPackageManager().getPackageInfo(MyApplication.getInstance().getPackageName(), 1).versionCode;
            } catch (NameNotFoundException e) {
                e.printStackTrace();
            }
    
            operHelper = new DBOperHelper(MyApplication.getInstance(), version);
        }
    
        /** * 确保只有一个DBOperHelper的实例， * 从DBOperHelper获取到的readableDatabase或writableDatabase是同步的， 所以就不需要考虑线程安全问题 * * @param * @return */
        public synchronized static AppDao getInstance() {
            return new AppDao();
        }
    
        /** * 查询出某个表中所有的数据 * * @param claz */
        public <T> List<T> findAll(Class<T> claz) {
            return find(claz, null, null, null, null, null, null);
        }
    
        /** * 有查询条件的查询某个表 * * @param claz * @return */
        public <T> List<T> findAll(Class<T> claz, String selection, String[] selectionArgs) {
            return find(claz, selection, selectionArgs, null, null, null, null);
        }
    
        /** * 多条件查询 * columns:要查询的列名，可以是多个，可以为null，表示查询所有列 * @param claz 需要返回的数据类型字节码对象，通过字节码对象才能通过反射进行下一步操作，不可为null * @param selection 查询条件，比如id=? and name=? 可以为null * @param selectionArgs 对查询条件赋值，一个问号对应一个值，按顺序 可以为null * @param groupBy 与合计函数一起使用 * @param having 语法have，与合计函数一起使用，可以为null * @param orderBy 语法，按xx排序，可以为null * @param limit 返回rows数量 */
        public <T> List<T> find(Class<T> claz, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit) {
    
            List<T> list = null;
    
            // 获取到类名
            String className = claz.getName();
    
            SQLiteDatabase readableDatabase = operHelper.getReadableDatabase();
    
            // 表名必须为是类名+Table
            String tableName = className.substring(className.lastIndexOf(".") + 1) + endTableName;
    
            // 查询数据
            Cursor query = readableDatabase.query(tableName, null, selection, selectionArgs, groupBy, having, orderBy, limit);
    
            if (query != null) {
                list = new ArrayList<T>();
    
                try {
                    // 得到字节码对象
                    @SuppressWarnings("unchecked")
                    Class<T> clz = (Class<T>) Class.forName(className);
                    // 根据字节码对象获取到所有set开头的公共方法集合
                    List<Method> methodList = parseSetMethodList(clz, "set");
    
                    // 如果得到的set方法集合大于1
                    if (methodList != null && methodList.size() > 0) {
                        query.moveToFirst();
                        for (int i = 0; i < query.getCount(); i++) {
                            // 将获取到得数据组装为list集合
                            list.add(initObject(clz, query, methodList));
                            query.moveToNext();
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if (query != null) {
                        query.close();
                    }
                    if (readableDatabase != null) {
                        readableDatabase.close();
                    }
                }
            } else {
                if (readableDatabase != null) {
                    readableDatabase.close();
                }
            }
            Log.e("appDao", tableName + "表获取到数据" + list == null ? "0" : list.size() + "条");
            return list;
        }
    
        /** * 根据从数据库获取到得数据封装对象并返回 * * @param clz 字节码对象 * @param query 数据库游标 * @param methodList set开头的方法名称集合 * @return */
        private <T> T initObject(Class<T> clz, Cursor query, List<Method> methodList) {
            T obj = null;
    
            try {
                obj = clz.newInstance();
                // 循环插入clz实例的每一个字段值
                for (Method method : methodList) {
                    // 根据方法名获取到参数的名字
                    String fieldName = method.getName().substring(4);
                    // 截取第三个字符转换为小写，并拼接成字段
                    fieldName = (method.getName().charAt(3) + "").toLowerCase(Locale.getDefault()) + fieldName;
                    // 得到方法的参数类型
                    Class<?>[] parameterTypes = method.getParameterTypes();
    
                    // 如果参数类型数组不为null且大于0时才进行插入数据
                    if (parameterTypes != null && !(parameterTypes.length < 1)) {
    
                        int columnIndex = query.getColumnIndex(fieldName);
                        if (parameterTypes[0] == String.class) {
                            method.invoke(obj, query.getString(columnIndex));
                        } else if (parameterTypes[0] == Integer.class) {
                            method.invoke(obj, query.getInt(columnIndex));
                        } else if (parameterTypes[0] == Long.class) {
                            method.invoke(obj, query.getLong(columnIndex));
                        } else if (parameterTypes[0] == Float.class) {
                            method.invoke(obj, query.getFloat(columnIndex));
                        } else if (parameterTypes[0] == Boolean.class) {
                            method.invoke(obj, query.getBlob(columnIndex));
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return obj;
        }
    
        /** * 插入数据 * * @param list * @return insert 返回插入操作所影响的行数 */
        public <T> Long insertAll(List<T> list) {
            Long insert = 0L;
    
            if (list == null || list.size() < 1) {
                return 0L;
            }
    
            String className = list.get(0).getClass().getName();
            String tableName = className.substring(className.lastIndexOf(".") + 1) + endTableName;
            SQLiteDatabase writableDatabase = operHelper.getWritableDatabase();
            Class<?> c = null;
            try {
                // 根据类名来获取字节码对象
                c = Class.forName(className);
    
                if (c != null) {
                    // 查找出所有以get为开头的方法
                    List<Method> methodList = parseSetMethodList(c, "get");
    
                    // 根据查找出来的get方法集合来执行插入数据的动作
                    for (T obj : list) {
                        // 返回插入数据的id
                        long number = insert(tableName, obj, methodList, writableDatabase);
    
                        // 说明插入一条数据成功
                        if (number != -1) {
                            insert++;
                        }
                    }
                } else {
                    Log.e(this.getClass().getName(), "=============== not found className class =================");
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (writableDatabase != null) {
                    writableDatabase.close();
                }
            }
            LogData.i("appDao", tableName + "表插入数据" + insert + "条");
    
            // 通知内容变化
            if (insert > 0) {
                DBProvider.getInstance().onChange(tableName);
            }
    
            return insert;
        }
    
        /** * 执行具体的插入数据的动作 * * @param tableName 表名 * @param obj 数据源 * @param methodList 数据源中的对象类型中以get为开头的方法的集合 * @return * @throws IllegalAccessException * @throws IllegalArgumentException * @throws InvocationTargetException */
        private <T> Long insert(String tableName, T obj, List<Method> methodList, SQLiteDatabase writableDatabase) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
            Long insert = 0L;
    
            ContentValues values = new ContentValues();
    
            for (Method method : methodList) {
                String name = method.getName();
    
                // 封装好ContentValues 数据
                if (name.startsWith("get") && !name.startsWith("getClass")) {
    
                    Object methodValue = method.invoke(obj, new Object[]{});
                    String filedName = method.getName().substring(4);
    
                    filedName = (method.getName().charAt(3) + "").toLowerCase(Locale.getDefault()) + filedName;
    
                    values.put(filedName, methodValue + "");
                }
            }
            // 插入数据
            insert = writableDatabase.insert(tableName, null, values);
            return insert;
        }
    
        /** * 删除一条数据 * * @param clz 字节码对象 * @param select * @param selectArg * @return 操作所影响的行数 */
        public int delete(Class<?> clz, String select, String[] selectArg) {
            int delete = 0;
    
            SQLiteDatabase writableDatabase = operHelper.getWritableDatabase();
            String tableName = "";
            try {
                tableName = clz.getName().substring(clz.getName().lastIndexOf(".") + 1) + endTableName;
    
                delete += writableDatabase.delete(tableName, select, selectArg);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (writableDatabase != null) {
                    writableDatabase.close();
                }
            }
            LogData.i("AppDao", tableName + "表删除" + delete + "条数据");
    
            // 通知内容变化
            if (delete > 0) {
                DBProvider.getInstance().onChange(tableName);
            }
    
            return delete;
        }
    
        /** * 修改数据 * * @param clz 所要操作对象字节码 * @param select 选择条目的条件 * @param selectArg 选择条目的值 * @param values 所要修改的键值对 * @return 修改所影响的行数 */
        public int update(Class<?> clz, String select, String[] selectArg, ContentValues values) {
            int update = 0;
    
            SQLiteDatabase writableDatabase = operHelper.getWritableDatabase();
            String tableName = "";
            try {
                tableName = clz.getName().substring(clz.getName().lastIndexOf(".") + 1) + endTableName;
    
                update += writableDatabase.update(tableName, values, select, selectArg);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (writableDatabase != null) {
                    writableDatabase.close();
                }
            }
            LogData.i("AppDao", tableName + "表修改所影响了" + update + "条数据");
    
            // 通知内容变化
            if (update > 0) {
                DBProvider.getInstance().onChange(tableName);
            }
    
            return update;
        }
    
        /** * 删除所有数据 * * @param clz * @return 操作所影响的行数 */
        public int deleteAll(Class<?> clz) {
            return delete(clz, null, null);
        }
    
        /** * 根据class的字节码对象来反射获取到以set或get开头的公共方法集合 * * @param clz * @param methodStartsWith 寻找以什么开头的方法（在这里也就是setXxx()或者getXxx()之类的方法） * @return */
        private List<Method> parseSetMethodList(Class<?> clz, String methodStartsWith) {
            Method[] methods = clz.getMethods();
            List<Method> list = new ArrayList<Method>();
    
            for (Method m : methods) {
                if (m.getName().startsWith(methodStartsWith)) {
                    // 根据方法名获取到参数的名字
                    list.add(m);
                }
            }
            return list;
        }
    }

DBOperHelper:

package lc.com.car.base.db;
    
    import android.content.Context;
    import android.database.sqlite.SQLiteDatabase;
    import android.database.sqlite.SQLiteOpenHelper;
    
    /** * 数据库操作类 * * @author lingfeng * */
    public class DBOperHelper extends SQLiteOpenHelper { 
    
        public DBOperHelper(Context context, int version) {
            super(context, "hb.db", null, version);
        }
    
        @Override
        public void onCreate(SQLiteDatabase db) {
          // Student表 使用时删掉
            db.execSQL("CREATE TABLE "
                    +"StudentBeanTable "
                    +"(_ID INTEGER primary key autoincrement,name varchar(40),id varchar(40),age varchar(10))");
        }
    
        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    
        }
    }

**DBProvider：**

package lc.com.car.base.db;
    
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Set;
    
    import lc.com.car.base.callback.OnRespanceListener;
    
    
    /** * 数据库内容变化监听器 * @author lingfeng * */
    public class DBProvider { 
    
        private static DBProvider dbProvider;
    
        public static DBProvider getInstance(){
            if(dbProvider == null){
                dbProvider = new DBProvider();
            }
            return dbProvider;
        }
    
        //数据库状态变化监听
        private HashMap<OnRespanceListener<String>,String> hashMap = new HashMap<OnRespanceListener<String>, String>();
    
        /** * 当tableName表中的数据发生改变时被appDao调用 * @param tableName */
        public void onChange(String tableName){
            Set<OnRespanceListener<String>> keySet = hashMap.keySet();
            Iterator<OnRespanceListener<String>> iterator = keySet.iterator();
    
            while(iterator.hasNext()){
                OnRespanceListener<String> next = iterator.next();
                String value = hashMap.get(next);
                if(tableName.equals(value)){
                    next.onRespance(tableName);
                }
            }
        }
    
        /** * 注册监听 * @param tableName * @param onRespanceListener */
        public void addRegisterContentObserver(String tableName, OnRespanceListener<String> onRespanceListener){
            hashMap.put(onRespanceListener, tableName);
        }
    
        /** * 取消注册监听 * @param * @param onRespanceListener */
        public void unRegisterContentObserver(OnRespanceListener<String> onRespanceListener){
            hashMap.remove(onRespanceListener);
        }
    }