Java基础反射Reflection学习_reflection.initialize-CSDN博客

本文链接：https://blog.csdn.net/GayFei/article/details/110045982

反射Reflection

概述

Reflection(反射) 是被视为动态语言的关键，反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息，并且可以直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象)，这个对象就包含了完整的类的信息。我们可以根据这个对象看到类的内部结构。
Java反射机制提供主要的功能

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时获取任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理

反射相关主要API

java.lang.Class : 代表一个类通用来描述所有类的类
java.lang.reflect.Method : 代表类的方法
java.lang.reflect.Field : 代表类的成员变量
java.lang.reflect.Constructor : 代表类的构造器
……

@Test
    public void test() throws Exception {
        // 在User类的外部，是不可以直接调用User类的私有结构
        //User user = new User();
        //user.showNation();

        Class<User> clazz = User.class;
        // 通过反射获取构造器
        Constructor<User> cons = clazz.getConstructor(String.class, Integer.class);
        // 创建User对象
        User tom = cons.newInstance("Tom", 18);
        System.out.println(tom.toString());
        // 通过反射调用对象指定的方法和属性
        Field age = clazz.getDeclaredField("age");
        // 通过反射获取方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(tom);
        // 通过反射调用user私有属性、构造器和方法
        age.setAccessible(true);
        age.set(tom, 10);
        System.out.println(tom.toString());
        // 通过反射调用user私有构造器
        Constructor<User> cons1 = clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        User jerry = cons1.newInstance("Jerry");
        age.set(jerry, 12);
        System.out.println(jerry.toString());
        // 通过反射调用user私有方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        Object invoke = showNation.invoke(jerry, "USA");
        System.out.println(invoke);
    }

class User {

    private String name;

    private Integer age;

    public User() {
    }

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

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

    public void show() {
        System.out.println("hello user name tom age 18");
    }

    private String showNation(String nation) {
        System.out.println("nationality " + nation);
        return nation;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

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

Class类的理解

java.lang.Class类的理解
1、类的加载过程：程序经过Javac 命令以后会生成一个字节码文件(.class结尾)。接着使用java 命令对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中。这个过程就被成为类的加载，加载到内存中的类，称之为运行时类，此运行时类作为一个Class的实例。
2、也就是说，Class的实例就对应着一个运行时类
3、加载到内存中的运行时类，会缓存一定的时间。在此时间内，可以通过不同的方式来获取此运行时类

@Test
    public void test2() throws ClassNotFoundException { // 获取Class实例的方式
        // 方式一
        Class<User> clz = User.class;
        System.out.println(clz);
        // 方式二 通过运行时类的对象调用getClass()
        User user = new User();
        Class<? extends User> clz1 = user.getClass();
        System.out.println(clz1);
        // 方式三 调用Class的静态方法，Class.forName(String classPath)
        Class<?> clz2 = Class.forName("com.example.demo.day03.User");
        System.out.println(clz2);

        System.out.println(clz == clz2);
        System.out.println(clz == clz1);
        // 方式四 使用类的加载器 ClassLoader
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class<?> clz3 = classLoader.loadClass("com.example.demo.day03.User");
        System.out.println(clz3);
        System.out.println(clz == clz3);
        Class<Void> voidClass = void.class;

    }

哪些类型可以有Class对象

class外部类、成员(成员内部类、静态内部类)，局部内部类，匿名内部类
interface 接口
[] 数组
enum 枚举
annotation 注解@interface
primitive type 基本数据类型
void

@Test
    public void test3(){
        int[] a = new int[100];
        int[] b = new int[10];
        // 只要元素类型与维度一致 就是同一个Class
        System.out.println(a.getClass());
        System.out.println(a.getClass() == b.getClass());
        int[][] c = new int[10][10];
        System.out.println(c.getClass());
    }

类的加载过程简要描述

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过以下三个步骤来对该类进行初始化

类的加载 Load ：将类的class文件读入到内存，并为之创建一个java.lang.Class对象，此过程由类的加载器完成
类的链接 Link ：将类的二进制数据合并到JRE中
类的初始化 Initialize ：JVM负责对类进行初始化

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成为方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口(即引用地址)，所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。
链接：将Java类的二进制代码合并到JVM的运行状态之中的过程。

验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题
准备：正式为类变量(static)分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
解析：虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。

初始化

执行 类构造器<clinit>() 方法的过程，类构造器<clinit>() 方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的，不是构造该类对象的构造器)。
当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发父类的初始化。
虚拟机会保证一个类的类构造器<clinit>() 方法在多线程环境中内正确的加锁和同步。

ClassLoader
在这里插入图片描述
类的加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成为方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口
类缓存：标准的JavaSE类加载器可以按要求查找类，一旦某个类的被加载到类加载器中，它将会维持加载(缓存一段时间)，JVM垃圾回收机制可以回收这些Class对象。
JVM规范定义的类的加载器

引导类加载器：是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取
扩展类加载器：负责jre/lib/ext 目录下的jar包，或者-D java.ext.dirs指定目录下的jar包装入工作库。
系统类加载器：负责java -classpath或-D java.class.path指定的目录下的类与jar包装入工作是常用的类的加载器

