投稿
  1. 极客之音首页
  2. 后端开发
  3. Java
  4. Java自学入门

Java入门-反射（reflection）

李, 若俞 • • Java自学入门 • 阅读 271

反射（reflection）

今日语录：面对现实，你的傲慢与情况最起码得有相应的实力~

一、前言

请看下面的问题

1、根据配置文件re.properties指定信息，创建Cat对象并调用hi方法

classfullpath = com.hspedu.Cat

method = hi

思考：使用现有技术，你能做到吗？

2、这样的需求在学习框架时特别多，即通过外部文件配置，在不修改源码情况下，来控制程序，也符合设计模式的ocp原则（开闭原则：不修改源码，扩容功能）

package Reflection_;

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * @author chenx
 * @date 2022年04月20日
 */
public class ReflectionQuestion {
 public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
  // 1、使用Properties类，可以读写配置文件
  Properties properties = new Properties();
  properties.load(new FileInputStream("src\Reflection_\re.properties"));
  String classfullpath = properties.get("classfullpath").toString();
  String method = properties.get("method").toString();
  System.out.println("classfullpath:" + classfullpath);
  System.out.println("method:" + method);

  // 2、创建对象，传统的方法，行不通 => 需要用到 反射机制
  // new clssfullpath();

  // 3、使用反射机制解决
  // （1）加载类 ，返回class类型的对象
  Class cls = Class.forName(classfullpath);
  // (2) 通过cls得到 你加载的类 com.chenx.Cat的对象实例
  Object o = cls.newInstance();
  System.out.println("o的运行类型="+o.getClass());
  // (3) 通过class对象 得到你加载的类Reflection_.Cat的 methodName 的方法对象
  //  即： 在反射中，可以把方法视为对象（万物皆对象）
  Method method1 = cls.getMethod(method);
  // 传统方法 对象：方法（），反射机制 方法.invoke(对象)
  System.out.println("=======================");
  method1.invoke(o);

  //System.out.println("得到的方法名为："+method1.getName());
 }
}

二、简介

Java Reflection

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

三、反射原理示意图

Java入门-反射（reflection）
image-20220425102115593

四、Java反射机制作用

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

五、反射相关的主要类

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

这些类在java.lang.reflection中

六、反射优点和缺点

  • 优点：可以动态的创建和使用对象（也是框架底层核心），使用灵活，没有反射机制，框架技术就失去底层支撑

  • 缺点：使用反射基本是解释执行，对执行速度有影响

    package Reflection_;

    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;

    /**
     * @author chenx
     * @date 2022年04月25日
     */
    public class Reflection02 {
     public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
      m1();

      m2();
     }

     //传统方法来调用
     public static void m1(){
      Cat cat = new Cat();
      long start = System.currentTimeMillis();
      for(int i=0;i< 900000000; i++){
       cat.hi();
      }
      long end = System.currentTimeMillis();
      System.out.println("m1执行时间花了："+(end-start));
     }

     // 反射机制调用方法hi
     public static void m2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
      Class cla = Class.forName("Reflection_.Cat");
      Object o = cla.newInstance();
      Method met = cla.getMethod("hi");

      long start = System.currentTimeMillis();
      for(int i=0;i< 900000000; i++){
       met.invoke(o);
      }
      long end = System.currentTimeMillis();
      System.out.println("m2执行时间花了："+(end-start));
     }
    }

    Java入门-反射（reflection）
    image-20220425214049060

七、反射调用优化-关闭访问检查

  • Method和Field、Constructor对象都有setAccessible()方法

  • setAccessible作用是启动和禁用访问安全检查的开关

    package Reflection_;

    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;

    /**
     * @author chenx
     * @date 2022年04月25日
     */
    public class Reflection02 {
     public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
      m1();

      m2();

      //Field
      //Method
      //Constructor
     }

     //传统方法来调用
     public static void m1(){
      Cat cat = new Cat();
      long start = System.currentTimeMillis();
      for(int i=0;i< 900000000; i++){
       cat.hi();
      }
      long end = System.currentTimeMillis();
      System.out.println("m1执行时间花了："+(end-start));
     }

     // 反射机制调用方法hi
     public static void m2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
      Class cla = Class.forName("Reflection_.Cat");
      Object o = cla.newInstance();
      Method met = cla.getMethod("hi");
      met.setAccessible(true);
      long start = System.currentTimeMillis();
      for(int i=0;i< 900000000; i++){
       met.invoke(o);
      }
      long end = System.currentTimeMillis();
      System.out.println("m2执行时间花了："+(end-start));
     }
    }

    Java入门-反射（reflection）
    image-20220425214922309

    2808 ->  2375，提高了433

  • 参数值为true表示 反射的对象在使用时取消访问检查，提高反射的效率。参数值为false则表示反射的对象执行访问检查

    Java入门-反射（reflection）
    image-20220425214509063

八、Class类

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

Class类常用方法

Java入门-反射（reflection）
image-20220429154733195

示例代码：

