Java反射详解

前言

在学习反射之前，我们先引出一个问题：
（1）根据配置文件re.properties指定信息，创建Cat对象并调用方法hi
classfullPath=com.hspedu.Cat
method=hi
（2）这样的需求在学习框架时特别多，即通过外部文件配置，在不修改源码的情况下，来控制程序，也符合
设计模式ocp原则(开闭原则：不修改源码，扩容功能)
（3）解决方法

①Cat类

public class Cat {
    private String name = "招财猫";
    public void hi(){
        System.out.println("hi"+name);
    } }
1
2
3
4
5

②re.properties文件

classfullPath=com.hsp.Cat
method=hi
1
2

③

public class ReflectionDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {

//     要求: 根据配置文件re.properties 指定信息，创建Cat对象并调用方法hi
/*        传统的方式 new 对象 --> 调用方法
       Cat cat = new Cat();
        cat.hi();
*/
//      1.使用Properties类，可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String classfullPath = properties.get("classfullPath").toString();
        String methodName = properties.get("method").toString();//classfullPath=com.hsp.Cat
        System.out.println("classfullPath=" + classfullPath);//method=hi
        System.out.println("method=" + methodName);
//      2.使用反射机制解决:
//        (1)加载类，返回Class类型的对象cls
        Class cls = Class.forName(classfullPath);//class com.hsp.Cat
//        (2)通过 cls 得到你加载的类 com.hspedu.Cat的对象实例
        Object o = cls.newInstance();//com.hsp.Cat@16d3586
        System.out.println("o的运行类型=" + o.getClass());//o的运行类型=class com.hsp.Cat
//        (3)通过 cls 得到你加载的类com.hsp.Cat的 methodName"hi" 的方法对象
//        即：在反射中,可以把方法视为对象(万物皆对象)
        Method method1 = cls.getMethod(methodName);//public void com.hsp.Cat.hi()
//        (4)通过method1 调用方法:即通过方法对象来实现调用方法
        method1.invoke(o);//传统方法:对象.方法();反射机制: 方法.invoke(对象)
    } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

（4）动态语言是什么：
（1）动态语言是指程序运行时，可以改变程序结构或变量类型。典型的语言有：Python、JavaScript
（2）C,C++,JAVA不是动态语言，但是JAVA有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。

1.反射机制

（1）反射机制指的是可以在运行时加载、探知、使用编译期间完全未知的类。
（2）反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息(比如成员变量，
构造器，成员方法等等),并能操作对象的属性及方法。反射在设计模式和框架底层都会用到
（3）一个类被加载以后，JVM在堆中就产生了一个Class类型的对象(一个类只有一个Class对象)，这个对象
包含了类的完整结构信息。通过这个对象得到类的结构。这个Class对象就像一面镜子，透过这个镜子
可以看到类的结构。所以，形象的称为:反射

1.1反射机制原理示意图

（1）Class也是一个类
（2）javac会得到 .class字节码文件
（3）在运行阶段前会经历加载阶段(创建对象前会先经过类加载器进行加载)

1.2反射机制可以完成什么？

（1）在运行时判断任意一个对象所属的类
（2）在运行时构造任意一个类的对象
（3）在运行时得到任意一个类所具有的的成员变量和方法
（4）在运行时调用任意一个对象的成员变量和方法
（5）生成动态代理

1.3 反射的优缺点

（1）优点：可以动态的创建和使用对象(也是框架底层核心)，使用灵活，没有反射机制，框架技术就失去了底层支撑
（2）缺点：使用反射基本是解释执行，对执行速度有影响

1.4 反射调优

（1）Method、Field和Constructor对象都有setAccessible()方法
（2）setAccessible作用是启动和禁用访问安全检查的开关
（3）参数为true表示反射的对象在使用时取消访问检查，提高反射的效率；参数值为false则表示反射的对象执行访问检查

2. 反射相关的主要类

2.1 java.lang.Class类

2.1.1 Class类基本介绍

（1）Class也是类，因此也继承Object类
（2）Class类对象不是new出来的，而是系统创建的(通过类加载器ClassLoader的loadClass方法)

/* ClassLoader 类(注意：new对象最终也是通过 ClassLoader 类加载的)
public Class loadClass(String name) throws ClassNotFoundException {
		return loadClass(name, false);
}
*/    
1
2
3
4
5

