[Java知识库]Java中的反射

1.引出反射

• 根据配置文件的指定信息，创建Cat对象并调用方法hello

  # rc.properties
  classfullpath=com.atguigu.Cat
  method=hello
  # Cat.java
  public class Cat {
      private String name = "cat1";
      public void hello(){
          System.out.println("hello");
      }
  }
  

  • 使用传统方式：

  # 测试代码
  Properties properties = new Properties();
  properties.load(new FileInputStream("src/rc.properties"));
  String classfullpath = properties.get("classfullpath").toString();
  String methodName = properties.get("method").toString();
  // 直接new创建对象肯定是错误的，classfullpath只是一个字符串而已
  // new classfullpath()
  

  • 使用反射：

  Properties properties = new Properties();
  properties.load(new FileInputStream("src/rc.properties"));
  String classfullpath = properties.get("classfullpath").toString();
  String methodName = properties.get("method").toString();
  
  // 1.加载类(Class是一个名字为Class的类)
  Class cls = Class.forName(classfullpath);
  // 2.通过cls得到加载类的对象实例
  Object o = cls.newInstance();
  System.out.println(o.getClass());  // class com.atguigu.Cat
  // 3.通过cls得到加载类的方法(反射中可以把方法视为对象,Method为名字为Method的类)
  Method method = cls.getMethod(methodName);
  // 4.通过方法对象method调用方法
  method.invoke(o);  // 传统方式是对象.方法(),而在反射机制中是方法对象.invoke(类对象)
  

• 如果此时Cat类中的方法从hello改为eat：

  • 传统方式需要把cat.hello()改为cat.eat()
  • 使用反射只需要把配置文件中的method=hello改为method=eat即可

  所以反射可以通过外部配置文件，在不修改源码的情况下控制程序，符合ocp原则

tips:

• ocp原则：不修改源码的基础上扩展功能

2.反射机制

• 允许程序在执行期借助Reflection API取得任何类的内部信息(如成员变量、构造器、成员方法等)，并且能操作对象的属性和方法
• 加载完类后，在堆中就产生一个Class类型的对象(一个类只有一个Class对象)，该对象包含了类的完整结构信息，通过该对象得到类的结构(该对象就像一面镜子，可以透过镜子看到类的结构)：

3.反射相关的类

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

Properties properties = new Properties();
properties.load(new FileInputStream("src/rc.properties"));
String classfullpath = properties.get("classfullpath").toString();
String methodName = properties.get("method").toString();

// 1.加载类(Class是一个名字为Class的类)
Class cls = Class.forName(classfullpath);
// 2.通过cls得到加载类的对象实例
Object o = cls.newInstance();
System.out.println(o.getClass());  // class com.atguigu.Cat
// 3.通过cls得到加载类的方法(反射中可以把方法视为对象,Method为名字为Method的类)
Method method = cls.getMethod(methodName);
// 4.通过方法对象method调用方法
method.invoke(o);  // 传统方式是对象.方法(),而在反射机制中是方法对象.invoke(类对象)
// 5.通过getField获取类的成员变量(Field对象表示某个类的某个成员变量)
// 注意:getField 不能得到私有的属性,会报错
Field nameField = cls.getField("name");
System.out.println(nameField.get(o));
// 6.通过getConstructor获取类的构造方法(Constructor对象表示构造器)
Constructor constructor = cls.getConstructor();  // ()中可以指定构造器参数类型, 返回无参构造器
System.out.println(constructor);  // public com.atguigu.Cat()
// 调用有参构造器
Constructor constructor2 = cls.getConstructor(String.class);
System.out.println(constructor2);  // public com.atguigu.Cat(java.lang.String)

4.反射的优点和缺点

• 优点：动态创建和使用对象(框架底层核心)，使用灵活
• 缺点：反射机制是解释执行，对执行速度有影响，为了提高执行速度，可以进行反射调用的优化-关闭访问检查：
  • Method和Field、Constructor对象都有setAccessible方法
  • setAccessible方法用于启动和禁用访问安全检查的开关：
    • 参数值为true表示反射的对象在使用时取消访问检查，提高反射的效率
    • 参数值为false表示反射的对象执行访问检查

