Java笔记 - 反射

一、Java反射

 

1、Java反射机制

反射机制运行程序在执行期借助于Reflection API 获取任何类的内部信息（成员变量、构造器、成员方法等）。并能操作对象的属性及方法。

加载完类之后，在堆中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息，通过这个对象得到类的结构。

 

2、Java反射机制原理图

 

3、反射的功能

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

（2）在运行时构造任意一个类的对象。

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

（4）在运行时调用任意一个对象的成员变量和方法。

（5）生成动态代理

 

4、反射相关的主要类

（1）java.lang.Class ：代表一个类

（2）java.lang.reflect.Method ：代表类的方法

（3）java.lang.reflect.Field ：代表类的成员变量

（4）java.lang.reflect.Constructor ：代表类的构造器

 

5、反射的优缺点

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

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

 

6、反射优化-关闭访问检查

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

 

二、Class类

1、基本介绍

（1）CLass也是类，因此也继承Object类。

（2）Class类对象不是new出来的，而是系统创建的。

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

（4）每个类的实例都会记得自己是哪个Class实例所生成的。

（5）通过Class对象可以完整地得到一个类的完整结构，同一一系列API。

（6）Class对象是存放再堆的。

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

 

2、Class类的常用方法

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

        // 指定类名获取Class对象
        Class<?> cls = Class.forName("com.star.reflection.Cat");

        // 根据Class对象创建一个实例
        Object obj = cls.newInstance();

        // 返回Class对象表示的实体
        System.out.println(cls.getName());

        // 返回当前Class的接口
        Class<?>[] interfaces = cls.getInterfaces();

        // 返回类的类加载器
        ClassLoader classLoader = cls.getClassLoader();

        // 返回Class表示实体的超类的Class
        Class<?> superclass = cls.getSuperclass();

        // 返回包含构造器的数组
        Constructor<?>[] constructors = cls.getConstructors();

        // 返回柏寒内部变量的数组
        Field[] declaredFields = cls.getDeclaredFields();

        // 返回包含内部方法的数组
        Method[] methods = cls.getMethods();
    }
}

 

3、获取Class类对象

public class GetClass {
    public static void main(String[] args) throws ClassNotFoundException {
        /*
        cls1,cls2,cls3,cls4 是一个对象 hashcode一样
        integerClass,integerType 是一个对象 hashcode一样
         */
        // 1、Class.forName() 多用于配置文件
        String classPath = "com.star.entity.Cat";
        Class<?> cls1 = Class.forName(classPath);
        System.out.println(cls1);

        // 2、Cat.class 多用于参数参加第
        Class<Cat> cls2 = Cat.class;
        System.out.println(cls2);

        //3、对象.getClass() 通过创建好的对象，获取class信息
        Cat cat = new Cat();
        Class<? extends Cat> cls3 = cat.getClass();
        System.out.println(cls3);

        //4、通过类加载器来获取类的Class
        ClassLoader classLoader = cat.getClass().getClassLoader();
        Class<?> cls4 = classLoader.loadClass(classPath);
        System.out.println(cls4);

        // 5、基本数据类型
        Class<Integer> integerClass = int.class;
        Class<Boolean> booleanClass = boolean.class;

        // 6、基本数据类型对应的包装类可以通过.TYPE得到Class类对象
        Class<Integer> integerType = Integer.TYPE;
        Class<Boolean> booleanType = Boolean.TYPE;
    }
}

 

4、具有Class对象的类型

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

（2）interface：接口

（3）数组

（4）enum：枚举

（5）annotation：注解

（6）基本数据类型

（7）void

 

三、类加载

1、两种加载类型

（1）静态加载：编译时加载相关的类，如果没有则报错，依赖性强（new的方法创建）

（2）动态加载：运行时加载需要的类，如果运行时不用该类，即是不存在该类，二不报错，依赖性低（Class的方法创建）

 

2、类加载过程

（1）加载阶段

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

（2）连接阶段-验证

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

②包括：文件格式验证（是否以模式ioxcafebabe开头）、元数据验证、字节码验证和符号引用验证。

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

（3）连接阶段-准备

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

①非静态变量，在准备阶段不分分配内存。

②静态变量，在准备阶段分配内存，并默认初始化值。

③静态常量，在准备阶段分配内存，并赋值，

（4）连接阶段-解析

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

（5）初始化

①到初始化阶段，才真正开始执行类中定义的Java程序代码，此阶段执行客户端方法的过程。

②客户端方法由编译器按语句在源文件中出现的顺序，以此自动搜集类中的所有静态变量的复制动作和静态代码块中的语句，并进行合并。

③虚拟机会保证一个类客户端方法在多线程环境中正确的加锁、同步，如果多个线程同时去初始化一个类，那么只有一个线程去执行这个类的客户端方法，其他线程都需要阻塞等待，知道活动线程执行客户端方法完毕。

 

四、通过反射获取类信息

1、反射api

（1）java.lang.Class类

public class DemoClass {
    public static void main(String[] args) throws ClassNotFoundException {

        Class<?> cls = Class.forName("com.star.reflection.Item");

        // 获取全类名
        System.out.println(cls.getName());
        System.out.println("-------------------------------");

        // 获取简单类名
        System.out.println(cls.getSimpleName());
        System.out.println("-------------------------------");

        // 获取所有public修饰的属性
        Field[] fields = cls.getFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        }
        System.out.println("-------------------------------");