（3）对于某个类的Class对象，在内存中只有一份，因此类只加载一次
（4）每个类的实例都会记得自己是由哪个Class实例所生成的
（5）通过Class对象可以完整地得到一个类的完整结构，通过一系列API可以看
（6）Class对象是存放在堆当中的
（7）类的字节码二进制数据，是存放在方法区的，有的地方称为类的元数据(包括 方法代码，变量名，方法名，访问权限等等)

2.1.2 Class类的常用方法

（1）获取修饰符,以int形式返回
getModifiers()
（2）获取类的名字
①getName：获取全类名(包名+类名)
②getSimpleName：获取简单类名
Class对象表示某个类加载后在堆中的对象
（3）获取属性信息
①getFields：获取所有public修饰的属性，包含本类以及父类的
②getDeclaredFields：获取本类中所有属性
（4）获取方法信息
①getMethods：获取所有public修饰的方法，包含本类以及父类的
②getDeclaredMethods：获取本类中的所有方法
（5）获取父类
getSuperclass
（6）接口
getInterfaces
（7）获取构造器信息
①getConstructors：获取本类所有public修饰的构造器
②getDeclaredConstructors：获取本类中的所有构造器
（8）其他
①getPackage：以Package形式返回 包信息
②getAnnotations：以Annotation[]形式返回注解信息
③getClassLoader:返回该类的类加载器
④newInstance：创建对象实例

代码示例如下：

public class Car {
    public String brand = "宝马";
    public  int price = 50000;
    public String color = "白色";
//	toString方法
1
2
3
4
5

public class ReflectionDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        String classAllPath="com.reflect.Car";
//1.获取Car类 对应的 Class 对象
//         表示不确定的Java类型
        Class<?> cls = Class.forName(classAllPath);
//        2.输出 cls
        System.out.println(cls);//显示cls对象，是哪个类的Class对象;  class com.hsp.Car
        System.out.println(cls.getClass());//输出cls运行类型;class java.lang.Class
//        3.得到包名
        System.out.println(cls.getPackage().getName());//包名
//        4.得到全类名
        System.out.println(cls.getName());
//        5.通过 cls 创建对象实例
        Car car =(Car) cls.newInstance();
        System.out.println(car);//car.toString
//        6.通过反射获取属性 brand
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));//宝马
//        7.通过反射给属性赋值
        brand.set(car,"奔驰");
        System.out.println(brand.get(car));//奔驰
//        8.得到所有的属性
        Field[] fields = cls.getFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        } } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

2.1.3 获取 Class 类对象

（1）Class.forName(“全类名”)
①前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，
可能抛出ClassNotFoundException，实例 Class cls = Class.forName(“com.hsp.Cat”);
②应用场景：多用于配置文件，读取类全路径，加载类
（2）类名.class
①前提：若已知具体的类，通过类的class 获取，该方式 最为安全可靠，程序性能最高。
②应用场景：多用于参数传递，比如通过反射得到对应构造器对象
（3）对象.getClass
①前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象，实例：
Class clazz = 对象.getClass(); // 运行类型
②应用场景：通过创建好的对象，获取Class对象
（4）其他方式
ClassLoader cl = 对象.getClass().getClassLoader();
Class clazz4 = cl.loadClass(“类的全类名”);
（5）基本数据(int,char,boolean,float,double,byte,long,short)按如下方式得到Class类对象
Class cls = 基本数据类型.class
（6）基本数据类型对应的包装类，可以通过 .TYPE 得到Class类对象
Class cls = 包装类.TYPE

public class ReflectionDemo4 {
    public static void main(String[] args) throws ClassNotFoundException {
//        1.Class.forName
        Class cls1 = Class.forName("com.reflection.Car");
//        2.类名.class,应用场景: 用于参数传递
        Class cls2 = Car.class;
//        3.对象.getClass(),应用场景，有对象实例
        Car car = new Car();
        Class cls3 = car.getClass();
//        4.通过类加载器来获取到类的Class对象
//       (1)先得到类加载器 car
        ClassLoader classLoader = car.getClass().getClassLoader();
//        (2)通过类加载器得到Class对象
        Class cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);
//        cls1,cls2,cls3,cls4 其实是同一个对象
     
//    5.基本数据(int,char,boolean,float,double,byte,long,short)按如下方式得到Class类对象
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booleanClass = boolean.class;
        System.out.println(integerClass);//int
//        6.基本数据类型对应的包装类，可以通过 .TYPE 得到 Class 类对象
        Class<Integer> type1 = Integer.TYPE;
        Class<Character> type2 = Character.TYPE;
        System.out.println(type1); //int
        System.out.println(integerClass.hashCode()); //22307196
        System.out.println(type1.hashCode()); //22307196
    } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2.1.4 哪些类型有Class对象

