需求和快速入门

• 目的：通过外部文件配置，不修改源码的情况下，来控制程序（也符合设计模式的开闭原则，不修改源码拓展程序）

• 步骤（假设配置文件配置的类名字是classname，里面有一个方法，名字为methodName）

  • 加载类，返回一个Class类型的对象（是一个类，类名叫Class）

    Class cls = Class.forName(classname)

  • 通过 cls 得到加载的类的对象实例

    Object obj = cls.newInstance()

  • 通过 cls 得到加载的类的 methodName“hi” 的方法对象（Method 类型的对象），即在反射中，可以把方法视为对象（万物皆对象）

    Method method1 = cls.gerMethod(methodName)

  • 通过 method1 调用方法，即通过方法对象来实现调用方法

    传统方法：对象.方法（）

    反射机制：方法.invoke（对象）

    method1.invoke（obj）

  • 注：可以向下转型obj，但是没有必要，因为要用反射的机制来调用方法，反射才有价值。如果将obj向下转型，还是只能通过方法名来调用方法，这样如果我想调用另一个方法，只能通过修改方法名->修改源码的方式。而利用反射机制，只用修改外部文件（配置文件），将methodName 修改

反射原理

• 反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息(比如成员变量，构造器，成员方法等等)，并能操作对象的属性及方法。反射在设计模式和框架底层都会用到
• 加载完类之后，在堆中就产生了一个Class类型的对象(一个类只有一个Class对象)，这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为反射

反射相关主要类

• java.lang.Class:代表一个类， Class对象表示某个类加载后在堆中的对象
• java.lang.reflect.Method: 代表类的方法, Method对象表示某个类的方法
• java.lang.reflect.Field: 代表类的成员变量,Field对象表示某个类的成员变量
• java.ang.reflect.Constructor: 代表类的构造方法,Constructor对象表示
  构造器

反射的优点和缺点及其优化

• 优点: 可以动态的创建和使用对象(也是框架底层核心),使用灵活,没有反射机制，框架技术就失去底层支撑。
• 缺点: 使用反射基本是解释执行,对执行速度有影响
• 反射调用优化-关闭访问检查
  1. Method和Field、Constructor对象都有setAccessible()方法
  2. setAccessible作用是启动和禁用访问安全检查的开关
  3. 参数值为true表示反射的对象在使用时取消访问检查，提高反射的效率。参数值为false则表示反射的对象执行访问检查

Class类

• Class也是类，因此也继承Object类
• Class类对象不是new出来的，而是系统创建的
• 对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
• 每个类的实例都会记得自己是由哪个 Class 实例所生成
• 通过Class对象可以完整地得到一个类的完整结构，通过一系列API调用类的各部分
• Class对象是存放在堆的
• 类的字节码二进制数据，是放在方法区的， 有的地方称为类的元数据(包括 方法代码，变量名，方法名，访问权限等等)

Class类常用方法