package Reflection_;

import java.lang.reflect.Field;
import java.util.Arrays;

/**
 * @author chenx
 * @date 2022年04月29日
 */
public class Class01 {
 public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
  //1、Class也是类，因此也继承Object类
  //2、Class类对象不是new出来的，而是系统创建的
  //(1)传统new创建对象
  // ClassLoader类
  //   public Class<?> loadClass(String name) throws ClassNotFoundException {
  //        return loadClass(name, false);
  //    }
  //Cat cat = new Cat();
  //（2）反射方式
  //    @CallerSensitive
  //    public static Class<?> forName(String className)
  //                throws ClassNotFoundException {
  //        Class<?> caller = Reflection.getCallerClass();
  //        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
  //    }
  //   最终也会调用
  //  ClassLoader类
  //  public Class<?> loadClass(String name) throws ClassNotFoundException {
  //        return loadClass(name, false);
  //    }

  String str = "Reflection_.Cat";
  Class<?> aclass = Class.forName(str);

  // 1、得到hash值
  System.out.println(aclass.hashCode());
  // 2、得到运行类型
  System.out.println(aclass.getClass());
  // 3、得到包名
  System.out.println(aclass.getPackage().getName());
  // 4、得到当前Class类对象的父类的Class对象
  System.out.println(aclass.getSuperclass());
  // 5、得到类的全名
  System.out.println(aclass.getName());
  // 6、通过aclass创建对象实例
  Cat cat02 = (Cat)aclass.newInstance();
  // 7、获取当前Class对象的接口
  System.out.println(Arrays.toString(aclass.getInterfaces()));
  // 8、获得当前Class对象的类加载器
  System.out.println(aclass.getClassLoader());
  // 9、获得一个包含某些Constructor对象的数组
  System.out.println(Arrays.toString(aclass.getConstructors()));
  // 10、返回Field对象的一个数组
  System.out.println(Arrays.toString(aclass.getDeclaredFields()));
  // 11、返回一个Method对象，此对象的形参类型为paramType
  System.out.println(Arrays.toString(aclass.getMethods()));

  Object o = aclass.newInstance();
  // 获取属性
  Field field = aclass.getField("brand");
  System.out.println("----------"+field.getName());
  // 12、获取所有属性
  Field[] fields = aclass.getFields();
  if(fields.length>0){
   for(Field f : fields){
    System.out.println(f.getName());
   }
  }
  //System.out.println(Arrays.toString(fields));

  field.set(o,"chenx");

  Object obj2 = field.get(o);
  System.out.println(obj2);

 }
}

Java入门-反射（reflection）
image-20220429163234076

获取Class对象的六种方式

  • 应用场景：多用于配置文件，读取类全路径，加载类

    // 方式一：Class.forName();
    // 通过配置文件获取
    String str = "Reflection_.Cat";
    Class<?> aclass = Class.forName(str);
    System.out.println(aclass.getName());
    1. 前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException，实例：Class cls1 = Class.forName(“java.lang.Cat”);

  • 2.前提：若已知具体的类，通过类的Class获取，该方式最为安全可靠，程序性能最高实例：Class cls2 = Cat.class

    应用场景：多用于参数传递，比如通过反射得到对应构造器对象

    // 方式二：类名.class
    System.out.println(Cat.class);

  • 3.前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象，实例：Class aclass = 对象.getClass();

    应用场景：通过创建好的对象，获取Class对象

    // 方式三：Class class = 对象名.class
    Class<?> cls = Cat.class;
    //System.out.println(cls);

  • 4.其他方式

    ClassLoader cl = 对象.getClass().getClassLoader();

    Class clazz4 = cl.loadClass(“类的全类名”);

    Java入门-反射（reflection）

  • 5.基本数据类型（int char boolean float double byte long short）按如下方式得到Class类对象

    Class cls = 基本数据类型.class

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

    Class cls = 包装类.TYPE
    Java入门-反射（reflection）
    image-20220503183356927

九、哪些类型有Class对象

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

示例代码

package Reflection_;

import java.io.Serializable;

/**
 * @author chenx
 * @date 2022年05月03日
 */
public class AllTyprClass_ {
 public static void main(String[] args) {
  Class<String> c1 = String.class;
  Class<Serializable> c2 = Serializable.class;
  Class<Integer[]> c3 = Integer[].class;
  Class<float[][]> c4 = float[][].class;
  Class<Deprecated> c5 = Deprecated.class;

  Class<Thread.State> c6 = Thread.State.class;
  Class<Long> c7 = long.class;
  Class<Void> c8 = void.class;
  Class<Class> c9 = Class.class;

  System.out.println(c1);
  System.out.println(c2);
  System.out.println(c3);
  System.out.println(c4);
  System.out.println(c5);
  System.out.println(c6);
  System.out.println(c7);
  System.out.println(c8);
  System.out.println(c9);
 }
}

Java入门-反射（reflection）
image-20220503214939102

十、类加载

