Java反射

反射 反射机制 Java Reflection

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

Java反射机制原理示意图！！！

![[外链图片转存失败,源站可能有防盗

Java反射机制可以完成

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

反射相关的主要类

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

这些类在java.lang.reflection

反射优点和缺点

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

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

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

Class类 基本介绍

Class也是类，因此也继承Object类[类图]

Class类对象不是new出来的，而是系统创建的[演示]

对于某个类的Class类对象，在内存中只有一份，因为类只加载一次[演示]

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

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

Class对象是存放在堆的

类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据(包括 方法代码，
变量名，方法名，访问权限等等) (https:/ /www.zhihu.com/question/38496907)

package com.xz.reflection.class_;


public class Class01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //看看Class类图
        //1. Class也是类，因此也继承Object类
        //CLass
        //2.Class类对象不是new出来的，而是系统创建的
        //(1) 传统new对象
        
        Cat cat = new Cat();
        //(2) 反射方式
        Class cls1 = Class.forName("com.xz.reflection.Cat");

        //3.对于某个类的CLass类对象，在内存中只有一份，因为类只加载一次
        Class cls2 = Class.forName("com.xz.reflection.Cat");
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());

        Class cls3 = Class.forName("com.xz.reflection.Dog");
        System.out.println(cls3.hashCode());

    }

}

类图

Class类的常用方法

package com.xz.reflection.class_;

import com.xz.reflection.Car;

import java.lang.reflect.Field;


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

        String classAllPath = "com.xz.reflection.Car";
        //1. 获取到Car类 对应的 Class 对象
        // 表示不确定的Java类型
        Class cls = Class.forName(classAllPath);
        //2. 输出cls
        System.out.println(cls);//显示cls对象，是哪个类的Class对象 com.xz.reflection.Car
        System.out.println(cls.getClass());//输出cls的运行类型 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);
        //6. 通cls获取属性brand
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));//宝马
        //7. 通过反射给属性赋值
        brand.set(car, "奔驰");
        System.out.println(brand.get(car));
        //8. 通过反射机制拿到所有的属性（字段）
        System.out.println("=========所有的属性（字段）:==========");
        for (Field field : cls.getFields()) {
            System.out.println(field.getName());//名称
        }


    }
}

获取 Class 对象的各种方式（6）

package com.xz.reflection.class_;

import com.xz.reflection.Car;


public class GetClass_ {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.Class.forName
        String classAllPath = "com.xz.reflection.Car";//通过读取配置文件获取
        Class cls1 = Class.forName(classAllPath);
        System.out.println(cls1);

        //2.类名.class,应用场景：多用于参数传递
        Class cls2 = Car.class;
        System.out.println(cls2);

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

        //4.通过类加载器【4种】来获取到类的Class对象
        //(1)先得到类加载器car
        ClassLoader classLoader = car.getClass().getClassLoader();
        //(2)通过类加载器得到Class对象
        Class cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);

        //cls1,cls2,cls3,cls4是同一个对象
        System.out.println("========================");
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());
        System.out.println(cls3.hashCode());
        System.out.println(cls4.hashCode());

        //5.基本数据(int,char,boolean,float,double,byte,long,short) 按如下方式得到Class类对象
        Class integerClass = int.class;
        Class characterClass = char.class;
        Class booleanClass = boolean.class;
        System.out.println(integerClass);//int

        //6. 基本数据类型对应的包装类,可以通过.TYPE得到Class类对象
        Class type1 = Integer.TYPE;
        Class type2 = Character.TYPE;
        System.out.println(type1);

        //得到的integerClass 和 type1 也是同一个对象
        System.out.println("========================");
        System.out.println(integerClass.hashCode());
        System.out.println(type1.hashCode());


    }

}

哪些类型有Class对象

如下类型有Class对象

外部类，成员内部类，静态内部类，局部内部类，匿名内部类

interface: 接口

数组