        // 获取所有属性
        Field[] declaredFields = cls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField.getName());
        }
        System.out.println("-------------------------------");

        // 获取所有public修饰的方法
        Method[] methods = cls.getMethods();
        for (Method method : methods) {
            System.out.println(method.getName());
        }
        System.out.println("-------------------------------");

        // 获取所有方法
        Method[] declaredMethods = cls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.getName());
        }
        System.out.println("-------------------------------");

        // 获取所有public修饰的构造器
        Constructor<?>[] constructors = cls.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor.getName());
        }
        System.out.println("-------------------------------");

        // 获取所有构造器
        Constructor<?>[] declaredConstructors = cls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor.getName());
        }
        System.out.println("-------------------------------");

        // 获取类所在的包
        System.out.println(cls.getPackage().getName());
        System.out.println("-------------------------------");

        // 获取类的父类
        System.out.println(cls.getSuperclass().getName());
        System.out.println("-------------------------------");

        //获取类的接口
        Class<?>[] interfaces = cls.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println(anInterface.getName());
        }
        System.out.println("-------------------------------");

        // 获取类的注解
        Annotation[] annotations = cls.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
    }
}

（2）变量、方法、构造器

public class DemoField {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class<?> cls = Class.forName("com.star.reflection.Item");

        System.out.println("-----属性-----");

        Field publicStr = cls.getField("publicStr");

        // 以int的形式返回修饰符（省缺：0，public：1，private：2，protected：4，static：8，final：16）
        // 多个修饰符未 int加和
        System.out.println(publicStr.getModifiers());

        // 以class的形式返回类型
        System.out.println(publicStr.getType());

        // 返回属性名
        System.out.println(publicStr.getName());

        System.out.println("-----方法-----");

        Method hello = cls.getMethod("hello");
        Method hi = cls.getMethod("hi",String.class);

        // 以int的形式返回修饰符（省缺：0，public：1，private：2，protected：4，static：8，final：16）
        // 多个修饰符为 int加和
        System.out.println(hi.getModifiers());

        // 获取返回值类型
        System.out.println(hi.getReturnType());

        // 获取方法名
        System.out.println(hi.getName());

        // 获取参数类型
        Class<?>[] parameterTypes = hi.getParameterTypes();
        for (Class<?> parameterType : parameterTypes) {
            System.out.println(parameterType);
        }

        System.out.println("-----构造器-----");
        Constructor<?> constructor1 = cls.getConstructor();
        Constructor<?> constructor2 = cls.getConstructor(String.class, String.class, String.class);

        // 以int的形式返回修饰符（
        System.out.println(constructor2.getModifiers());

        // 获取构造器名
        System.out.println(constructor2.getName());

        // 获取构造器参数类型
        Class<?>[] parameterTypes1 = constructor2.getParameterTypes();
        for (Class<?> aClass : parameterTypes1) {
            System.out.println(aClass);
        }
    }
}

 

2、通过反射创建对象

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

        Class<?> cls = Class.forName("com.star.reflection.Item");

        // 调用public修饰的无参构造器创建对象
        Item item1 = (Item)cls.newInstance();
        System.out.println(item1.publicStr);

        // 调用public修饰的有参构造器创建对象
        Constructor<?> constructor1 = cls.getConstructor(String.class, String.class, String.class);
        Item item2 = (Item) constructor1.newInstance("public", "b", "c");
        System.out.println(item2.publicStr);

        // 调用public修饰的有参构造器创建对象
        // setAccessible(true) 爆破
        Constructor<?> declaredConstructor = cls.getDeclaredConstructor(String.class);
        declaredConstructor.setAccessible(true);
        Item item3 = (Item)declaredConstructor.newInstance("private");
        System.out.println(item3.publicStr);
    }
}

 

3、通过反射访问属性

public class DemoField2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        Class<?> cls = Class.forName("com.star.reflection.Item");

        // 创建对象
        Constructor<?> constructor1 = cls.getConstructor(String.class, String.class, String.class);
        Item item2 = (Item) constructor1.newInstance("public", "private", "protected");

        // 访问共有属性
        System.out.println("-----public-----");
        Field publicStr = cls.getField("publicStr");
        System.out.println(publicStr.get(item2));
        publicStr.set(item2,"public2");
        System.out.println(publicStr.get(item2));

        // 访问私有属性
        System.out.println("-----private-----");
        Field privateStr = cls.getDeclaredField("privateStr");
        privateStr.setAccessible(true); // 爆破
        System.out.println(privateStr.get(item2));
        privateStr.set(item2,"private2");
        System.out.println(privateStr.get(item2));
    }
}

 

4、通过反射访问方法 

public class DemoMethod2 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        Class<?> cls = Class.forName("com.star.reflection.Item");

        // 创建对象
        Constructor<?> constructor1 = cls.getConstructor(String.class, String.class, String.class);
        Item item2 = (Item) constructor1.newInstance("public", "private", "protected");

        // 调用public修饰的方法
        Method hei = cls.getMethod("hi", String.class);
        hei.invoke(item2, "public");

        // 调用非public修饰的方法
        Method hei1 = cls.getDeclaredMethod("hei", String.class);
        hei1.setAccessible(true);
        hei1.invoke(item2, "private");
    }
}

 

注：笔记整理于B站韩顺平老师JAVA反射课程，致谢！