基本说明

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

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

    如：Dog dog = new Dog();

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

    如：Class cls = Class.forName("person");
    Object o = cls.newInstance();
    Method m = cls.getMethod("hi"):
    m.invoke(o);

类加载时机

  • 当创建对象时（new）
  • 当子类被加载时
  • 调用类中的静态成员时
  • 通过反射

十一、类加载流程

Java入门-反射（reflection）
image-20220503220144168

  • 类加载各阶段完成任务

    Java入门-反射（reflection）
    image-20220503224651731

  • 1.加载阶段

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

  • 2.连接阶段-验证

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

  • 3.连接阶段-准备

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

      package Reflection_;

      /**
       * @author chenx
       * @date 2022年05月03日
       */
      public class ClassLoad02_ {
       public static void main(String[] args) {

       }
      }

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

      }

  • 4.连接阶段-解析

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

  • 5.Initialization(初始化)

    • 到初始化阶段，才真正开始执行类中定义的Java程序代码，此阶段是执行()方法的过程

    • ()方法是由编译器按语句在源文件中出现的顺序，依此自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并

    • 虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕

      示例代码：

      package Reflection_;

      import java.sql.SQLOutput;

      /**
       * @author chenx
       * @date 2022年05月04日
       */
      public class ClassLoad03_ {
       public static void main(String[] args) {
        // 1、加载BB类，并生成BB的class对象
        // 2、链接 num = 0;
        // 3、初始化阶段
        //    依此自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并
        //   clinit(){
        //       System.out.println("BB 静态代码块被执行");
        //   num = 300;
        //       num = 100;
        //   }
        //   顺序执行，最后num=100
        // 4、“B()构造器被加载”
        //  类加载同步机制控制，部分源码
        //  protected Class<?> loadClass(String name, boolean resolve)
        //        throws ClassNotFoundException
        //    {
        //        因为这个机制，才能保证某个类在内存中只有一份Class对象
        //        synchronized (getClassLoadingLock(name)) {
        //           ......
        //        }
        //     }
        BB b = new BB();
        System.out.println(BB.num);
       }
      }

      class BB{
       static {
        System.out.println("BB 静态代码块被执行");
        num = 300;

       }
       static int num = 100;
       public BB(){
        //System.out.println(num);
       }

      }
      Java入门-反射（reflection）
      image-20220504101643267

十二、通过反射创建对象

  • 方式一：调用类中的public修饰的无参构造器class

  • 方式二：调用类中的指定构造器

  • Class类相关方法

    • newInstance:调用本类中的无参构造器，获取对应类的对象
    • getConstructor(Class..clas):根据参数列表，获取对应的构造器对象
    • getDecalaredConstructor(Class…clas):根据参数列表，获取对应的构造器对象

  • Constructor类相关方法

    package Reflection_;

    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;

    /**
     * @author chenx
     * @version 1.0
     * 演示通过反射机制创建实例
     */
    public class ReflecCreateInstance {
     public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {

      //1. 先获取到User类的Class对象
      Class<?> userClass = Class.forName("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 + "]";
     }
    }

    Java入门-反射（reflection）
    image-20220504104028437
    • setAccessible：爆破（暴力破解，使用反射可以访问private构造器/方法/属性）
    • newInstance(Object …obj)：调用构造器

十三、通过反射访问类中的成员

  • 访问属性

    1、根据属性名获取Field对象

    Field f = clazz对象.getDeclaredField(属性名);

    2、暴破：f.setAccessible(true);

    3、访问

    f.set(o,值);

    4、如果是静态属性，则set和get中的参数o，可以写成null

    package Reflection_;

    /**
     * @author chenx
     * @date 2022年05月04日
     */
    import java.lang.reflect.Field;

    /**
     * @author chenx
     * @version 1.0
     * 演示反射操作属性
     */
    public class ReflecAccessProperty {
     public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {

      //1. 得到Student类对应的 Class对象
      Class<?> stuClass = Class.forName("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 + "]";
     }
    }
    Java入门-反射（reflection）
    image-20220504105004437

  • 访问方法

    1、根据方法名和参数列表获取Method方法对象：Method m = clazz.getDeclaredMethod(方法名,XX.class);

    2、获取对象：Object o = clazz.newInstance();

    3、暴破：m.setAccessible(true);

    4、访问：Object returnValue = m.invoke(o,实参列表);

    5、注意：如果是静态方法，则invoke的参数哦，可以写成null;

    package Reflection_;

    /**
     * @author chenx
     * @date 2022年05月04日
     */
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;

    /**
     * @author chenx
     * @version 1.0
     * 演示通过反射调用方法
     */
    public class ReflecAccessMethod {
     public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {

      //1. 得到Boss类对应的Class对象
      Class<?> bossCls = Class.forName("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);
     }
    }
    Java入门-反射（reflection）
    image-20220504105841646


原文始发于微信公众号（Whisper Coding）：Java入门-反射（reflection）

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/255604.html

赞 (0)
李, 若俞的头像李, 若俞
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！