public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
    m1();//传统 耗时=3ms
    m2();//反射 耗时=1476
    m3();//反射优化 耗时=985
}

//传统方法来调用hello
public static void m1() {
    Cat cat = new Cat();
    long start = System.currentTimeMillis();
    for (int i = 0; i < 900000000; i++) {
        cat.hello();
    }
    long end = System.currentTimeMillis();
    System.out.println("m1() 耗时=" + (end - start));
}
//反射机制调用方法hello
public static void m2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
    Class cls = Class.forName("com.atguigu.Cat");
    Object o = cls.newInstance();
    Method hello = cls.getMethod("hello");
    long start = System.currentTimeMillis();
    for (int i = 0; i < 900000000; i++) {
        hello.invoke(o);  // 反射调用方法
    }
    long end = System.currentTimeMillis();
    System.out.println("m2() 耗时=" + (end - start));
}
// 反射调用优化 + 关闭访问检查
public static void m3() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
    Class cls = Class.forName("com.atguigu.Cat");
    Object o = cls.newInstance();
    Method hello = cls.getMethod("hello");
    hello.setAccessible(true);  // 在反射调用方法时，取消访问检查
    long start = System.currentTimeMillis();
    for (int i = 0; i < 900000000; i++) {
        hello.invoke(o);//反射调用方法
    }
    long end = System.currentTimeMillis();
    System.out.println("m3() 耗时=" + (end - start));
}

5.Class类

5.1 概念

• Class类也是类：

• Class类对象不是new出来的，而是系统创建的(通过ClassLoader的loadClass方法)：

public Class<?> loadClass(String name) throws ClassNotFoundException {
    return loadClass(name, false);
}

• 对于某个类的Class类对象，在内存中只有一份，因为类只加载一次：

Class cls1 = Class.forName("com.atguigu.Cat");
Class cls2 = Class.forName("com.atguigu.Cat");
System.out.println(cls1 == cls2);  // true

• 每个类的实例会记得自己由哪个Class类的实例生成
• 通过Class类的对象可以完整得到一个类的完整结构
• Class类的对象是存放在堆的
• 类(指的是Cat类不是Class类)的字节码二进制数据(也称为类的元数据，包括变量名、方法名等)存放在方法区

tips:

• 如果某类已经通过传统方式new出来了一个对象，此时再去执行Class.forName方法就不会再次加载类，因为前面已经加载好了(传统方式加载类也是通过loadClass方法加载该类的Class类的对象)

5.2 常用方法

String classAllPath = "com.atguigu.Cat";
// 1.获取到 Cat 类 对应的 Class 对象
// <?> 表示不确定的Java类型
Class<?> cls = Class.forName(classAllPath);
// 2. 输出 cls
System.out.println(cls);  //显示 cls 对象, 是哪个类的 Class 对象 com.atguigu.Cat
System.out.println(cls.getClass());  //输出 cls 运行类型 java.lang.Class
//3. 得到包名
System.out.println(cls.getPackage().getName());  // com.atguigu
//4. 得到全类名
System.out.println(cls.getName());  // com.atguigu.Cat
//5. 通过 cls 创建对象实例
Cat cat = (Cat) cls.newInstance();
System.out.println(cat); 
//6. 通过反射获取属性
Field field = cls.getField("name");
System.out.println(field.get(cat));  // cat1
//7. 通过反射给属性赋值
field.set(cat, "cat2");
System.out.println(field.get(cat));
//8.得到所有的属性(字段)
System.out.println("=======所有的字段属性====");
Field[] fields = cls.getFields();
for (Field f : fields) {
    System.out.println(f.getName());  // name
}

5.3 获取Class类对象的不同方式

• 在代码编译阶段，使用Class.forName方法获取(多用于配置文件，通过文件读取类的全路径来加载类)：

