声明：此例子是为了学习注解和反射的综合应用，但是功能是可以用的。我不能保证没有bug，因为我也没可劲的测试过，只是为了学习注解反射，比较好理解的一个例子。
1、声明表名注解，创建数据库表名使用
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TableName {
String value();
}
2、声明字段直接，创建表中的列使用
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface KeyName {
String value(); //字段名称
boolean isPrimaryKey() default false; //是否为主键
}
3、创建一个要存入数据库的对象
此处用Student为例子
@TableName("sdfsdfsdf")
public class Student {
//表中的列名为sql_userName，并且是主键
@KeyName(value = "sql_userName", isPrimaryKey = true)
private String userName;
@KeyName(value = "sql_age")
private int age;
//没有被注解的字段，默认就是属性名字
private String sex;
public Student() {
}
public Student(String userName, int age, String sex) {
this.userName = userName;
this.age = age;
this.sex = sex;
}
//get() 和set()方法...省略了,要写上。。。。
@Override
public String toString() {
return "Student{" +
"userName='" + userName + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
}
4、创建 SQLiteOpenHelper 单例
我们要去动态的创建表，所以这里只创建数据，不做其他操作。
public class SQLiteManager {
public SQLiteManager() {
}
private static SQLiteOpenHelper SQ_LITE_UTIL = null;
public static SQLiteOpenHelper getSqLiteUtil(Context context, String name) {
if (SQ_LITE_UTIL == null) {
synchronized (SQLiteOpenHelper.class) {
if (SQ_LITE_UTIL == null) {
SQ_LITE_UTIL = new SQLiteOpenHelper(context, name, null, 1) {
@Override
public void onCreate(SQLiteDatabase db) {
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
};
}
}
}
return SQ_LITE_UTIL;
}
}
4、定义一个增删检查的接口类
也可以不写，定义这个接口是为了规范方法的。
public interface IDataBaseInterface {
<_Tx> boolean insert(_Tx object);
<_Tx> boolean insert(_Tx... object);
<_Tx> boolean insert(List<_Tx> objectList);
<_Tx> boolean update( _Tx object);
<_Tx> boolean update(_Tx... object);
<_Tx> boolean update( List<_Tx> objectList);
<_Tx> boolean delete(_Tx object);
<_Tx> boolean delete(_Tx... object);
<_Tx> boolean delete(List<_Tx> objectList);
<_Tx> List<_Tx> select(Class<_Tx> txClass,AbsSelect object);
}
5、 ！！重点在这里！！ 通过注解反射实现增删改查
代码里面都写了注释咯~~~
public class DataBaseImpl implements IDataBaseInterface {
private Context context;
String sqlName;
static Map<String, String> keyTokey = new HashMap<>();//记录属性类型和sql中的数据类型，目的是为了转换数据类型
static {
keyTokey.put(String.class.getSimpleName(), "TEXT");
keyTokey.put(Integer.class.getSimpleName(), "INTEGER");
keyTokey.put("int", "INTEGER");
keyTokey.put(Long.class.getSimpleName(), "TEXT");
keyTokey.put(Short.class.getSimpleName(), "INTEGER");
keyTokey.put(Double.class.getSimpleName(), "REAL");
keyTokey.put(Boolean.class.getSimpleName(), "BLOB");
}
public DataBaseImpl(Context context, String sqlName) {
this.context = context;
this.sqlName = sqlName;
}
@Override
public <_Tx> boolean insert(_Tx object) {
String primarKey = null;//主键名称
String primarKeyTy = null;
String primarKeySqlTy = null;
Class aClass = object.getClass();
//创建一行数据
ContentValues contentValues = new ContentValues();
//记录属性和属性的数据类型
Map<String, Object> keyToValue = new HashMap<>();
//获取类的表名注解
TableName annotation = (TableName) aClass.getAnnotation(TableName.class);
if (annotation != null) {
Constant.tableName = annotation.value();
} else {
Constant.tableName = aClass.getSimpleName();
}
try {
//反射所有属性
Field[] declaredFields = Utils.getClassDeclaredFields(aClass);
if (declaredFields != null) {
for (Field itemField : declaredFields) {
itemField.setAccessible(true);
//获取属性的列名注解
KeyName keyName = itemField.getAnnotation(KeyName.class);
if (keyName != null) {//如果属性被注解了
if (keyName.isPrimaryKey()) {
//主键的名字从注解里面获取（写spl语句使用）
primarKey = keyName.value();
//主键的数据类型，判断主键的数据类型和sql的数据类型使用
primarKeyTy = ((Class) itemField.getGenericType()).getSimpleName();
}
//添加列名和内容
contentValues.put(keyName.value(), String.valueOf(itemField.get(object)));
//添加属性名称和属性的数据类型
keyToValue.put(keyName.value(), ((Class) itemField.getGenericType()).getSimpleName());
} else {
contentValues.put(itemField.getName(), String.valueOf(itemField.get(object)));
keyToValue.put(itemField.getName(), ((Class) itemField.getGenericType()).getSimpleName());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
//构造创建表的sql语句
StringBuilder stringBuilder = new StringBuilder();
//移除主键，主键在spl语句中单独添加，不与其他列一起添加
keyToValue.remove(primarKey);
for (Map.Entry<String, Object> objectEntry : keyToValue.entrySet()) {
String key = objectEntry.getKey();
Object value = objectEntry.getValue();
stringBuilder.append("," + key);
for (Map.Entry<String, String> keyT : keyTokey.entrySet()) {
if (keyT.getKey().equals(value.toString())) {
//循环map，拼接spl语句
stringBuilder.append(" " + keyT.getValue());
}
if (keyT.getKey().equals(primarKeyTy)) {
//获取主键在sql的数据类型
primarKeySqlTy = keyT.getValue();
}
}
}
//获取数据库
SQLiteDatabase writableDatabase = SQLiteManager.getSqLiteUtil(context, sqlName).getWritableDatabase();
String sql = "create table if not exists " + Constant.tableName + " (" + primarKey + " "
+ primarKeySqlTy + " primary key " + stringBuilder.toString() + ")";
//先检查表是否存在
boolean exist = Utils.isTableExist(writableDatabase, Constant.tableName);
if (!exist) {
writableDatabase.execSQL(sql);
}
//再检查是否有多余的列
for (Map.Entry<String, Object> entry : keyToValue.entrySet()) {
String keyTValue = null;
if (!Utils.isColumnExist(writableDatabase, Constant.tableName, entry.getKey())) {
for (Map.Entry<String, String> keyT : keyTokey.entrySet()) {
if (keyT.getKey().equals(entry.getKey())) {
keyTValue = keyT.getValue();
}
}
//更新表结构sql语句
String upsql = "ALTER TABLE " + Constant.tableName + " ADD " + entry.getKey() + " " + keyTValue;
writableDatabase.execSQL(upsql);
}
}
//插入数据
writableDatabase.insert(Constant.tableName, null, contentValues);
writableDatabase.close();
return false;
}
@Override
public <_Tx> boolean insert(_Tx... object) {
for (_Tx tx : object) {
insert(tx);
}
return false;
}
@Override
public <_Tx> boolean insert(List<_Tx> objectList) {
for (_Tx tx : objectList) {
insert(tx);
}
return false;
}
@Override
public <_Tx> boolean update(_Tx object) {
String primarKey = null;
Class aClass = object.getClass();
SQLiteDatabase writableDatabase = SQLiteManager.getSqLiteUtil(context, sqlName).getWritableDatabase();
ContentValues contentValues = new ContentValues();
String primarKeyValue = null;
try {
Field[] declaredFields = Utils.getClassDeclaredFields(aClass);
for (Field itemField : declaredFields) {
itemField.setAccessible(true);
//主键
KeyName keyName = itemField.getAnnotation(KeyName.class);
if (keyName != null) {
if (keyName.isPrimaryKey()) {
primarKey = keyName.value();//主键的名字从注解里面获取
primarKeyValue = String.valueOf(itemField.get(object));
}
contentValues.put(keyName.value(), String.valueOf(itemField.get(object)));
} else {
contentValues.put(itemField.getName(), String.valueOf(itemField.get(object)));
}
}
writableDatabase.update(Constant.tableName, contentValues, primarKey + "=?", new String[]{primarKeyValue});
writableDatabase.close();
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
@Override
public <_Tx> boolean update(_Tx... object) {
for (_Tx tx : object) {
update(tx);
}
return false;
}
@Override
public <_Tx> boolean update(List<_Tx> objectList) {
for (_Tx tx : objectList) {
update(tx);
}
return false;
}
@Override
public <_Tx> boolean delete(_Tx object) {
String primarKey = null;
Class aClass = object.getClass();
SQLiteDatabase writableDatabase = SQLiteManager.getSqLiteUtil(context, sqlName).getWritableDatabase();
String primarKeyValue = null;
TableName annotation = (TableName) aClass.getAnnotation(TableName.class);
if (annotation != null) {
Constant.tableName = annotation.value();
} else {
Constant.tableName = aClass.getSimpleName();
}
try {
Field[] declaredFields = Utils.getClassDeclaredFields(aClass);
if (declaredFields != null) {
for (Field itemField : declaredFields) {
itemField.setAccessible(true);
//主键
KeyName keyName = itemField.getAnnotation(KeyName.class);
if (keyName != null) {
if (keyName.isPrimaryKey()) {
primarKey = keyName.value();//主键的名字从注解里面获取
primarKeyValue = String.valueOf(itemField.get(object));
}
}
}
}
writableDatabase.delete(Constant.tableName, primarKey + "=?", new String[]{primarKeyValue});
writableDatabase.close();
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
@Override
public <_Tx> boolean delete(_Tx... object) {
for (_Tx tx : object) {
delete(tx);
}
return false;
}
@Override
public <_Tx> boolean delete(List<_Tx> objectList) {
for (_Tx tx : objectList) {
delete(tx);
}
return false;
}
@Override
public <_Tx> List<_Tx> select(Class<_Tx> txClass, AbsSelect absSelect) {
//返回结果
List<_Tx> _TxList = new ArrayList<>();
//查询列名
List<String> columnsList = new ArrayList<>();
//记录查询sql的字段和属性的数据类型
Map<String, String> keyToType = new HashMap<>();
//存放查询出来的数据
Map<String, Object> keyToValue = new HashMap<>();
String selection = null;
String[] selectionArgs = null;
String groupBy = null;
String having = null;
String orderBy = null;
String limit = null;
if (absSelect != null) {
if (!TextUtils.isEmpty(absSelect.tableName())) {
Constant.tableName = absSelect.tableName();
}
selection = absSelect.selection();
selectionArgs = absSelect.selectionArgs();
groupBy = absSelect.groupBy();
having = absSelect.having();
orderBy = absSelect.orderBy();
limit = absSelect.limit();
}
try {
TableName annotation = (TableName) txClass.getAnnotation(TableName.class);
if (annotation != null) {
Constant.tableName = annotation.value();
} else {
Constant.tableName = txClass.getSimpleName();
}
Field[] declaredFields = Utils.getClassDeclaredFields(txClass);
if (declaredFields != null) {
for (Field itemField : declaredFields) {
itemField.setAccessible(true);
KeyName keyName = itemField.getAnnotation(KeyName.class);
if (keyName != null) {
//添加查询的列名
columnsList.add(keyName.value());
//记录属性（列名）和数据类型
keyToType.put(keyName.value(), ((Class) itemField.getGenericType()).getSimpleName());
} else {
columnsList.add(itemField.getName());
keyToType.put(itemField.getName(), ((Class) itemField.getGenericType()).getSimpleName());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
if (columnsList != null && columnsList.size() > 0 && keyToType != null && keyToType.size() > 0) {
SQLiteDatabase writableDatabase = SQLiteManager.getSqLiteUtil(context, sqlName).getWritableDatabase();
//查询数据
Cursor cursor = writableDatabase
.query(Constant.tableName, columnsList.toArray(new String[]{}), selection, selectionArgs, groupBy, having, orderBy, limit);
while (cursor.moveToNext()) {
for (Map.Entry<String, String> entry : keyToType.entrySet()) {
//循环keyToType，如果获取到的数据类型是String.class.getSimpleName()，就去获取这个key（属性）在数据库中的值，并存放在keyToValue中，以此类推
if (entry.getValue().equals(String.class.getSimpleName())) { //String类型
keyToValue.put(entry.getKey(), cursor.getString(cursor.getColumnIndex(entry.getKey().trim())));
} else if (entry.getValue().equals("int")) {//int类型
keyToValue.put(entry.getKey(), cursor.getInt(cursor.getColumnIndex(entry.getKey().trim())));
} else if (entry.getValue().equals(Double.class.getSimpleName())) {//double类型
keyToValue.put(entry.getKey(), cursor.getDouble(cursor.getColumnIndex(entry.getKey().trim())));
} else if (entry.getValue().equals(Long.class.getSimpleName())) {//long类型
keyToValue.put(entry.getKey(), cursor.getLong(cursor.getColumnIndex(entry.getKey().trim())));
} else if (entry.getValue().equals(Short.class.getSimpleName())) {//short类型
keyToValue.put(entry.getKey(), cursor.getShort(cursor.getColumnIndex(entry.getKey().trim())));
} else if (entry.getValue().equals(Integer.class.getSimpleName())) {//Integer类型
keyToValue.put(entry.getKey(), cursor.getInt(cursor.getColumnIndex(entry.getKey().trim())));
} else if (entry.getValue().equals(Boolean.class.getSimpleName())) {//Integer类型
keyToValue.put(entry.getKey(), cursor.getBlob(cursor.getColumnIndex(entry.getKey().trim())));
}
}
try {
//反射构造方法
Constructor declaredConstructor = txClass.getDeclaredConstructor();
//打开权限
declaredConstructor.setAccessible(true);
//创建对象
_Tx objectClass = (_Tx) declaredConstructor.newInstance();
//反射对象的属性
Field[] declaredFields = Utils.getClassDeclaredFields(objectClass.getClass());
if (declaredFields != null) {
for (Field itemField : declaredFields) {
itemField.setAccessible(true);
KeyName keyName = itemField.getAnnotation(KeyName.class);
if (keyName != null) {
for (Map.Entry<String, Object> entry : keyToValue.entrySet()) {
//如果keyToValue中key和对象的属性是相同的，就把值赋给属性
if (entry.getKey().equals(keyName.value())) {
itemField.set(objectClass, entry.getValue());
}
}
} else {
for (Map.Entry<String, Object> entry : keyToValue.entrySet()) {
if (entry.getKey().equals(itemField.getName())) {
itemField.set(objectClass, entry.getValue());
}
}
}
}
}
_TxList.add(objectClass);
} catch (Exception e) {
e.printStackTrace();
}
}
writableDatabase.close();
}
return _TxList;
}
}
6、常量类
public class Constant {
public static String tableName = "";//表名
}
7、Utils 判断表是否存在还是列是否存在以及过滤反射的字段
public class Utils {
/**
* 作用:判断表是否存在
*
* @param db 数据库
* @param tableName 表名
*/
public static boolean isTableExist(SQLiteDatabase db, String tableName) {
Cursor cursor = null;
try {
cursor = db.rawQuery("SELECT count(*) FROM sqlite_master WHERE type='table' AND name=?", new String[]{tableName});
boolean hasNext = cursor.moveToNext();
return hasNext && cursor.getInt(0) > 0;
} finally {
if (cursor != null) {
cursor.close();
}
}
}
/**
* 判断列-否存在
*
* @param db 数据库
* @param columnName 列名
*/
public static boolean isColumnExist(SQLiteDatabase db, String tableName, String columnName) {
boolean result = false;
Cursor cursor = null;
try {
cursor = db.rawQuery("select * from sqlite_master where name = ? and sql like ?"
, new String[]{tableName, "%" + columnName + "%"});
result = null != cursor && cursor.moveToFirst();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (null != cursor && !cursor.isClosed()) {
cursor.close();
}
}
return result;
}
/***
*反射获取属性,屏蔽多余字段
*/
public static Field[] getClassDeclaredFields(Class sClass) {
List<Field> list = new ArrayList<>();
Field[] fields = sClass.getDeclaredFields();
if (fields != null) {
for (Field field : fields) {
if (!field.getName().equals("$change") && !field.getName().equals("serialVersionUID")) {
list.add(field);
}
}
}
Field[] fields1 = list.toArray(new Field[]{});
return list.toArray(new Field[]{});
}
}
8、查新使用的接口
规范方法
public interface ISelect {
String tableName();
String[] columns();
String selection();
String[] selectionArgs();
String groupBy();
String having();
String orderBy();
String limit();
}
9、实现查询的接口
默认都是空，但是查询的表名不可以为空哈，我查询的时候做了判断了~~
public class AbsSelect implements ISelect {
@Override
public String tableName() {
return null;
}
@Override
public String[] columns() {
return null;
}
@Override
public String selection() {
return null;
}
@Override
public String[] selectionArgs() {
return null;
}
@Override
public String groupBy() {
return null;
}
@Override
public String having() {
return null;
}
@Override
public String orderBy() {
return null;
}
@Override
public String limit() {
return null;
}
}
10、MainActivity
布局就不写了哈，就四个按钮，对应四个点击事件
public class MainActivity extends AppCompatActivity {
private List<Student> list = new ArrayList<>();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
list.add(new Student("小米", 7, "1"));
list.add(new Student("小明", 8, "2"));
list.add(new Student("小红", 9, "1"));
}
public void 增加(View view) {
new DataBaseImpl(this, "PersonInfo").insert(list);
}
public void 删除(View view) {
new DataBaseImpl(this, "PersonInfo").delete(new Student("小红", 9, "1"));
}
public void 修改(View view) {
Student student = new Student("小米", 9, "nv");
new DataBaseImpl(this, "PersonInfo").update(student);
}
public void 查看(View view) {
//查询所有的数据咯
List<Student> students = new DataBaseImpl(this, "PersonInfo").select(Student.class, new AbsSelect());
}
}
网友评论