（1）外部类，成员内部类，静态内部类，局部内部类，匿名内部类
（2）interface：接口
（3）数组
（4）enum：枚举
（5）annotation：注解
（6）基本数据类型
（7）void

2.2 java.lang.reflect.Field类

Field代表类的成员变量

2.3 java.lang.reflect.Method类

Method代表类的方法,Method对象表示某个类的方法

2.4 java.lang.reflect.Constructor类

Constructor代表类的构造方法，Constructor对象表示构造器

3.类加载

3.1 基本说明

反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载
（1）静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
（2）动态加载：运行时加载需要的类，如果运行时不用该类，既使不存在该类，也不报错

3.2 类加载时机

（1）当创建对象时(new) //静态加载
（2）当子类被加载时，父类也加载 // 静态加载
（3）调用类中的静态成员时 // 静态加载
（4）通过反射 // 动态加载

3.3 类加载过程

（1）加载阶段：
JVM在该阶段的主要目的是将字节码从不同的数据源(可能是class文件、也可能是jar包，甚至网络)转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象

（2）连接阶段
1）验证：
①目的是为了确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
②包括：文件格式验证(是否已魔数0xcafebabe开头)、元数据验证、字节码验证和符号引用验证
③可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间
2）准备：
JVM 会在该阶段对静态变量分配内存并默认初始化(对应数据类型的默认初始值，如0、0L、null、false等)。这些变量所使用的内存都将在方法区中进行分配。

3）解析：
虚拟机将常量池内的符号引用替换为直接引用的过程

（3）Initialization（初始化)
①到初始化阶段，才真正开始执行类中定义的 Java 程序代码，此阶段是执行() 方法的过程。
②()方法是由编译器按语句在源文件中出现的顺序，一次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。
③虚拟机会保证一个类的()方法在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕

public class ClassLoad03 {
    public static void main(String[] args) {
//        1.加载 B 类,并生成B的class对象
//        2.连接 num = 0
//        3.初始化阶段
//        依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句,并合并
/*
        clinit() {
            System.out.println("B 静态代码块被执行");
            num = 300;//会被合并为100
            num = 100;
}
           合并: num = 100
*/
        //看看加载类的时候， 是有同步机制控制
/*
protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException{
//正因为有这个机制， 才能保证某个类在内存中, 只有一份 Class 对象
synchronized (getClassLoadingLock(name)) {
//...
   } }
*/
        B b = new B();//类加载
        System.out.println(B.num);//100,如果直接使用类的属性，也会导致类的加载
    } }
