JAVA的反射机制

一，反射的初步：

动态语言： 程序运行时，可以改变程序结构或变量类型，如：Python,ruby,javascript等等。

二，获取类有三种方式：

1.xxx.forName(path)
2.xxx.class
3.xxx.getClass()

/** * 测试各种类型(class,interface,enum,annotation,primitive type,void)对应的java.lang.Class对象的获取方式 * */@SuppressWarnings("all")public class Demo01 {    public static void main(String[] args) {        String path = "com.bjsxt.test.bean.User";        try {            Class clazz = Class.forName(path);            //对象是表示或封装一些数据。  一个类被加载后，JVM会创建一个对应该类的Class对象，类的整个结构信息会放到对应的Class对象中。            //这个Class对象就像一面镜子一样，通过这面镜子我可以看到对应类的全部信息。            System.out.println(clazz.hashCode());            Class clazz2 = Class.forName(path); //一个类只对应一个Class对象            System.out.println(clazz2.hashCode());            Class strClazz = String.class;            Class strClazz2 = path.getClass();             System.out.println(strClazz==strClazz2);            Class intClazz =int.class;            int[] arr01 = new int[10];            int[][] arr02 = new int[30][3];            int[] arr03 = new int[30];            double[] arr04 = new double[10];            System.out.println(arr01.getClass().hashCode());            System.out.println(arr02.getClass().hashCode());            System.out.println(arr03.getClass().hashCode());            System.out.println(arr04.getClass().hashCode());        } catch (Exception e) {            e.printStackTrace();        }    }}

三，利用反射的API，来获取类的信息：通过类的模板获取类的，属性，方法，构造器，（有参，无参）！

//测试1：public class Demo02 {    public static void main(String[] args) {        String path = "com.bjsxt.test.bean.User";        try {            Class clazz = Class.forName(path);            //获取类的名字            System.out.println(clazz.getName());//获得包名+类名：com.bjsxt.test.bean.User            System.out.println(clazz.getSimpleName());  //获的类名：User            //获取属性信息//          Field[] fields = clazz.getFields(); //只能获得public的field            Field[] fields = clazz.getDeclaredFields();//获得所有的field            Field f = clazz.getDeclaredField("uname");            System.out.println(fields.length);            for(Field temp:fields){                System.out.println("属性："+temp);            }            //获取方法信息            Method[] methods = clazz.getDeclaredMethods();            Method m01 = clazz.getDeclaredMethod("getUname", null);            //如果方法有参，则必须传递参数类型对应的class对象            Method m02 = clazz.getDeclaredMethod("setUname", String.class);             for(Method m:methods){                System.out.println("方法："+m);            }            //获得构造器信息            Constructor[] constructors = clazz.getDeclaredConstructors();            Constructor c = clazz.getDeclaredConstructor(int.class,int.class,String.class);            System.out.println("获得构造器："+c);            for(Constructor temp:constructors){                System.out.println("构造器："+temp);            }        } catch (Exception e) {            e.printStackTrace();        }    }}

//测试2：public class Demo03 {    public static void main(String[] args) {        String path = "com.bjsxt.test.bean.User";        try {            Class<User> clazz = (Class<User>) Class.forName(path);            //通过反射API调用构造方法，构造对象            User u = clazz.newInstance();   //其实是调用了User的无参构造方法            System.out.println(u);            Constructor<User> c = clazz.getDeclaredConstructor(int.class,int.class,String.class);            User u2 = c.newInstance(1001,18,"高淇二");            System.out.println(u2.getUname());            //通过反射API调用普通方法            User u3 = clazz.newInstance();            Method method = clazz.getDeclaredMethod("setUname", String.class);            method.invoke(u3, "高淇三");   //u3.setUname("高淇三");            System.out.println(u3.getUname());            //通过反射API操作属性            User u4 = clazz.newInstance();            Field f = clazz.getDeclaredField("uname");            f.setAccessible(true); //这个属性不需要做安全检查了，可以直接访问            f.set(u4, "高淇四");       //通过反射直接写属性            System.out.println(u4.getUname());  //通过反射直接读属性的值            System.out.println(f.get(u4));        } catch (Exception e) {            e.printStackTrace();        }    }}

四，反射操作泛型

/** * 通过反射获取泛型信息 * */public class Demo04 {       public void test01(Map<String,User> map,List<User> list){        System.out.println("Demo04.test01()");    }       public Map<Integer,User> test02(){        System.out.println("Demo04.test02()");        return null;    }       public static void main(String[] args) {        try {                       //获得指定方法参数泛型信息            Method m = Demo04.class.getMethod("test01", Map.class,List.class);            Type[] t = m.getGenericParameterTypes();            for (Type paramType : t) {                System.out.println("#"+paramType);                if(paramType instanceof ParameterizedType){                    Type[] genericTypes = ((ParameterizedType) paramType).getActualTypeArguments();                    for (Type genericType : genericTypes) {                        System.out.println("泛型类型："+genericType);                    }                }            }                       //获得指定方法返回值泛型信息            Method m2 = Demo04.class.getMethod("test02", null);            Type returnType = m2.getGenericReturnType();            if(returnType instanceof ParameterizedType){                    Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();                    for (Type genericType : genericTypes) {                        System.out.println("返回值，泛型类型："+genericType);                    }                               }               } catch (Exception e) {            e.printStackTrace();        }       }}

五，反射操作注解

/** * 通过反射获取注解信息 * */public class Demo05 {    public static void main(String[] args) {        try {            Class clazz = Class.forName("com.bjsxt.test.annotation.SxtStudent");                        //获得类的所有有效注解            Annotation[] annotations=clazz.getAnnotations();            for (Annotation a : annotations) {                System.out.println(a);            }            //获得类的指定的注解            SxtTable st = (SxtTable) clazz.getAnnotation(SxtTable.class);            System.out.println(st.value());            //获得类的属性的注解            Field f = clazz.getDeclaredField("studentName");            SxtField sxtField = f.getAnnotation(SxtField.class);            System.out.println(sxtField.columnName()+"--"+sxtField.type()+"--"+sxtField.length());            //根据获得的表名、字段的信息，拼出DDL语句，然后，使用JDBC执行这个SQL，在数据库中生成相关的表        } catch (Exception e) {            e.printStackTrace();        }    }}

//操作注解的代码如下import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target(value={ElementType.FIELD})@Retention(RetentionPolicy.RUNTIME)public @interface SxtField {    String columnName();    String type();    int length();}@SxtTable("tb_student")public class SxtStudent {    @SxtField(columnName="id",type="int",length=10)    private int id;    @SxtField(columnName="sname",type="varchar",length=10)    private String studentName;    @SxtField(columnName="age",type="int",length=3)    private int age;        public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }    public String getStudentName() {        return studentName;    }    public void setStudentName(String studentName) {        this.studentName = studentName;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target(value={ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)public @interface SxtTable {    String value();}