    @Test
    public void test(){

        // 对于自定义类 使用系统类的加载器
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2 系统类的加载器

        // 调用系统类加载器的.getParent() 获取扩展类加载器
        ClassLoader parent = classLoader.getParent();
        System.out.println(parent); //sun.misc.Launcher$ExtClassLoader@776ec8df 扩展类加载器

        // 调用扩展类加载器.getParent() 无法直接获取引导类加载器
        // 引导类加载器负责加载Java平台核心库 无法加载自定义类
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1); //null 无法直接获取引导类加载器


        ClassLoader classLoader1 = String.class.getClassLoader();
        System.out.println(classLoader1); //null String 也无法无法直接获取引导类加载器 也说明是引导类加载器加载的

    }

获取运行时类的完整结构

package com.example.demo.day03;

import org.apache.commons.lang3.StringUtils;
import org.junit.Test;

import java.util.Random;


/**
 * 通过反射创建对应的运行时类对象
 *
 * @author zjt
 * @date 2020-11-25
 */
public class NewInstanceTest {


    @Test
    public void test() throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        // .newInstance() 调用此方法创建对应的运行时类的对象
        // 要求 使用 .newInstance()方法提供空参构造器，且权限通常设置为public
        ClassLoader classLoader = NewInstanceTest.class.getClassLoader();
        Class<?> clazz = classLoader.loadClass("com.example.demo.day03.User");
        User user = (User) clazz.newInstance(); // 调用的是空参构造器
        System.out.println(user);

    }

    // 体现反射的动态性
    @Test
    public void test2() {
        for (int i = 0; i < 100; i++) {
            int num = new Random().nextInt(3);
            String classPath;
            switch (num) {
                case 0:
                    classPath = "java.util.Date";
                    break;
                case 1:
                    classPath = "java.lang.Object";
                    break;
                case 2:
                    classPath = "com.example.demo.day03.User";
                    break;
                default:
                    classPath = "";
            }
            if (StringUtils.isNotBlank(classPath)) {
                try {
                    Object instance = getInstance(classPath);
                    System.out.println(instance);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }


    // 此方法创建一个指定类的对象
    // classPath 指定类的全类名
    public Object getInstance(String classPath) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Class<?> clz = Class.forName(classPath);
        return clz.newInstance();
    }
}

package com.example.demo.day04;

import java.io.Serializable;

/**
 * @author zjt
 * @date 2020-11-25
 */
public class Biology<T> implements Serializable {

    public double weight;
    private String gender;

    private void breath() {
        System.out.println("呼吸");
    }

    public void eat() {
        System.out.println("eat");
    }

}

package com.example.demo.day04;

import java.io.IOException;

/**
 * @author zjt
 * @date 2020-11-25
 */
@MyAnnotation(value = "Person")
public class Person extends Biology<String> implements Comparable<String>, MyInterface {

    public Integer id;

    Integer age;

    private String name;

    private Person(String name) {
        this.name = name;
    }

    Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @MyAnnotation(value = "hello")
    public Person(String name, Integer age, Integer id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    @MyAnnotation
    private String show(String nation) throws ClassCastException {
        System.out.println("country " + nation);
        return nation;
    }

    public String display(String display, Integer year) throws IndexOutOfBoundsException, IOException {
        return display;
    }

    @Override
    public void info() {
        System.out.println("天才");

    }

    @Override
    public int compareTo(String o) {
        return o.compareTo(this.toString());
    }
}

package com.example.demo.day04;

/**
 * @author zjt
 * @date 2020-11-25
 */
public interface MyInterface {
    void info();
}

package com.example.demo.day04;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;

/**
 * @author zjt
 * @date 2020-11-25
 */
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

    String value() default "Hi";
}

package com.example.demo.day04;

import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.*;

/**
 * 获取当前运行时类的方法结构
 *
 * @author zjt
 * @date 2020-11-25
 */
public class MethodTest {


    @Test
    public void test() {
        Class<Person> clz = Person.class;
        // getMethods() 获取当前运行时类以及父类中声明为public权限的方法
        Method[] methods = clz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("-----------------------");
        // getDeclaredMethods() 获取本类中所有方法(不包括父类)
        Method[] declaredMethods = clz.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
        System.out.println();
        System.out.println("-----------------------");
        System.out.println();
        // 声明的注解
        // 方法包含的结构  权限修饰符 返回值类型 方法名 (参数列表)  抛出异常
        for (Method method : declaredMethods) {
            // 获取方法声明的注解
            Annotation[] annotations = method.getDeclaredAnnotations();
            for (Annotation annotation : annotations) {
                System.out.print(annotation + "\t");
            }
            // 获取方法的权限修饰符
            int modifiers = method.getModifiers();
            String s = Modifier.toString(modifiers);
            System.out.print(s + "\t");

            //返回值类型
            Class<?> type = method.getReturnType();
            System.out.print(type + "\t");
            // 方法名
            String name = method.getName();
            System.out.print(name + "\t");

            // 形参列表
            System.out.print("(");
            Class<?>[] types = method.getParameterTypes();
            if (types.length > 0) {
                for (int i = 0; i < types.length; i++) {
                    Class<?> type1 = types[i];
                    if (i == types.length - 1) {
                        System.out.print(type1.getName() + " args_" + i);
                    } else {
                        System.out.print(type1.getName() + " args_" + i + ",");
                    }
                }
            }
            System.out.print(")");
            // 抛出的异常
            Class<?>[] exceptionTypes = method.getExceptionTypes();
            if (exceptionTypes.length > 0)
                System.out.print(" throws ");
            for (int i = 0; i < exceptionTypes.length; i++) {
                if (i == exceptionTypes.length - 1) {
                    System.out.print(exceptionTypes[i].getName());
                } else {
                    System.out.print(exceptionTypes[i].getName() + ",");
                }

            }
            System.out.println();
        }
    }


    // 获取构造器
    @Test
    public void test2() {
        Class<Person> clz = Person.class;
        // getConstructors() 当前运行时类中的构造器
        Constructor<?>[] cons = clz.getConstructors();
        for (Constructor<?> con : cons) {
            System.out.println(con);
        }
        System.out.println("---------------------");
        // getDeclaredConstructors() 当前运行时类中声明所有的构造器
        Constructor<?>[] dCons = clz.getDeclaredConstructors();
        for (Constructor<?> con : dCons) {
            System.out.println(con);
        }

        System.out.println("---------------------");
        // 获取运行时类的父类
        Class<? super Person> superClz = clz.getSuperclass();
        System.out.println(superClz);

        System.out.println("---------------------");
        // 获取运行时类的带泛型的父类
        Type clzGenericSuperclass = clz.getGenericSuperclass();
        System.out.println(clzGenericSuperclass);
        System.out.println("---------------------");
        // 获取运行时类的带泛型的父类的泛型
        ParameterizedType paramType = (ParameterizedType) clzGenericSuperclass;
        Type[] arguments = paramType.getActualTypeArguments();
        for (Type argument : arguments) {
            System.out.println(argument.getTypeName());
        }
    }

    // 获取运行时类实现的接口
    @Test
    public void test3(){
        Class<Person> clz = Person.class;
        Class<?>[] interfaces = clz.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println(anInterface);
        }

        System.out.println();
        Class<? super Person> superClz = clz.getSuperclass(); // 父类
        Class<?>[] interfaces1 = superClz.getInterfaces();
        for (Class<?> aClass : interfaces1) {
            System.out.println(aClass);
        }
    }

    // 当前运行时类所在的包
    @Test
    public void test4(){
        Class<Person> clz = Person.class;
        Package aPackage = clz.getPackage();
        System.out.println(aPackage);
    }

    // 当前运行时类声明的注解
    @Test
    public void test5(){
        Class<Person> clz = Person.class;
        Annotation[] annotations = clz.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
    }
}