class B {
    static {
        System.out.println("B 静态代码块被执行了");
        num = 300;
    }
    static int num = 100;
    public B() {//构造器
        System.out.println("B() 构造器被执行了");
    } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

5. 通过反射创建对象

（1）创建对象的方法：
①调用父类中的public修饰的无参构造器
②调用类中的指定构造器
（2）Class类的相关方法：
①newInstance：调用类中的无参构造器，获取对应类的对象
②getConstructor(Class…clazz)：根据参数列表，获取对应的public构造器对象
③getDeclaredConstructor(Class…clazz)：根据参数列表，获取对应的所有构造器对象
（3）Constructor类的相关方法
①setAccessible：暴破【暴力破解】, 使用反射可以访问 private 构造器/方法/属性, 在反射面前，都是纸老虎
②newInstance(Object…obj)：根据指定的构造方法创建对象

public class ReflecCreateInstance {
    public static void main(String[] args) throws Exception {
//        1.先获得 User 类的Class对象
        Class<?> userClass = Class.forName("com.hsp.reflection.User");
//        2.通过public的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);
//        3.通过public 的有参构造器创建实例
//        3.1 先得到对应构造器
        Constructor<?> constructor = userClass.getConstructor(String.class);
//        3.2 创建实例,并传入实参
        Object o1 = constructor.newInstance("yqd");
        System.out.println(o1);
//        4.通过非public 的有参构造器创建实例
//        4.1 得到 private 的构造对象
        Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
//        4.2 创建实例
//        暴破【暴力破解】，使用反射可以访问 private 构造器/方法/属性
        constructor1.setAccessible(true);
        Object user2 = constructor1.newInstance(100, "张无忌");
        System.out.println(user2);
    } }
class User {//User类
    private int age = 10;
    private String name = "Java";
    public User(){//无参 public
    }
    public User(String name){//public的有参构造器
        this.name = name;
    }
    private User(int age,String name){//private 有参构造器
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

6.通过反射访问类中的成员

6.1 访问属性

public class ReflecAccessProperty {
    public static void main(String[] args) throws Exception {
//      1.得到 Student 类对应的 Class 对象
        Class<?> stuClass = Class.forName("com.hsp.reflection.Student");
//        2.创建对象
        Object o = stuClass.newInstance();
        System.out.println(o.getClass());// o 的运行类型是Student
//        3.使用反射得到 age 属性对象
        Field age = stuClass.getField("age");
        age.set(o, 88);//通过反射来操作属性
        System.out.println(o);
        System.out.println(age.get(o));//返回 age 属性的值
//        4.使用反射操作 name 属性
        Field name = stuClass.getDeclaredField("name");
//        对name进行暴破，可以操作 private 属性
        name.setAccessible(true);
//        name.set(o,"张三丰");
        name.set(null, "张三丰");//因为name 是 static 属性，因此 o 也可以写成null
        System.out.println(o);
        System.out.println(name.get(o));//获取属性值
        System.out.println(name.get(null));//获取属性值，要求name是static
    } }
class Student {
    public int age;
    private static String name;
    public Student() { // 构造器
    }
    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

6.2 访问方法

public class ReflecAccessMethod {
    public static void main(String[] args) throws Exception {
//        1.得到Boss类对应的Class对象
        Class<?> bossClass = Class.forName("com.hsp.reflection.Boss");
//        2.创建对象
        Object o = bossClass.newInstance();
//        3.调用 public 的hi方法
//        3.1 得到hi方法对象
        Method hi = bossClass.getDeclaredMethod("hi", String.class);
//        3.2 调用
        hi.invoke(o,"我在学Java");
//        4.调用 private static 方法
//        4.1 得到 say 方法对象
        Method say = bossClass.getDeclaredMethod("say", int.class, String.class, char.class);
//        4.2 因为 say 方法是private，所以需要暴破
        say.setAccessible(true);
        System.out.println(say.invoke(o,100,"张三",'男'));
//        4.3 因为say方法是static的，还可以这样调用，可以传入 null
        System.out.println(say.invoke(null,200,"李四",'女'));
//        5.在反射中，如果方法有返回值，统一返回Objec，但是它的运行类型和方法定义的返回类型一致
        Object reVal = say.invoke(null, 300, "王五", '男');
        System.out.println("reVal的运行类型="+reVal.getClass());
    } }
class Monster {
}
class Boss {
    public int age;
    private static String name;
    public Boss() {//构造器
    }
    public Monster m1() {
        return new Monster();
    }
    private static String say(int n, String s, char c) {//静态方法
        return n + " " + s + " " + c;
    }
    public void hi(String s) {//普通 public 方法
        System.out.println("hi" + s);
    } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

7.反射操作泛型

（1）Java采用泛型擦除的机制来引入泛型。Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换的麻烦。
但是，一旦编译完成，所有的和泛型有关的类型将全部擦除
（2）为了通过反射操作这些类型以迎合实际开发的需要，Java新增了ParameterizedType,GenericArrayType,TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。

8.反射操作注解

9.动态编译

9.1 动态编译的应用场景

（1）可以做一个浏览器端编写java代码，上传服务器编译和运行的在线测评系统
（2）服务器动态加载某些类文件进行编译

9.2 动态编译的两种做法

（1）通过Runtime调用javac，启动新的进程去操作
Runtime run = Runtime.getRuntime();
Process process = run.exec(“javac -cp d:/myjava/ HelloWorld.java”);
（2）通过JavaCompiler动态编译

9.3 动态运行编译好的类