enum :枚举

annotation :注解

基本数据类型

void

package com.xz.reflection.class_;

import java.io.Serializable;


public class AllTypeClass {
    public static void main(String[] args) {
        Class cls1 = String.class;//外部类
        Class cls2 = Serializable.class;//接口
        Class cls3 = Integer[].class;//数组
        Class cls4 = float[][].class;//二维数组
        Class cls5 = Deprecated.class;//注解
        Class cls6 = Thread.State.class;//枚举
        Class cls7 = long.class;//基础数据类型
        Class cls8 = Double.class;//包装类
        Class cls9 = void.class;//void数据类型
        Class cls10 = Class.class;

        System.out.println(cls1);
        System.out.println(cls2);
        System.out.println(cls3);
        System.out.println(cls4);
        System.out.println(cls5);
        System.out.println(cls6);
        System.out.println(cls7);
        System.out.println(cls8);
        System.out.println(cls9);
        System.out.println(cls10);


    }
}

类加载 基本说明

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

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

动态加载:运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖性

类加载时机

当创建对象时(new) //静态加载

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

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

通过反射 //动态加载

类加载过程图

类加载各阶段完成任务

加载阶段

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

连接阶段-验证

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

连接阶段-准备

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

连接阶段-解析

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

Initialization (初始化)

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

通过反射获取类的结构信息 第一组：java.lang.Class类

getName:获取全类名getSimpleName:获取简单类名getFields:获取所有public修饰的属性，包含本类以及父类的getDeclaredFields:获取本类中所有属性getMethods:获取所有public修饰的方法，包含本类以及父类的getDeclaredMethods:获取本类中所有方法getConstructors: 获取本类public修饰的构造器getDeclaredConstructors:获取本类中所有构造器getPackage:以Package形式返回包信息getSuperClass:以Class形式返回父类信息getInterfaces:以Class[]形式返回接口信息getAnnotations:以Annotation[]形式返回注解信息

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