//1. Class.forName
String classAllPath = "com.atguigu.Cat";  // 通过读取配置文件获取
Class<?> cls1 = Class.forName(classAllPath);
System.out.println(cls1);

• 在类的加载阶段，使用类.class获取(多用于参数传递)，该方式最为安全，性能最高:

//2. 类名.class , 应用场景: 用于参数传递(比如cls.getConstructor(String.class))
Class cls2 = Cat.class;
System.out.println(cls2);

• 在运行阶段(即已知类的实例)，使用对象.getClass获取：

//3. 对象.getClass(), 应用场景，有对象实例
Car car = new Car();
Class cls3 = car.getClass();
System.out.println(cls3);

• 通过类加载器获取：

Cat cat = new Cat();
String classAllPath = "com.atguigu.Cat"; //通过读取配置文件获取
//(1)先得到类加载器
ClassLoader classLoader = cat.getClass().getClassLoader();
//(2)通过类加载器得到 Class 对象
Class cls4 = classLoader.loadClass(classAllPath);
System.out.println(cls4);

• 基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到 Class 类对象：

Class<Integer> integerClass = int.class;
System.out.println(integerClass);  //int

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

Class<Integer> type1 = Integer.TYPE;
System.out.println(type1);  // int

tips：

• 上面代码中的integerClass和type1的hashCode是一致的，因为会自动进行拆箱和装箱
• 以下类型都是有Class对象的：

Class<String> cls1 = String.class;  //外部类
Class<Serializable> cls2 = Serializable.class;  //接口
Class<Integer[]> cls3 = Integer[].class;  //数组
Class<float[][]> cls4 = float[][].class;  //二维数组
Class<Deprecated> cls5 = Deprecated.class;  //注解
Class<Thread.State> cls6 = Thread.State.class;  //枚举
Class<Long> cls7 = long.class;  //基本数据类型
Class<Void> cls8 = void.class;  //void 数据类型
Class<Class> cls9 = Class.class;

6.类加载

6.1 类型

• 静态加载：编译时加载相关的类，如果没有就报错(依赖性太强)
  • 创建对象时(new)
  • 子类被加载时父类也加载
  • 调用类中的静态成员
• 动态加载：运行时加载需要的类，如果运行时不用该类，即使不存在也不会报错(降低依赖性)
  • 通过反射

// 由于输入的i可能是1，也可能是2，所以不能确定一定会使用到Cat类或Dog类，假如没有创建Cat类，case 1的代码会报错，但是没有Dog的话代码编译不会报错(如果输入的i值为2才会去动态加载Dog类，发现没有才报错)
int i = new Scanner(System.in).nextInt();
switch (i) {
    case 1:
        Cat cat = new Cat();  
        break;
    case 2:
        Class cls = Class.forName("com.psj.Dog");
        break;
}

6.2 类加载过程

6.2.1 类加载三个阶段

• 加载：将字节码从不同数据源(可能是class文件、jar包、网络等)转换为二进制字节流加载到内存，并生成一个代表该类的java.lang.Class类对象

• 连接阶段：

  • 验证：确保class文件的字节流包含的信息符合JVM的要求，包括文件格式验证、元数据验证、字节码验证和符合引用验证
  • 准备：JVM在该阶段对静态变量分配内存并默认初始化，变量使用的内存都将在方法区中分配

  //1. n1 是实例属性, 不是静态变量，因此在准备阶段，是不会分配内存
  //2. n2 是静态变量，分配内存n2是默认初始化0 ,而不是20(初始化阶段赋值20)
  //3. n3 是static final 是常量, 和静态变量不一样, 因为一旦赋值就不变 n3 = 30
  public int n1 = 10;
  public static int n2 = 20;
  public static final int n3 = 30
  

  • 解析：JVM将常量池内的符号引用替换为直接引用的过程

