反射（Java Reflection）

最新推荐文章于 2024-09-09 20:03:37 发布

Maddoxzhi

最新推荐文章于 2024-09-09 20:03:37 发布

阅读量503

点赞数 1

分类专栏：学习笔记-java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/maddoxzhi/article/details/127559552

版权

学习笔记-java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

根据b站韩顺平教育韩顺平教育java教学视频学习的学习笔记。个人学习理解，如有疏漏，敬请改正。

反射机制

1、反射机制允许程序在执行期借助于ReflectionAPI取得任何类的内部信息（比如成员变量，构造函数，成员方法等等）并能操作对象的属性及方法。反射在设计模式和框架底层都会用到

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

Java反射机制原理图

Java反射机制的作用

1、在运行时判断任意一个对象所属的类

2、在运行时构造任意一个类的对象

3、在运行时得到任意一个类所具有的成员变量和方法

4、在运行时调用一个对象的成员变量和方法

5、生成动态代理

反射相关的类

java.lang.Class：代表一个类，Class对象表示某个类加载后在堆中的对象

java.lang.reflect.Method：代表类的方法，Method对象表示某个类的方法

java.lang.reflect.Field：代表类的成员变量，Field对象表示某个类的字段

java.lang.reflect.Constructor：代表类的构造方法，Constructor对象表示某个类的构造器

public class ReflectDmo {
    public static void main(String[] args) throws Exception{
        //在不修改源码的情况下，通过外部文件调用类的对象、属性和方法，为了满足ocp原则（开闭原则）
        Properties properties = new Properties();
        //将文件加载到Properties对象
        properties.load(new FileInputStream("src\\re.properties"));
//        String catPath = properties.getProperty("catPath");
        String catPath =  properties.get("catPath").toString();
        String method = properties.get("method").toString();
//        String method = properties.getProperty("method");
        System.out.println("catPath:" + catPath);
        System.out.println("method:" + method);

        //使用反射
        //加载类得到Class类的对象cls
        Class cls = Class.forName(catPath);
        //通过cls得到你加载的类com.zdz.com.zdz.reflection.Cat的对象实例,注意这里是调用了Cat的无参构造方法进行实例化
        Object o = cls.newInstance();
        System.out.println(o.getClass());
        //通过cla得到你加载的类com.zdz.com.zdz.reflection.Cat的method方法
        //  即在反射中可以将方法视为对象（万物皆对象）
        System.out.println("===============");
        Method method1 = cls.getMethod(method);
        //通过method1调用方法
        method1.invoke(o);//传统方法 对象.方法   反射：方法.invoke（对象）
        Method method2 = cls.getMethod("cry");//也可以通过字符串直接获取方法名
        method2.invoke(o);

        //java.lang.reflect.Field：代表类的成员变量，Field对象表示某个类的字段
        Field field = cls.getField("age");//注意field不能得到私有(private)属性
        System.out.println(field.get(o));//传统方法 对象.属性   反射：属性对象.get（对象）
        //java.lang.reflect.Constructor：代表类的构造方法，Constructor对象表示某个类的构造器
        Constructor cos = cls.getConstructor();//()里可以写构造器参数，没有则是调用无参构造器
        System.out.println(cos);

        Constructor cos2 = cls.getConstructor(String.class,Integer.class);
        //String.Class就是String类的Class对象
        System.out.println(cos2);

    }
}

反射调用优化

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

优化

Method method1 = cls.getMethod(method);
        method1.setAccessible(true);//在反射调用方法时，取消访问检查，提高反射的效率

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

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

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

Class类

基本介绍

1、Class也是一个类，因此它也继承了Object类

2、Class类对象不是new出来的，而是系统创建的（类加载器ClassLoader的loadClass()方法）

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

4、每个类的实例都会记得自己是由哪个Class实例所生成

5、通过Class可以完整地得到一个类的完整结构，通过一系列API

6、Class对象是存放在堆的

7、类的字节码二进制数据是放在方法区的，有的地方称为类的元数据（包括方法代码、变量名、方法名、访问权限等）

Class类的常用方法

public class ClassOfMethod {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        String classPath = "com.zdz.reflection.Cat";
        //获取到Cat类对的Class对象
        Class<?> cls = Class.forName(classPath);//<?>是泛型通配符，表示不确定的Java类型
        System.out.println(cls);//显示cls是那个类的Class对象
        System.out.println(cls.getClass());//输出cls的运行类型 java.lang.Class
        //得到包名
        System.out.println(cls.getPackage().getName());
        //得到全类名 com.zdz.reflection.Cat
        System.out.println(cls.getName());
        //通过cls创建对象实例
        Object o = cls.newInstance();
//        Object o1 = Class.forName(classPath).newInstance();
//        Cat cat = (Cat) o;
//        Cat cat = (Cat)Class.forName(classPath).newInstance();
        //通过反射获取属性
        Field name = cls.getField("name");
        //通过反射给属性（字段）赋值
        name.set(o,"波斯猫");
        //得到所有的属性
        Field[] fields = cls.getFields();
        for (Field element : fields){
            System.out.println(element.get(o));//这是得到属性对应的值，element.getName(o)是获取字段名
        }
    }
}