getModifiers:以int形式返回修饰符[说明:默认修饰符是0，public 是1 , private 是2 , protected 是4,static是8 , final 是16, 例如：public(1) + static (8) = 9getType:以Class形式返回类型getName:返回属性名

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

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

第四组: java.lang.reflect.Constructor类

getModifiers:以int形式返回修饰符getName:返回构造器名(全类名)getParameterTypes:以Class[]返回参数类型数组

方法实例

package com.xz.reflection.question;

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;


public class ReflectionUtils {
    public static void main(String[] args) {

    }

    //演示方法
    @Test
    public void api_01() throws ClassNotFoundException {

        //得到Class对象
        Class personCls = Class.forName("com.xz.reflection.question.Person");

//        1.  getName:获取全类名
        String name = personCls.getName();
        System.out.println(name);//com.xz.reflection.question.Person
//        2.  getSimpleName:获取简单类名
        System.out.println(personCls.getSimpleName());//Person
//        3.  getFields:获取所有public修饰的属性，包含本类以及父类的
        for (Field field : personCls.getFields()) {
            System.out.println("本类以及父类所有属性:" + field.getName());
        }
//        4.  getDeclaredFields:获取本类中所有属性
        for (Field declaredField : personCls.getDeclaredFields()) {
            System.out.println("本类中所有属性:" + declaredField.getName());
        }
//        5.  getMethods:获取所有public修饰的方法，包含本类以及父类的
        for (Method method : personCls.getMethods()) {
            System.out.println("本类及父类，超类的public修饰的方法:" + method.getName());
        }
//        6.  getDeclaredMethods:获取本类中所有方法
        for (Method declaredMethod : personCls.getDeclaredMethods()) {
            System.out.println("本类中所有方法:" + declaredMethod.getName());
        }
//        7.  getConstructors: 获取所有public修饰的构造器，包含本类的
        for (Constructor constructor : personCls.getConstructors()) {
            System.out.println("本类public修饰的构造器:" + constructor.getName());
        }
//        8.  getDeclaredConstructors:获取本类中所有构造器
        for (Constructor declaredConstructor : personCls.getDeclaredConstructors()) {
            System.out.println("本类的所有构造器:" + declaredConstructor.getName());
        }
//        9.  getPackage:以Package形式返回包信息
        System.out.println(personCls.getPackage());//com.xz.reflection.question
//        10.  getSuperClass:以Class形式返回父类信息
        System.out.println("父类信息:" + personCls.getSuperclass().getName());
//        11.  getInterfaces:以Class[]形式返回接口信息
        for (Class anInterface : personCls.getInterfaces()) {
            System.out.println("接口信息:" + anInterface.getName());
        }
//        12.  getAnnotations:以Annotation[]形式返回注解信息
        for (Annotation annotation : personCls.getAnnotations()) {
            System.out.println("注解信息" + annotation);
        }


    }

    @Test
    public void api_02() throws ClassNotFoundException {
        //得到Class对象
        Class personCls = Class.forName("com.xz.reflection.question.Person");
        //getDeclaredFields:获取本类中所有属性
        //规定：public 是1 , private 是2 , protected 是4,static是8 , final 是16
        for (Field declaredField : personCls.getDeclaredFields()) {
            System.out.println("本类中所有属性:" + declaredField.getName() + " 该属性的修饰符值:" + declaredField.getModifiers()
                    + " 该属性的类型：" + declaredField.getType());
        }

        //getDeclaredMethods:获取本类中所有方法
        for (Method declaredMethod : personCls.getDeclaredMethods()) {
            System.out.println("本类中所有方法:" + declaredMethod.getName()
                    + " 该方法的访问修饰符值=" + declaredMethod.getModifiers()
                    + " 该方法的返回类型:" + declaredMethod.getReturnType());

            //输出当前的方法形参数组情况
            for (Class parameterType : declaredMethod.getParameterTypes()) {
                System.out.println(" 该方法的形参类型:" + parameterType);
            }

        }

        //getDeclaredConstructors:获取本类中所有构造器
        for (Constructor declaredConstructor : personCls.getDeclaredConstructors()) {
            System.out.println("=======================");
            System.out.println(" 本类的所有构造器:" + declaredConstructor.getName());

            for (Class parameterType : declaredConstructor.getParameterTypes()) {
                System.out.println(" 该构造器的形参类型:" + parameterType);
            }

        }

    }
}

class A {
    public String hobby;

    public A() {

    }
}

interface IA {

}

interface IB {

}

@Deprecated
class Person extends A implements IA, IB {
    //属性
    public String name;
    protected int age;
    String job;
    private double sal;

    public Person() {
    }

    public Person(String name) {

    }

    //私有构造器
    private Person(String name, int age) {

    }

    //方法
    public void m1(String name, int age, double sal) {

    }

    protected String m2() {
        return null;
    }

    void m3() {
    }

    private void m4() {

    }
}

通过反射创建对象

方式一:调用类中的public修饰的无参构造器方式二:调用类中的指定构造器Class类相关方法
newInstance :调用类中的无参构造器，获取对应类的对象
getConstructor(Cas…clazz):根据参数列表，获取对应的构造器对象
getDecalaredConstructor(Cas…clazz):根据参数列表，获取对应的构造器对象Constructor类相关方法
setAccessible:暴破 //暴破[暴力破解]，使用反射可以访间private构造器
newlnstance(Object…obj):调用构造器

通过反射访问类中的成员 访问属性

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

访问方法

根据方法名和参数列表获取Method方法对象:
Method m =clazz.getDeclaredMethod(方法名，XX.class); //得到本类的所有方法获取对象: Object o= clazz.newInstance();暴破: m.setAacessible(true);访问: Object returnValue = m.invoke(o,实参列表);注意:如果是静态方法，则invoke的参数o,可以写成null!