• 初始化：开始执行类中定义的Java代码(即执行方法的过程)

  • 方法是由编译器按语句在源文件中出现顺序依次自动收集类中所有的静态变量的赋值和静态代码块的语句，并进行合并
  • JVM保证一个类的方法能被正确加锁和同步(即多个线程同时初始化一个类，只有一个线程去执行该类的方法，保证某个类在内存中只有一份Class类对象)

tips:

• 可以通过使用-Xverify:none参数关闭大部分的类验证措施，缩短JVM类加载时间
• 类加载过程和实例无关

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

// 部分实例代码:
//得到 Class 对象
Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
//getDeclaredFields:获取本类中所有属性
//规定 说明: 默认修饰符 是 0 ， public 是 1 ，private 是 2 ，protected 是 4 , static 是 8 ，final 是 16
Field[] declaredFields = personCls.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("本类中所有属性=" + declaredField.getName())
...

7.1 java.lang.Class 类

7.2 java.lang.reflect.Field 类

7.3 java.lang.reflect.Method 类

7.4 : java.lang.reflect.Constructor 类

8.通过反射创建对象

Class<?> userClass = Class.forName("com.atguigu.User");
// 1. 通过 public 的无参构造器创建实例
Object o1 = userClass.newInstance();
System.out.println(o1);

// 2. 通过 public 的有参构造器创建实例
// 2.1 先得到对应构造器(相当于public User(String name){...} )
Constructor<?> constructor = userClass.getConstructor(String.class);
// 2.2 创建实例，并传入实参
Object o2 = constructor.newInstance("psj");
System.out.println(o2);

// 3. 通过非 public 的有参构造器创建实例
// 3.1 得到 private 的构造器对象
Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
// 3.2 创建实例
//**暴破【暴力破解】：使用反射可以访问 private 构造器/方法/属性
constructor1.setAccessible(true);
Object o3 = constructor1.newInstance(11, "psj");
System.out.println(o3);

//User 类
class 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 + "]";
    }
}

tips:

• 之前创建对象时是无法通过私有构造器创建的，而通过反射可以

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

# 访问属性
// 得到 Student 类对应的 Class 对象
Class<?> stuClass = Class.forName("com.atguigu.Student");
// 创建对象
Object o = stuClass.newInstance();//o 的运行类型就是 Student
System.out.println(o.getClass());//Student
//1. 使用反射得到 age 属性对象
Field age = stuClass.getField("age");
age.set(o, 88);  //通过反射来操作属性
System.out.println(o);//
System.out.println(age.get(o));  //返回 age 属性的值
//2. 使用反射操作 name 属性
Field name = stuClass.getDeclaredField("name");
//对 name 进行暴破, 可以操作 private 属性
name.setAccessible(true);
name.set(null, "psj");  //因为 name 是 static 属性，因此 o 也可以写出 null(静态属性和实例无关)
System.out.println(o);
System.out.println(name.get(o));  //获取属性值
System.out.println(name.get(null));  //获取属性值, 要求 name 是 static

# 访问方法
    // 得到 Boss 类对应的 Class 对象
    Class<?> bossCls = Class.forName("com.atguigu.Boss");
// 创建对象
Object o = bossCls.newInstance();
// 1. 调用 public 的 hi 方法
//Method hi = bossCls.getMethod("hi", String.class);//OK
// 1.1 得到 hi 方法对象
Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK
// 1.2 调用
hi.invoke(o, "psj");
// 2. 调用 private static 方法
// 2.1 得到 say 方法对象
Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
// 2.2 因为 say 方法是 private, 所以需要暴破
say.setAccessible(true);
System.out.println(say.invoke(o, 100, "张三", '男'));
// 2.3 因为 say 方法是 static 的，还可以这样调用 ，可以传入 null
System.out.println(say.invoke(null, 200, "李四", '女'));
// 3. 在反射中，如果方法有返回值，统一返回 Object , 但是运行类型和方法定义的返回类型一致
Object reVal = say.invoke(null, 300, "王五", '男');
System.out.println("reVal 的运行类型=" + reVal.getClass());  //String

// 类
class Student {
    public int age;
    private static String name;

    public Student() {//构造器
    }

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

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