方法名	功能说明
static Class forName(String name)	返回指定类名 name 的 Class 对象
Object newInstance()	调用缺省构造函数，返回该Class对象的一个实例
getName(）	返回此Class对象所表示的实体(类、接口、数组类、基本类型等)名称
Class[ ]getlnterfaces()	获取当前Class对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Class getSuperclass()	返回表示此Class所表示的实体的超类的Class
Constructor[ ] getConstructors()	返回一个包含某些Constructor对象的数组
Field[ ] getDeclaredFields()	返回Field对象（**成员属性）**的一个数组（注：不能直接获取私有属性）
Method getMethod (String name,class … paramTypes)	返回一个Method对象，此对象的形参类型为paramType

• 假设 cls 是某个对象对应的 Class 对象，则直接输出 cls 显示cls对象是哪个类的Class对象。输出cls.getClass（）得到cls的运行类型 java.lang.Class

获取Class类对象的六种方式

• 由于一个类只会加载一次，所以他们获取的都是同一个类对象（hashCode相同）

1. 前提:已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

   实例:Class cls1 Class.forName( "iava.lang.Cat” )；
   应用场景:多用于配置文件,读取类全路径，加载类

2. 前提:若已知具体的类，通过类的class 获取，该方式最为安全可靠，程序性能最高

   实例:Class cls2 = Cat.class;
   应用场景:多用于参数传递，比如通过反射得到对应构造器对象

3. Class class = 对象.getClass(); 其实就是得到它的运行类型
   应用场景: 通过创建好的对象，获取Class对象
   前提:已知某个类的实例，调用该实例的getClass()方法获取Class对象

4. 其他方式
   ClassLoader cls = 对象.getClass().getClassLoader();
Class class = cls.loadClass(“类的全类名”);

5. 基本数据类型(int, char,boolean,float,double,byte,long,short)按如下方式得到Class类
   Class cls = 基本数据类型.class

6. 基本数据类型对应的包装类，可以通过.TYPE 得到Class类对象
   Class cls = 包装类.TYPE

有Class对象的类型

• 外部类，成员内部类，静态内部类，局部内部类，匿名内部类
• interface:接口
• 数组
• enum:枚举
• annotation:注解
• 基本数据类型
• void

类加载

动态加载和静态加载

• 反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载。

• 静态加载:编译时加载相关的类，如果没有则报错，依赖性太强

• 动态加载:运行时加载需要的类，如果运行时不用该类，即使不存在该类，也不报错，降低了依赖性

类加载时机

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

类加载流程图

类加载五个阶段

加载阶段

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

连接阶段-验证

• 目的是为了确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
• 包括:文件格式验证(是否以魔数 oxcafebabe开头)、元数据验证、字节码验证和符号引用验证
• 可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施,，缩短虚拟机类加载的时间

连接阶段-准备

• JVM 会在该阶段对静态变量，分配内存并默认初始化(对应数据类型的默认初始值，（如 0、0L、null、false 等)。这些变量所使用的内存都将在方法区中进行分配

class A{
//属性-成员变量-字段
//分析类加载的链接阶段-准备 属性是如何处理
//1.n1 是实例属性，不是静态变量，因此在准备阶段，是不会分配内存
//2.n2 是静态变量，分配内存n2是默认初始化 0,而不是20
//3.n3 是static final 是常量，他和静态变量不一样，因为一旦赋值就不变 n3 = 30
public int n1 = 10;
public static int n2 = 20;
int n3 = 3;
public static final int n3 = 30;
}

连接阶段-解析

• 虚拟机将常量池内的符号引用替换为直接引用的过程

假设有一个类 MyClass，它有一个字段 field 和一个方法 method。在类文件中，这两个成员都会以符号引用的形式存在，例如：

• 字段的符号引用：MyClass/field
• 方法的符号引用：MyClass/method

当虚拟机加载 MyClass 并解析这些符号引用时，它会执行以下步骤：

1. 加载：虚拟机加载 MyClass 类文件，并创建一个运行时常量池。
2. 解析字段：虚拟机查找 MyClass 的字段 field，并计算出其在内存中的实际地址。
3. 解析方法：虚拟机查找 MyClass 的方法 method，并计算出其在内存中的入口点。

最终，虚拟机会用实际的内存地址或偏移量来替换符号引用，使得字节码指令可以直接访问这些字段或调用这些方法。

总结

简单来说，符号引用是类文件中的抽象表示，而直接引用是虚拟机内部使用的具体引用。虚拟机在加载类时会解析这些符号引用，以便程序能够正确地访问类的方法和字段。这一过程保证了程序的可移植性和安全性。

Initialization(初始化)

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

通过反射获取类的结构信息

java.lang.Class类

1. getName:获取全类名
2. getSimpleName:获取简单类名
3. getFields:获取所有public修饰的属性，包含本类以及父类的（父类的父类等等也可以，下面同）
4. getDeclaredFields:获取本类中所有属性
5. getMethods:获取所有public修饰的方法，包含本类以及父类的
6. getDeclaredMethods:获取本类中所有方法
7. getConstructors: 获取所有public修饰的构造器，包含本类，不包含父类
8. getDeclaredConstructors:获取本类中所有构造器
9. getPackage:以Package形式返回包信息
10. getsuperClass:以Class形式返回父类信息
11. getlnterfaces:以Class[]形式返回接口信息
12. getAnnotations:以Annotation[] 形式返回注解信息

java.lang.reflect.Field 类（属性相关）

1. getModifiers:以int形式返回修饰符

   [说明: 默认修饰符 是0， public 是1，private是2，protected 是4，static是8，final是16]

   若为 public static 之类，则两个int值相加

2. getType:以Class形式返回类型

3. getName:返回属性名

java.lang.reflect.Method类（方法相关）

1. getModifiers:以int形式返回修饰符
   [说明: 默认修饰符 是0， public 是1，private 是2，protected 是 4, static是8，final是16]
2. getReturnType:以Class形式获取 返回类型
3. getName:返回方法名
4. getParameterTypes:以 Class[ ] 返回参数类型数组，无参则不返回

java.lang.reflect.Constructor类（构造器相关）

1. getModifiers: 以int形式返回修饰符

   [说明: 默认修饰符 是0， public 是1，private 是2，protected 是 4, static是8，final是16]

2. getName:返回构造器名(全类名)

3. getParameterTypes:以Class[ ] 返回参数类型数组

反射暴破及实例

总结：Decalared获取私有内容的对象，暴破setAccessible使用私有内容的对象

可以暴破：构造器、属性、方法的对象，类的（Class）对象不能暴破

setAccessible 是 Java 反射 API 中的一个方法，它用于控制反射对象（如类、构造函数、方法和字段）的访问权限。通过调用 setAccessible 方法，可以改变 Java 语言访问控制的限制，允许程序访问原本不可见的私有成员。

作用

setAccessible 的主要作用如下：

1. 访问私有成员：通过设置 Accessible 属性为 true，可以使程序能够访问类的私有成员，如私有字段或私有方法。
2. 绕过访问控制：这使得程序能够在运行时动态地访问和修改类的私有成员，即使这些成员在源代码中被声明为 private、protected 或包私有。

创建对象

• 方式一：调用类中的public修饰的无参构造器
• 方式二: 调用类中的指定构造器
• Class类相关方法
  • newlnstance :调用类中的无参构造器，获取对应类的对象
  • getConstructor(Class…clazz):根据参数列表，获取对应的public构造器对象
  • getDecalaredConstructor(Class…clazz):根据参数列表，获取对应的所有构造器对象
• Constructor类相关方法
  • setAccessible:暴破
  • newlnstance(Object…obj):调用构造器

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

        //1. 先获取到User类的Class对象
        Class<?> userClass = Class.forName("com.hspedu.reflection.User");
        //2. 通过public的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);
        //3. 通过public的有参构造器创建实例
        /*
            constructor 对象就是
            public User(String name) {//public的有参构造器
                this.name = name;
            }
         */
        //3.1 先得到对应构造器
        Constructor<?> constructor = userClass.getConstructor(String.class);
        //3.2 创建实例，并传入实参
        Object hsp = constructor.newInstance("hsp");
        System.out.println("hsp=" + hsp);
        //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=" + user2);
    }
}