获取Class对象的六种方式

1、（在编译阶段获取）前提：已知一个类的全类名（包含各级文件），且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

如：String classPath = "com.zdz.reflection.Cat";//通过读取配置文件获取
//获取到Cat类对的Class对象
Class<?> cls = Class.forName(classPath);

应用场景：多用于配置文件，读取类全路径，加载类（底层框架使用较多）

2、（在类加载阶段获取）前提：若已知具体的类，通过类的class获取，该方式最为安全可靠，程序性能最高实例

如：Class cls = Cat.class

Constructor cos2 = cls.getConstructor(String.class,Integer.class);

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

3、（在运行阶段获取）前提:已知某个类的实例，调用该实例的getClass()方法获取Class对象

如Class clazz = 对象.getClass();

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

4、（通过类加载器获取）其他方式，类加载器【4种】得到Class对象

ClassLoader cls = 对象.getClass().getClassLader();

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

对于一个类而言只有一个Class对象与之对应（类只加载一次）

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

Class cls = 基本数据类型.class

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

Class cls = 包装类.TYPE

哪些类型有Class对象

1、外部类、成员内部类、静态内部类、局部内部类、匿名内部类

2、Interface：接口

3、数组

4、enum：枚举

5、annotation：注解

6、基本数据类型

7、void

类加载

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

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

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

类加载时机

1当创建对象时（new）---静态加载

2当子类被加载时，父类也加载-----静态加载

3调用类中的静态成员时----静态加载

4通过反射---动态加载

类加载流程图

类加载各阶段完成的任务

类加载五个阶段（JVM知识）

加载阶段

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

连接阶段-验证

1、目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全

2、包括：文件格式验证（是否以魔数ox cafe babe开头）、元数据验证、字节码验证和符号引用验证、

3、可以考虑使用-Xverify：none参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间

连接阶段-准备

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

连接阶段-解析

虚拟机将常量池内的符号引用替换为直接引用的过程（逻辑地址转换为物理地址的过程）

Initialization（初始化）

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

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

3虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕------正因为有这个机制才能保证某个类在内存中只有一份Class对象

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

第一组：java.lang.Class类

1getName：获取全类名

2getSimpleNmae：获取简单类名

3getField：获取所有public修饰的属性，包含本类以及父类的

..............看代码............

package com.zdz.reflection;

import org.junit.jupiter.api.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.security.PublicKey;

/**
 * @version null
 * @anthor zdz/Maddox
 */
public class ReflectionUtils {
    public static void main(String[] args) {

    }
    @Test
    public void apiOneShow() throws ClassNotFoundException {
        //得到Class对象
        Class cls = Class.forName("com.zdz.reflection.Person");
        //1、getName：获取全类名
        System.out.println(cls.getName());
        //2、getSimpleNmae：获取简单类名
        System.out.println(cls.getSimpleName());
        //3、getFields：获取所有public修饰的属性，包含本类以及父类的
        Field[] fields = cls.getFields();
        for (Field field : fields) {
            //先输出子类的在输出父类的
            System.out.println("本类及父类的公共属性:" + field.getName());
        }
        //4、getDeclaredFields()获取本类的所有属性
        Field[] fields1 = cls.getDeclaredFields();
        for (Field field : fields1) {
            System.out.println("本类的所有属性:" + field.getName());
        }
        //5、getMethods()获取本类及父类public修饰的所有方法
        Method[] methods = cls.getMethods();
        for (Method method : methods) {
            System.out.println("本类及父类的所有公共方法："+ method.getName());
        }
        //6、getDeclaredMethods获取本类的所有方法
        Method[] methods1 = cls.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println("获取本类的所有方法"+ method.getName());
        }
        //7、getConstructors()获取本类的所有公共构造器
        //8、getDeclaredConstructors()获取本类所有的构造器
        //9、getPackage:以Package形式返回包信息
        System.out.println(cls.getPackage());
        //9、getSuperClass:以Class形式返回父类信息
        System.out.println(cls.getSuperclass());
        //10、getInterfaces：以Class[]形式返回接口信息
        Class[] interfaces = cls.getInterfaces();
        for (Class anInterface : interfaces) {
            System.out.println("接口信息："+ anInterface.getName());
        }
        //11、getAnnotations:以Annotations[]形式返回注解信息
        Annotation[] annotations = cls.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("注解信息："+ annotation);
        }

    }
}
class People{
    private String names;
    public String race;

    public void hi(){

    }
}
class Person extends People{
    private String name;
    public int age;
    private String sex;
    public String school;

    public void f1(){

    }
    public void f2(){

    }
    public void f3(){

    }
}

第二组：java.lang.reflect.Field类

1、getModifiers：以int修饰返回修饰符

[说明：默认修饰符是0，public是1，private是2，protected是4，static是8，final是16]当有两个修饰符的时候按照public(1)+static(8) =9的形式输出

2、getType：以Class形式返回类型

