Java 反射和注解的笔记

这几天刚开工,有简单的学习一下反射和注解。

1. 什么是反射机制？

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的以及动态调用对象的方法的功能称为Java的反射机制。

2. 什么时候用到反射

Java的反射机制相信大家在平时的业务开发过程中应该很少使用到，但是在一些基础框架的搭建上应用非常广泛.

3.反射机制能够获取哪些信息？

在运行时判定任意一个对象所属的类;
在运行时构造任意一个类的对象；
在运行时判定任意一个类所具有的成员变量和方法；
在运行时调用任意一个对象的方法；
生成动态代理；
主要的反射机制类：
java.lang.Class; //类
java.lang.reflect.Constructor;//构造方法
java.lang.reflect.Field; //类的成员变量
java.lang.reflect.Method;//类的方法
java.lang.reflect.Modifier;//访问权限
3.1 class对象的获取
//第一种方式 通过对象getClass方法
Person person = new Person();
Class<?> class1 = person.getClass();
//第二种方式 通过类的class属性
class1 = Person.class;
try {
//第三种方式 通过Class类的静态方法——forName()来实现
class1 = Class.forName(“club.sscai.Person”);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}

上边这三种方式，最常用的是第三种，前两种获取 class 的方式没有什么意义，毕竟你都导了包了
3.2 字段及方法和注解的获取
Field[] allFields = class1.getDeclaredFields();//获取class对象的所有属性
Field[] publicFields = class1.getFields();//获取class对象的public属性
try {
Field ageField = class1.getDeclaredField(“age”);//获取class指定属性
Field desField = class1.getField(“des”);//获取class指定的public属性
} catch (NoSuchFieldException e) {
e.printStackTrace();
}

Method[] methods = class1.getDeclaredMethods();//获取class对象的所有声明方法
Method[] allMethods = class1.getMethods();//获取class对象的所有方法 包括父类的方法

Class parentClass = class1.getSuperclass();//获取class对象的父类
Class<?>[] interfaceClasses = class1.getInterfaces();//获取class对象的所有接口

Constructor<?>[] allConstructors = class1.getDeclaredConstructors();//获取class对象的所有声明构造函数
Constructor<?>[] publicConstructors = class1.getConstructors();//获取class对象public构造函数
try {
Constructor<?> constructor = class1.getDeclaredConstructor(new Class[]{String.class});//获取指定声明构造函数
Constructor publicConstructor = class1.getConstructor(new Class[]{});//获取指定声明的public构造函数
} catch (NoSuchMethodException e) {
e.printStackTrace();
}

Annotation[] annotations = class1.getAnnotations();//获取class对象的所有注解
Annotation annotation = class1.getAnnotation(Deprecated.class);//获取class对象指定注解

Type genericSuperclass = class1.getGenericSuperclass();//获取class对象的直接超类的 Type
Type[] interfaceTypes = class1.getGenericInterfaces();//获取class对象的所有接口的type集合

下面简单举个例子 通过反射和注解 生成 数据库 并插入数据

1. 获取class
    Class<? extends Object> aClass = o.getClass();
   

2. //2.获取表名称
    String simpleName = aClass.getSimpleName();
   

3.  查询数据库判断表是否存在 是 不作操作 否 新增表
   

4.  执行插入语句
   