package com.example.demo.day04;

import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * 获取当前运行时类的属性结构
 *
 * @author zjt
 * @date 2020-11-25
 */
public class FieldTest {

    @Test
    public void test() {
        Class<Person> clazz = Person.class;
        // 获取Person属性结构
        // getFields() 获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("---------------------");
        // getDeclaredFields() 获取当前运行时类中所有的属性(不包含父类中声明的属性)
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }

        System.out.println("---------------------");
        // 权限修饰符  数据类型   变量名
        for (Field f : declaredFields) {
            // 获取权限修饰符 返回值int 类型
            int modifiers = f.getModifiers();
            String s = Modifier.toString(modifiers);
            System.out.print(modifiers + ":" + s + "\t");

            // 获取数据类型
            Class<?> type = f.getType();
            System.out.print(type + "\t");
            // 获取变量名
            String name = f.getName();
            System.out.println(name + "\t");
        }
    }
}

调用运行时类的指定结构

package com.example.demo.day04;

import org.junit.Test;

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

/**
 * 调用运行时类的指定结构：属性、方法、构造器
 *
 * @author zjt
 * @date 2020-11-25
 */
public class ReflectionTest {

    @Test
    // 操作运行时类的属性
    public void testField() throws Exception {
        Class<Person> clz = Person.class;
        // 创建运行时类的对象
        Person p = clz.newInstance();
        // 获取指定的属性
        // clz.getField("id"); 通常不采用此方式 原因是getField() 方法要求类中属性声明为public
//        Field id = clz.getField("id");
//        id.set(p, 18);
//        System.out.println(p.toString());
//        System.out.println("----------------");
        // 获取运行时类中指定变量名的属性
        Field name = clz.getDeclaredField("name");
        // 保证当前属性是可访问的
        name.setAccessible(true);
        // 设置属性值
        name.set(p, "Tom");
        System.out.println(p.toString());
    }

