反射

1.反射理论

概念

反射：Reflection 将类的各个组成部分封装为其他对象，这就是反射机制。

Java 反射机制是在运行状态中，动态获取信息以及动态调用对象方法的功能

• 对于任意一个类，都能够知道这个类的所有属性和方法；

• 对于任意一个对象，都能够调用它的任意方法和属性；

• 生成动态代理

反射机制的相关类

类名	用途
java.lang.Class	代表类的实体，在运行的Java应用程序中表示类和接口
java.lang.reflect.Method	代表类的成员变量（成员变量也称为类的属性）
java.lang.reflect.Field	代表类的方法
java.lang.reflect.Constructor	代表类的构造方法

反射的源头 Class

java.lang.Class是反射的源头，我们创建了一个类，生成对应的.class文件，之后我们使用java.exe加载（ JVM 加载器完成）此.class文件，此.class文件加载到内存以后，就是一个运行时类，存在在缓存区，那么这个运行时类本身就是一个 Class 实例，每一个运行时类只加载一次。

泛型和 Class 类

• 在不使用泛型的时候，必须将利用反射得到的对象进行强制转换才可以对他进行相应的赋值。
• 在使用了泛型之后，可以方便地避免强制转换地操作

//不使用
public class YeekuObjectFactory {
    public static Object getInstance(String clsName){
        try{
            Class cls = Class.forName(clsName);
            return cls.newInstance();
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

public static void main(String args[]){
        Date d = (Date) YeekuObjectFactory.getInstance("java.util.Date");
//        甚至可以出现下面这种操作
//        JFrame jFrame = (Date) YeekuObjectFactory.getInstance("java.util.Date");
    }

//使用泛型
public class YeekuObjectFactoy2 {
    public static <T>T getInstance(Class<T> cls){
        try{
            return cls.newInstance();
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }
 
    public static void main(String args[]){
        Date d = YeekuObjectFactoy2.getInstance(Date.class);
        JFrame jFrame = YeekuObjectFactoy2.getInstance(JFrame.class);
    }
}

2.类的加载

2.1.类的加载过程

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

类加载过程：加载->连接->初始化。连接过程又可分为三步:验证->准备->解析。参考

• 一个非数组类的加载阶段（加载阶段获取类的二进制字节流的动作）是可控性最强的阶段，这一步我们可以去完成还可以自定义类加载器去控制字节流的获取方式（重写一个类加载器的 loadClass() 方法）。
• 数组类型不通过类加载器创建，它由 Java 虚拟机直接创建。但是因为数组类的元素类型（Element Type,指的是数组去掉所有维度的类型）,最终是要靠类加载器去创建。
• 所有的类都由类加载器加载，加载的作用就是将.class文件加载到内存。

2.2.类加载器

JVM 中内置了三个重要的 ClassLoader，除了 BootstrapClassLoader 其他类加载器均由 Java 实现且全部继承自java.lang.ClassLoader：

1. BootstrapClassLoader(启动类加载器) ：最顶层的加载类，由C++实现，负责加载 %JAVA_HOME%/lib目录下的 jar 包和类或者或被 -Xbootclasspath参数指定的路径中的所有类。
2. ExtensionClassLoader(扩展类加载器) ：主要负责加载目录 %JRE_HOME%/lib/ext 目录下的 jar 包和类，或被 java.ext.dirs 系统变量所指定的路径下的 jar 包。
3. AppClassLoader(应用程序类加载器) :面向我们用户的加载器，负责加载当前应用classpath下的所有 jar 包和类。

2.3.双亲委派

每一个类都有一个对应它的类加载器。系统中的 ClassLoder 在协同工作的时候会默认使用 双亲委派模型 。

• 即在类加载的时候，系统会首先判断当前类是否被加载过。

• 已经被加载的类会直接返回，否则才会尝试加载。

• 加载的时候，首先会把该请求委派该父类加载器的 loadClass() 处理，因此所有的请求最终都应该传送到顶层的启动类加载器 BootstrapClassLoader 中。

• 当父类加载器无法处理时，才由自己来处理。

• 当父类加载器为 null 时，会使用启动类加载器 BootstrapClassLoader 作为父类加载器。

  

好处

• 双亲委派模型保证了Java程序的稳定运行，可以避免类的重复加载（ JVM 区分不同类的方式不仅仅根据类名，相同的类文件被不同的类加载器加载产生的是两个不同的类），也保证了 Java 的核心 API 不被篡改。
• 如果没有使用双亲委派模型，而是每个类加载器加载自己的话就会出现一些问题，比如我们编写一个称为 java.lang.Object 类的话，那么程序运行的时候，系统就会出现多个不同的 Object 类。

取消双亲委派

为了避免双亲委托机制，我们可以自己定义一个类加载器，然后重写 loadClass() 即可。

自定义类加载器

除了 BootstrapClassLoader 其他类加载器均由 Java 实现且全部继承自java.lang.ClassLoader。如果我们要自定义自己的类加载器，很明显需要继承 ClassLoader。

相关方法

//1.获取一个系统类加载器
ClassLoader classloader = ClassLoader.getSystemClassLoader();
//2.获取系统类加载器的父类加载器，即扩展类加载器
Classloader = classloader.getParent();
//3.获取扩展类加载器的父类加载器，即引导类加载器
Classloader = classloader.getParent();
//4.测试当前类由哪个类加载器进行加载
Classloader = Class.forName("exer2.ClassloaderDemo").getClassLoader();
//5.测试JDK提供的Object类由哪个类加载器加载
Classloader = Class.forName("java.lang.Object").getClassLoader();
//*6.关于类加载器的一个主要方法：getResourceAsStream(String str):获取类路径下的指定文件的输入流
InputStream in = null;
in = this.getClass().getClassLoader().getResourceAsStream("exer2\\test.properties");
System.out.println(in);

3.反射的使用

3.1实例化 class 对象

1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象

   • 多用于配置文件，将类名定义在配置文件中。读取文件，加载类

2. 类名.class：通过类名的属性class获取

• 多用于参数的传递，最为安全可靠，程序性能最高

3. 对象.getClass()：getClass()方法在Object类中定义着。

• 多用于对象的获取字节码的方式

4. 类加载器：

   ClassLoader cl = this.getClass().getClassLoader();
   
   Class clazz4 = cl.loadClass(“类的全类名”);
   

注意

同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的 Class对象都是同一个。

有了Class 对象，能做什么？

• T newInstance(Object... initargs) ：创建对象
  • 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

//1.根据全类名获取对应的Class对象
String name = “atguigu.java.Person";
Class clazz = null;
clazz = Class.forName(name);
//2.调用指定参数结构的构造器，生成Constructor的实例
Constructor con = clazz.getConstructor(String.class,Integer.class);
//3.通过Constructor的实例创建对应类的对象，并初始化类属性
Person p2 = (Person)con.newInstance("Peter",20);
System.out.println(p2);

3.2. 获取运行时类的完整结构

写在前面：

• 带有Declared修饰的方法可以反射到私有的方法。

• 没有Declared修饰的只能用来反射public 的方法。

实现的全部接口

• Class getInterfaces() ：确定此对象所表示的类或接口实现的接口

所继承的父类

• public Class<? Super T> getSuperclass(): 返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的 Class。

获取成员变量

• Field[] getFields() ：获取所有 public 修饰的成员变量
  • Field getField(String name): 获取指定名称的 public 修饰的成员变量
• Field[] getDeclaredFields() ：获取所有的成员变量，不考虑修饰符
  * Field getDeclaredField(String name) ：获取指定名称的成员变量

Field方法中：

1. public int getModifiers()：以整数形式返回此 Field的修饰符
2. public Class<?> getType() ：得到 Field的属性类型
3. public String getName() ：返回 Field的名称。

获取构造方法

• Constructor<?>[] getConstructors()：获取所有 public 修饰的构造方法

    * `Constructor<T> getConstructor(类<?>... parameterTypes)  `：获取指定参数类型且 public 修饰的成员变量
    * `Constructor<?>[] getDeclaredConstructors()`：获取类声明的所有构造方法
    * `Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)`：获得该类中与参数类型匹配的构造方法
  

Constructor类中：

1. public int getModifiers()： 取得修饰符
2. public String getName()：取得方法名称
3. public Class<?>[] getParameterTypes()：取得参数的类型

获取成员方法

• Method[] getMethods()：获取所有 public 修饰的成员方法
• Method getMethod(String name, 类<?>... parameterTypes) ：根据方法名和参数类型匹配来返回一个 public 的Method对象。
• Method[] getDeclaredMethods() ：获取所有 成员方法
• Method getDeclaredMethod(String name, 类<?>... parameterTypes)：根据方法名和参数类型匹配来返回一个Method对象。

Method类中：

1. public Class<?> getReturnType() : 取得全部的返回值
2. public Class<?>[] getParameterTypes() : 取得全部的参数
3. public int getModifiers() : 取得修饰符
4. public Class<?>[] getExceptionTypes() : 取得异常信息

Annotation 相关

• get Annotation(Class<T> annotationClass)：返回改程序元素上存在的、指定类型的注解，如果该类型注解不存在，则返回 null。
• getDeclaredAnnotations()：返回直接存在于此元素上的所有注释。

泛型相关

• Type getGenericSuperclass()：获取父类泛型类型
• ParameterizedType：泛型类型
• getActualTypeArguments()：获取实际的泛型类型参数数组

包

• Package getPackage()：类所在的包

3.3.调用指定属性及指定方法

调用指定 Method

1. getMethod(String name,Class…parameterTypes)：方法取得一个Method对象，并设置此方法操作时所需要的参数类型
2. Object invoke(Object obj, Object... args)：调用，并向方法中传递要设置的obj对象的参数信息。
   • Object 对应原方法的返回值，若原方法无返回值，此时返回 null
   • 若原方法若为静态方法，此时形参Object obj可为 null
   • 若原方法形参列表为空，则Object[] args为 null
   • 若原方法声明为 private ,则需要在调用此 invoke() 方法前，显式调用方法对象的setAccessible(true)方法，将可访问 private 的方法。
   • setAccessible(true): 暴力反射; 忽略访问权限修饰符的安全检查

调用指定属性

在反射机制中，可以直接通过Field类操作类中的属性，通过Field类提供的 set() 和 get() 方法就可以完成设置和取得属性内容的操作。

• void set(Object obj, Object value) ：设置指定对象obj上此Field的属性内容
• get(Object obj)：取得指定对象obj上此Field的属性内容
• setAccessible(true): 暴力反射; 忽略访问权限修饰符的安全检查

4.动态代理

利用反射机制在运行时创建代理类。达到不修改源码的基础上对方法增强。字节码随用随创建，随用随加载。

更多请参考

4.1. Proxy(基于接口)

基于 JDK 实现动态代理，通过 jdk 提供的工具方法Proxy.newProxyInstance动态构建全新的代理类字节码文件并实例化对象返回。

• 继承Proxy类，并持有InvocationHandler接口引用
• jdk 动态代理是由 java 内部的反射机制来实例化代理对象，并代理的调用委托类方法

实现

• 创建代理对象的要求：被代理类最少实现一个接口，如果没有则不能使用

• newProxyInstance方法的参数：

  • ClassLoader：类加载器：它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
  • Class[]：字节码数组：它是用于让代理对象和被代理对象有相同方法。固定写法。
  • InvocationHandler：用于提供增强的代码
    • 它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
    • 此接口的实现类都是谁用谁写。

/**
 * 模拟一个消费者
 */
public class Client {

    public static void main(String[] args) {
        final Producer producer = new Producer();
        
       IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 作用：执行被代理对象的任何接口方法都会经过该方法
                     * 方法参数的含义
                     * @param proxy   代理对象的引用
                     * @param method  当前执行的方法
                     * @param args    当前执行方法所需的参数
                     * @return        和被代理对象方法有相同的返回值
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //提供增强的代码
                        Object returnValue = null;

                        //1.获取方法执行的参数
                        Float money = (Float)args[0];
                        //2.判断当前方法是不是销售
                        if("saleProduct".equals(method.getName())) {
                            returnValue = method.invoke(producer, money*0.8f);
                        }
                        return returnValue;
                    }
                });
        proxyProducer.saleProduct(10000f);
    }
}

4.2. Enhancer（基于子类）

提供者：第三方cglib库

使用

• 使用 Enhancer 类中的 create 方法
• 创建代理对象的要求： 被代理类不能是最终类
• create方法的参数：
  • Class：字节码：它是用于指定被代理对象的字节码。
  • Callback：用于提供增强的代码
    • 它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
    • 此接口的实现类都是谁用谁写。
    • 我们一般写的都是该接口的子接口实现类：MethodInterceptor

/**
 * 模拟一个消费者
 */
public class Client {

    public static void main(String[] args) {
        final Producer producer = new Producer();
        
        Producer cglibProducer = (Producer)Enhancer.create(producer.getClass(), new MethodInterceptor() {
            /**
             * 执行被代理对象的任何方法都会经过该方法
             * @param proxy
             * @param method
             * @param args
             *    以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
             * @param methodProxy ：当前执行方法的代理对象
             * @return
             * @throws Throwable
             */
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                //提供增强的代码
                Object returnValue = null;

                //1.获取方法执行的参数
                Float money = (Float)args[0];
                //2.判断当前方法是不是销售
                if("saleProduct".equals(method.getName())) {
                    returnValue = method.invoke(producer, money*0.8f);
                }
                return returnValue;
            }
        });
        cglibProducer.saleProduct(12000f);
    }
}