3、getName：返回属性名

  @Test
    public void apiTwoShow() throws ClassNotFoundException {
        //得到Class对象
        Class cls = Class.forName("com.zdz.reflection.Person");
        //4、getDeclaredFields()获取本类的所有属性
        Field[] fields1 = cls.getDeclaredFields();
        for (Field field : fields1) {
            System.out.println("本类的所有属性:" + field.getName()
                            + "    本类属性的修饰符" + field.getModifiers()
                            + " 该属性的类型"  + field.getType());
        }
    }

第三组：java.lang.reflect.Method类

1、getModifiers：以int修饰返回修饰符

[说明：默认修饰符是0，public是1，private是2，protected是4，static是8，final是16]当有两个修饰符的时候按照public(1)+static(8) =9的形式输出

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]当有两个修饰符的时候按照public(1)+static(8) =9的形式输出

2、getName：返回构造器名

3、getParameterTypes：以Class[]返回参数类型数组

反射爆破创建实例

通过反射创建对象

1、调用类中的public修饰的无参构造器

2、调用类中的指定构造器

3、Class类相关方法

newInstance：调用类中的无参构造器，获取对应类的对象

getConstructor(Class...clazz)：根据参数列表，获取对应的构造器对象

getDecalaredConstructor(Class...clazz):根据参数列表，获取对应的构造器对象

4、Constructor类相关方法

setAccessible:爆破

newInstance(Object...obj)：调用构造器

package com.zdz.reflection;

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

/**
 * @version null
 * @anthor zdz/Maddox
 */
public class ReflectCreateObject {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        //1、先获取到User类的Class类对象
        Class<?> aClass = Class.forName("com.zdz.reflection.User");
        //2、通过public的无参构造器创建实例
        Object o = aClass.newInstance();
        System.out.println(o);
        //3、通过public的有参构造器创建实例
        //constructor即
        // public   User(String name){
        //       this.name = name;
        //    }
        //3.1 先得到对应的构造器
        Constructor<?> constructor = aClass.getConstructor(String.class);
        //3.2 创建实例，并传入实参
        Object zdz = constructor.newInstance("zdz");
        System.out.println("zdz = " + zdz);
        //4、通过非public的有参构造器创建实例  ---  反射面前都是纸老虎
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);//暴破，使用反射可以访问private构造器
        Object zdz1 = declaredConstructor.newInstance("zdz", 22);
        System.out.println("zdzage = " + zdz1);

    }
}

class User{
    private String name;
    private int age;

    public User(){

    }

    public User(String name){
        this.name = name;
    }

    private User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

反射爆破操作属性

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

Field field = cls.getField("age");

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

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

3、访问

field.set(o,值);// o-对象

syso(field.get(o));//syso是输出简写

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

package com.zdz.reflection;

import java.lang.reflect.Field;

/**
 * @version null
 * @anthor zdz/Maddox
 */
public class ReflectAccessProperty {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        Class<?> aClass = Class.forName("com.zdz.reflection.Student");
        Object o = aClass.newInstance();
        Field age = aClass.getField("age");
        age.set(o,18);//通过反射来操作属性
        System.out.println(o);
        System.out.println(age.get(o));//返回值

        Field name = aClass.getDeclaredField("name");//name是私有属性
        name.setAccessible(true);//私有属性一样要暴破
        name.set(o,"zdz");
//        name.set(null,"zdz");也可以，静态变量是所有属性共享的
        System.out.println(name.get(o));
        }
}
class Student{
    private String name;
    public int age;

    public Student(){

    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

反射暴破操作方法

1、根据方法名和参数列表获取Method方法对象

Method method = clazz.getDeclaredMethod("方法名", String.class)

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

3、暴破：m.setAccessible(true)

4、访问：Object returnValue = method.invoke(o,实参列表);//o就是对象

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

package com.zdz.reflection;

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

/**
 * @version null
 * @anthor zdz/Maddox
 */
public class ReflectAccessMethod {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        //获取Teacher的Class对象
        Class<?> aClass = Class.forName("com.zdz.reflection.Teacher");
        //创建对象
        Object o = aClass.newInstance();
        Method method = aClass.getMethod("f1");
        Method f2 = aClass.getDeclaredMethod("f2", String.class);
        f2.invoke(o,"zdz");
        Method declaredMethod = aClass.getDeclaredMethod("f3",int.class, String.class);
        declaredMethod.setAccessible(true);
        declaredMethod.invoke(o,18,"zdz");//只有f3是一个静态方法时o才能为null
        //在反射中，如果方法有返回值，统一返回Object,但是它的运行类型是和方法定义的返回类型一致
        Object hi = declaredMethod.invoke(o, 22, "hi");
    }
}

class Teacher{

    private Student name;
    private int age;
    public String course;

    public Teacher(){

    }

    public Teacher(Student name, int age, String course) {
        this.name = name;
        this.age = age;
        this.course = course;
    }

    public void f1(){

    }

    public String f2(String name){
        System.out.println(name + "-----");
        return null;
    }

    private void f3(int age,String name){
        System.out.println(name + age);
    }
}