废话不多 直接上代码:

    public void save(Object o) {
        //1.获取class
        Class<? extends Object> aClass = o.getClass();
        Log.e(TAG, aClass.getName());
        //2.获取class里字段
        Field[] declaredFields = aClass.getDeclaredFields();
        String className = aClass.getName();
        String[] split = className.split("\\.");
        //2.获取表名称
//        String simpleName = aClass.getSimpleName();
        String tableName = split[split.length - 1];
        Log.e(TAG, tableName);
        //3.拼接字符串
        StringBuffer creatTable = new StringBuffer();
        StringBuffer stringBuffer = new StringBuffer();
        creatTable.append("CREATE TABLE [" + tableName + "] (");
        stringBuffer.append("insert into " + tableName + " (");
        for (int i = 0; i < declaredFields.length; i++) {
            //设置是否允许访问，不是修改原来的访问权限修饰词。
            declaredFields[i].setAccessible(true);
            Log.e(TAG, declaredFields[i].getName());
            if (i == declaredFields.length - 1) {
                //3.1获取字段名称并拼接
                stringBuffer.append(declaredFields[i].getName());
                creatTable.append("[" + declaredFields[i].getName() + "] VARCHAR(50))");
            } else {
                creatTable.append("[" + declaredFields[i].getName() + "] VARCHAR(50) ,");
                stringBuffer.append(declaredFields[i].getName() + ",");
            }
        }

        stringBuffer.append(") values (");
        for (int i = 0; i < declaredFields.length; i++) {
            //设置是否允许访问，不是修改原来的访问权限修饰词。
            declaredFields[i].setAccessible(true);
            try {
                if (declaredFields[i].getType().getName().equals(
                        java.lang.String.class.getName())) {//字符串类型
                    Object o1 = declaredFields[i].get(o);
                    //3.2获取字段值 并拼接
                    Log.e(TAG, declaredFields[i].getName() + "===" + o1);
                    if (i == declaredFields.length - 1) {
                        stringBuffer.append("'" +o1 + "'");
                    } else {
                        stringBuffer.append("'" +o1 + "'" + ",");
                    }
                } else if (declaredFields[i].getType().getName().equals(
                        java.lang.Integer.class.getName())
                        || declaredFields[i].getType().getName().equals("int")) {//int类型
                    Object o1 = declaredFields[i].getInt(o);
                    Log.e(TAG, declaredFields[i].getName() + "===" + o1);
                    if (i == declaredFields.length - 1) {
                        stringBuffer.append("'" + o1 + "'");
                    } else {
                        stringBuffer.append("'" + o1 + "'" + ",");
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

        }
        stringBuffer.append(")");
        Log.e(TAG, stringBuffer.toString());
        Log.e(TAG, creatTable.toString());
        //4.判断表是否存在 是 不作操作 否 新增表
        SQLiteDatabase db = getWritableDatabase();
        boolean b = tabbleIsExist(db, tableName);
        Log.e(TAG, "" + b);
        if (!b) {
            db.execSQL(creatTable.toString());

        }
        //5.执行sql
        db.execSQL(stringBuffer.toString());
    }
**注:注解也是通过反射获取注解value 拼接SQL  执行Sql 这里就不说了**

附源码

public class DBHelper extends SQLiteOpenHelper {


    private String TAG = "DBHelper";

    public DBHelper(Context context) {
        super(context, "DemoDB", null, 1, null);
    }


    @Override
    public void onCreate(SQLiteDatabase db) {

    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    }

    public void save(Object o) {
        //1.获取class
        Class<? extends Object> aClass = o.getClass();
        Log.e(TAG, aClass.getName());
        //2.获取class里字段
        Field[] declaredFields = aClass.getDeclaredFields();
        String className = aClass.getName();
        String[] split = className.split("\\.");
        //2.获取表名称
//        String simpleName = aClass.getSimpleName();
        String tableName = split[split.length - 1];
        Log.e(TAG, tableName);
        //3.拼接字符串
        StringBuffer creatTable = new StringBuffer();
        StringBuffer stringBuffer = new StringBuffer();
        creatTable.append("CREATE TABLE [" + tableName + "] (");
        stringBuffer.append("insert into " + tableName + " (");
        for (int i = 0; i < declaredFields.length; i++) {
            //设置是否允许访问，不是修改原来的访问权限修饰词。
            declaredFields[i].setAccessible(true);
            Log.e(TAG, declaredFields[i].getName());
            if (i == declaredFields.length - 1) {
                //3.1获取字段名称并拼接
                stringBuffer.append(declaredFields[i].getName());
                creatTable.append("[" + declaredFields[i].getName() + "] VARCHAR(50))");
            } else {
                creatTable.append("[" + declaredFields[i].getName() + "] VARCHAR(50) ,");
                stringBuffer.append(declaredFields[i].getName() + ",");
            }
        }

        stringBuffer.append(") values (");
        for (int i = 0; i < declaredFields.length; i++) {
            //设置是否允许访问，不是修改原来的访问权限修饰词。
            declaredFields[i].setAccessible(true);
            try {
                if (declaredFields[i].getType().getName().equals(
                        java.lang.String.class.getName())) {//字符串类型
                    Object o1 = declaredFields[i].get(o);
                    //3.2获取字段值 并拼接
                    Log.e(TAG, declaredFields[i].getName() + "===" + o1);
                    if (i == declaredFields.length - 1) {
                        stringBuffer.append("'" +o1 + "'");
                    } else {
                        stringBuffer.append("'" +o1 + "'" + ",");
                    }
                } else if (declaredFields[i].getType().getName().equals(
                        java.lang.Integer.class.getName())
                        || declaredFields[i].getType().getName().equals("int")) {//int类型
                    Object o1 = declaredFields[i].getInt(o);
                    Log.e(TAG, declaredFields[i].getName() + "===" + o1);
                    if (i == declaredFields.length - 1) {
                        stringBuffer.append("'" + o1 + "'");
                    } else {
                        stringBuffer.append("'" + o1 + "'" + ",");
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

        }
        stringBuffer.append(")");
        Log.e(TAG, stringBuffer.toString());
        Log.e(TAG, creatTable.toString());
        //4.判断表是否存在 是 不作操作 否 新增表
        SQLiteDatabase db = getWritableDatabase();
        boolean b = tabbleIsExist(db, tableName);
        Log.e(TAG, "" + b);
        if (!b) {
            db.execSQL(creatTable.toString());

        }
        //5.执行sql
        db.execSQL(stringBuffer.toString());
    }

    /**
     * 判断某个表是否存在
     *
     * @param db
     * @param tableName
     * @return
     */
    public boolean tabbleIsExist(SQLiteDatabase db, String tableName) {
        boolean result = false;
        if (tableName == null) {
            return false;
        }
        Cursor cursor = null;
        try {
            String sql = "select count(*) as c from sqlite_master where type ='table' and name ='" + tableName.trim() + "' ";
            cursor = db.rawQuery(sql, null);
            if (cursor.moveToNext()) {
                int count = cursor.getInt(0);
                if (count > 0) {
                    result = true;
                }
            }

        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 判断某表里某字段是否存在
     *
     * @param db
     * @param tableName
     * @param fieldName
     * @return
     */
    public boolean isFieldExist(SQLiteDatabase db, String tableName, String fieldName) {
        String queryStr = "select sql from sqlite_master where type = 'table' and name = '%s'";
        queryStr = String.format(queryStr, tableName);
        Cursor c = db.rawQuery(queryStr, null);
        String tableCreateSql = null;
        try {
            if (c != null && c.moveToFirst()) {
                tableCreateSql = c.getString(c.getColumnIndex("sql"));
            }
        } finally {
            if (c != null)
                c.close();
        }
        if (tableCreateSql != null && tableCreateSql.contains(fieldName))
            return true;
        return false;
    }

    /**
     * 判断某表里某字段是否存在 不存在则增加
     *
     * @param db
     * @param tableName
     * @param fieldName
     * @return
     */
    public boolean isFieldExistAndAddField(SQLiteDatabase db, String tableName, String fieldName) {
        String queryStr = "select sql from sqlite_master where type = 'table' and name = '%s'";
        queryStr = String.format(queryStr, tableName);
        Cursor c = db.rawQuery(queryStr, null);
        String tableCreateSql = null;
        try {
            if (c != null && c.moveToFirst()) {
                tableCreateSql = c.getString(c.getColumnIndex("sql"));
            }
        } finally {
            if (c != null)
                c.close();
        }
        if (tableCreateSql != null && tableCreateSql.contains(fieldName))
            return true;

        //增加字段
        boolean b = addField(db, tableName, fieldName);

        return false;
    }

    /**
     * 给某个表里增加字段
     *
     * @param db
     * @param tableName
     * @param fieldName
     * @return
     */
    public boolean addField(SQLiteDatabase db, String tableName, String fieldName) {
        boolean flag = false;
        try {
//            db.execSQL("alter table "+tableName+" add column "+fieldName+" varchar");
            db.execSQL("alter table " + tableName + " add column " + fieldName + " varchar(50)");
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
            flag = false;
            return flag;
        }
        return flag;
    }

}

如何使用

public class MainActivity extends AppCompatActivity {

    private String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        User user = new User();
        user.setId("2");
        user.setName("鱼达人");
        user.setAge("28");
        user.setJob("销售");
        user.setSex("男");

        Student student = new Student();
        student.setId("3");
//        student.setName("安迪");
        student.setAge("16");
        student.setClazz("三年二班");
        student.setSex("女");

        Teacher teacher = new Teacher();
        teacher.setAge(32);
        teacher.setName("王老师");
        teacher.setSubject("语文");
//插入任意实体类到数据库
 DBHelper dbHelper = new DBHelper(this);
  dbHelper.save(user);
 dbHelper.save(student);
dbHelper.save(teacher);
    }
}

实体类
public class Teacher {
private String name;
private int age;
private String subject;

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

public String getSubject() {
    return subject;
}

public void setSubject(String subject) {
    this.subject = subject;
}

}