class User { //User类
    private int age = 10;
    private String name = "韩顺平教育";

    public User() {//无参 public
    }

    public User(String name) {//public的有参构造器
        this.name = name;
    }

    private User(int age, String name) {//private 有参构造器
        this.age = age;
        this.name = name;
    }

    public String toString() {
        return "User [age=" + age + ", name=" + name + "]";
    }
}

访问属性

• 根据属性名获取Field对象（Declared可以获取私有属性）
  Field f= clazz对象.getDeclaredField(属性名);
• 暴破: f.setAccesgible(true); //f 是Field
• 访问
  f.set(o,值);
syso(f.get(o));
  如果是静态属性，则set和get中的参数o，可以写成null

public class ReflecAccessProperty {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {

        //1. 得到Student类对应的 Class对象
        Class<?> stuClass = Class.forName("com.hspedu.reflection.Student");
        //2. 创建对象
        Object o = stuClass.newInstance();//o 的运行类型就是Student
        System.out.println(o.getClass());//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 + "]";
    }
}

访问方法

• 根据方法名和参数列表获取Method方法对象:

  Method m=clazz.getDeclaredMethod(方法名，XX.class);//得到本类的所有方法

• 获取对象:Object o=clazz.newlnstance();

• 暴破:m.setAccessible(true);

• 访问:Object returnValue = m.invoke(o,实参列表);

• 注意:如果是静态方法，则invoke的参数o，可以写成null

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

        //1. 得到Boss类对应的Class对象
        Class<?> bossCls = Class.forName("com.hspedu.reflection.Boss");
        //2. 创建对象
        Object o = bossCls.newInstance();
        //3. 调用public的hi方法
        //Method hi = bossCls.getMethod("hi", String.class);//OK
        //3.1 得到hi方法对象
        Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK
        //3.2 调用
        hi.invoke(o, "韩顺平教育~");

        //4. 调用private static 方法
        //4.1 得到 say 方法对象
        Method say = bossCls.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. 在反射中，如果方法有返回值，统一返回Object , 但是他运行类型和方法定义的返回类型一致
        Object reVal = say.invoke(null, 300, "王五", '男');
        System.out.println("reVal 的运行类型=" + reVal.getClass());//String


        //在演示一个返回的案例
        Method m1 = bossCls.getDeclaredMethod("m1");
        Object reVal2 = m1.invoke(o);
        System.out.println("reVal2的运行类型=" + reVal2.getClass());//Monster


    }
}

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