    @Test
    // 操作运行时类的方法
    public void testMethod() throws Exception {
        Class<Person> clz = Person.class;
        System.out.println("非静态方法");
        // 创建运行时类的对象
        Person p = clz.newInstance();
        // 获取指定的某个方法
        // getDeclaredMethod(String name, Class<?>... parameterTypes)
        // 参数一：指明获取的方法名称
        // 参数二：指明方法的形参列表
        Method show = clz.getDeclaredMethod("show", String.class);
        // 保证当前方法是可访问的
        show.setAccessible(true);
        // invoke(Object obj, Object... args) 参数一：方法的调用者 参数二：给形参赋值的实参
        // invoke() 方法的返回值对应类中调用的方法的返回值
        Object china = show.invoke(p, "China");
        System.out.println(china);
        System.out.println("非静态方法结束");

        System.out.println();
        System.out.println("静态方法");
        Method desc = clz.getDeclaredMethod("desc");
        desc.setAccessible(true);
        Object invoke = desc.invoke(clz);// void 方法对应的返回值是 null
        System.out.println(invoke);
        System.out.println("静态结束");

    }
    @Test
    // 调用运行时类指定的构造器
    public void testConstructor() throws Exception {
        Class<Person> clz = Person.class;
        // 获取指定的构造器
        // getDeclaredConstructor(Class<?>... parameterTypes) 指明构造器的形参列表
        Constructor<Person> cons = clz.getDeclaredConstructor(String.class);
        cons.setAccessible(true);
        // 创建运行时类的对象
        Person jerry = cons.newInstance("Jerry");
        System.out.println(jerry.toString());
    }
}

