Java 反射机制初步了解

反射机制

        指的是可以于运行时加载、探知、使用编译期间完全未知的类。

        程序在运行状态中，可以动态加载一个只有名称的类，对于任意一个 已加载的类，都能够知道这个类的所有属性和方法；对于任意一个对 象，都能够调用它的任意一个方法和属性：

Class c = Class.forName("Path")

        加载完类之后，在堆内存中，就产生了一个Class类型的对象（一个类只有一个Class 对象），这个对象就包含了完整的类的结构信息，我们可以通过这个对象看到类的结构，这个对象就像一面镜子。所以，我们形象的称之为：反射。

常见用法：

• 动态构造类的反射对象

/*
   测试各种类型对应的java.lang.Class对象的获取方式
 */
@SuppressWarnings("all")
public class Demo01 {

    public static void main(String[] args) {
        String path = "SAMPLE.反射机制.User";
        try {
            //一个类被加载后，JVM会创建一个对应该类的Class对象，类的整个结构信息会放到对应的Class对象中。
            //这个Class对象就像一面镜子一样，通过这面镜子我可以看到对应类的全部信息。
            Class clazz = Class.forName(path);
            //一个类只对应一个Class对象,都具有相同的哈希码
            Class clazz2 = Class.forName(path);
            System.out.println(clazz.hashCode());
            System.out.println(clazz2.hashCode());

            //相同类型为同一个对象
            Class strClazz = String.class;
            Class strClazz2 = "I'm msg".getClass();
            System.out.println(strClazz==strClazz2);

            int[] arr01 = new int[10];
            int[][] arr02 = new int[30][3];
            double[] arr04 = new double[10];
            System.out.println(arr01.getClass().hashCode());
            System.out.println(arr02.getClass().hashCode());
            System.out.println(arr04.getClass().hashCode());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• 动态获取类的信息（属性、方法、构造器）

import java.lang.reflect.*;
/*
   利用用反射获取类的信息(类的名字、属性、方法、构造器等)
 */
public class Demo02 {
    public static void main(String[] args) {
        String path = "SAMPLE.反射机制.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

            fields = clazz.getDeclaredFields();//获得所有的field

            Field f = clazz.getDeclaredField("uname");//按命名获取属性

            //获取方法信息
            Method[] methods = clazz.getDeclaredMethods();
            Method m01 = clazz.getDeclaredMethod("getUname", null);//按命名、形参获取方法

            Method m02 = clazz.getDeclaredMethod("setUname", String.class);//如果方法有参，则必须传递参数类型对应的class对象

            //获得构造器信息
            Constructor[] constructors = clazz.getDeclaredConstructors();

            Constructor c = clazz.getDeclaredConstructor(int.class,int.class,String.class);//按构造方法的形参获取

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• 动态调用类的任意方法、构造器、属性

import java.lang.reflect.*;
import SAMPLE.反射机制.User;
/*
   通过反射对对象进行动态的操作
 */
public class Demo03 {
    public static void main(String[] args) {
        String path = "SAMPLE.反射机制.User";
        try {
            Class<User> clazz = (Class<User>) Class.forName(path);

            //通过反射API调用构造方法，构造对象
            User u = clazz.newInstance();// 其实是调用了User的无参构造方法

            Constructor<User> c = clazz.getDeclaredConstructor(int.class,int.class,String.class);
            User u2 = c.newInstance(1001,18,"name1");
            System.out.println(u2.getUname());

            //通过反射API调用普通方法
            User u3 = clazz.newInstance();
            Method method = clazz.getDeclaredMethod("setUname", String.class);
            method.invoke(u3, "name3");// u3.setUname("name3");
            System.out.println(u3.getUname());

            //通过反射API操作属性
            User u4 = clazz.newInstance();
            Field f = clazz.getDeclaredField("uname");
            f.setAccessible(true); // 这个属性不需要做安全检查了，可以直接访问
            f.set(u4, "name4");	// 通过反射直接写属性
            System.out.println(u4.getUname());	//通过反射直接读属性的值
            System.out.println(f.get(u4));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

• 获取泛型信息

package SAMPLE.反射机制;
import java.lang.reflect.*;
import java.util.*;
/*
   通过反射获取泛型信息
 */
public class Demo04 {
    public void test1(Map<String,User> map,List<User> list){
        System.out.println("Demo04.test1()");
    }

    public Map<Integer,User> test2(){
        System.out.println("Demo04.test2()");
        return null;
    }

    public static void main(String[] args) {
        try {
            //获得指定方法参数泛型信息
            Method m = Demo04.class.getMethod("test1", 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();
                    System.out.println("形参的泛型为：");
                    for (Type genericType : genericTypes) {
                        System.out.println(genericType);
                    }
                }
            }
            System.out.println("----------------");
            //获得指定方法返回值的泛型信息
            Method m2 = Demo04.class.getMethod("test2", null);
            Type returnType = m2.getGenericReturnType();
            System.out.println("返回值类型为："+returnType);
            if(returnType instanceof ParameterizedType){
                Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();
                System.out.println("返回值的泛型为：");
                for (Type genericType : genericTypes) {
                    System.out.println(genericType);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• 获取注解

import java.lang.annotation.Annotation;
/*
   通过反射获取注解信息
 */
public class Demo05 {
    public static void main(String[] args) {

        try {
            Class clazz = Class.forName("");

            //获得类的所有有效注解
            Annotation[] annotations=clazz.getAnnotations();
            for (Annotation a : annotations) {
                System.out.println(a);
            }
            /*获得类的指定的注解
            注解名称 annotation = (注解名称) clazz.getAnnotation(注解名称.class);
            */

            /*获得类的属性的注解
            Field f = clazz.getDeclaredField("studentName");
            注解名称 annotation = f.getAnnotation(注解名称.class);
            */

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• 反射效率的比较

import java.lang.reflect.Method;
/*
   通过跳过安全检查，提高反射效率
   三种执行方法的效率差异比较
 */
public class Demo06 {

    public static void test01(){
        User u = new User();

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000L; i++) {
            u.getUname();
        }
        long endTime = System.currentTimeMillis();

        System.out.println("普通方法调用，执行10亿次，耗时："+(endTime-startTime)+"ms");
    }

    public static void test02() throws Exception{//需执行安全检查
        User u = new User();
        Class clazz = u.getClass();
        Method m = clazz.getDeclaredMethod("getUname", null);

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000L; i++) {
            m.invoke(u, null);
        }
        long endTime = System.currentTimeMillis();

        System.out.println("反射动态方法调用，执行10亿次，耗时："+(endTime-startTime)+"ms");
    }

    public static void test03() throws Exception{//不需要执行访问安全检查
        User u = new User();
        Class clazz = u.getClass();
        Method m = clazz.getDeclaredMethod("getUname", null);
        m.setAccessible(true);

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000L; i++) {
            m.invoke(u, null);
        }
        long endTime = System.currentTimeMillis();

        System.out.println("反射动态方法调用，跳过安全检查，执行10亿次，耗时："+(endTime-startTime)+"ms");
    }
    public static void main(String[] args) throws Exception {
        test01();// 2s
        test02();// 60s
        test03();// 15s
    }
}