反射的应用：动态代理

代理设计模式原理简介：使用一个代理将对象包装起来，然后使用该代理对象取代原始对象，任何对原始对象的调用都要通过代理，代理对象决定是否以及何时将方法调用转到原始对象上。
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

package com.example.demo.day05;

/**
 * 静态代理 在编译期间就确定下来了
 *
 * @author zjt
 * @date 2020-11-26
 */
interface ClothFactory {

    void crateCloth();

}

// 代理类
class ProxyClothFactory implements ClothFactory {

    private final ClothFactory factory;

    public ProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }

    @Override
    public void crateCloth() {
        System.out.println("代理工厂准备工作");
        factory.crateCloth();
        System.out.println("代理工厂后续工作");
    }
}

// 被代理类
class NikeClothFactory implements ClothFactory {

    @Override
    public void crateCloth() {
        System.out.println("nike 生产一批毛衣");
    }
}

public class StaticProxyTest {

    public static void main(String[] args) {
        // 创建被代理类对象
        NikeClothFactory nike = new NikeClothFactory();
        // 创建代理类对象
        ProxyClothFactory factory = new ProxyClothFactory(nike);
        factory.crateCloth();
    }

}

package com.example.demo.day05;

import org.apache.logging.log4j.util.Strings;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.List;

/**
 * 动态代理
 *
 * @author zjt
 * @date 2020-11-26
 */

interface HotPot { // 火锅

    String getBedCharge(); // 锅底

    void dishes(List<String> dishes); //配菜

}

// 被代理类 麻辣火锅
class SpicyHotPot implements HotPot {

    @Override
    public String getBedCharge() {
        return "麻辣";
    }

    @Override
    public void dishes(List<String> dishes) {
        System.out.println("配菜有：" + Strings.join(dishes, ','));
    }
}

/**
 * 要实现动态代理，需要解决的问题
 * 问题一：如何根据加载到内存中的被代理类动态创建代理类及其对象？
 * 问题二：当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法？
 */
class ProxyFactory {
    // 调用此方法返回一个代理类的对象 --解决问题一
    public static <T> Object getProxyInstance(T t) { // T 被代理类的对象
        MyInvocationHandler<T> handler = new MyInvocationHandler<>();
        handler.bind(t);
        return Proxy.newProxyInstance(t.getClass().getClassLoader(), t.getClass().getInterfaces(), handler);
    }
}

class MyInvocationHandler<T> implements InvocationHandler {

    private T t; //需要使用被代理类的对象进行赋值

    public void bind(T t) {
        this.t = t;
    }
    // 方法的作用
    // 通过到代理类的对象，调用某个方法时 例如a 方法时，就会自动的调用方法：invoke()
    // 将被代理类要执行的方法a 的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // method:即为代理类对象调用的方法，此方法也就作为了被代理类要调用的方法
        // t 被代理类的对象
        return method.invoke(t, args); // 上述方法的返回值就作为当前类中invoke() 的返回值

    }
}

public class DynamicProxyTest {

    public static void main(String[] args) {
        SpicyHotPot spicyHotPot = new SpicyHotPot();
        // 代理类的对象
        HotPot proxyInstance = (HotPot) ProxyFactory.getProxyInstance(spicyHotPot);
        // 当通过代理类的对象调用方法时，会自动调用被代理类中同名的方法
        String bedCharge = proxyInstance.getBedCharge();
        System.out.println("锅底：" + bedCharge);
        proxyInstance.dishes(Arrays.asList("菠菜", "牛肉"));

        System.out.println("-------------------------");
        NikeClothFactory factory = new NikeClothFactory();
        ClothFactory clothFactory = (ClothFactory) ProxyFactory.getProxyInstance(factory);
        clothFactory.crateCloth();
    }

}