目录

Java反射概述

Class类

        Class对象获取的三种方式：

        Class类的常用方法

                 动态加载机制：

通过反射调用构造方法

        Constructor类

 通过反射获取继承关系

通过反射访问字段（成员变量）

                获取字段值：

设置字段值 

通过反射调用方法 

动态代理

        代理模式：

        静态代理 

         JDK动态代理

---

Java反射概述

        Java反射就是在程序运行状态下，对于任意一个类，都能获取到类的所有信息，例如：属性，方法。对于任意一个对象，都能调用它的任意方法和属性。简单来说，反射就是在程序运行期间能够获取自身的信息。

        要了解反射，就必须要了解Class类。

Class类

        Class对象中包含了类的所有信息。要想获取类的信息，就必须先获取Class对象。

        Class对象获取的三种方式：

                Class类中得到构造方法是私有的，所有所有的Class对象都指向了某一个数据类型。

                方式一：通过一个类的静态变量class获取        

                Class cls = String.class;

                 方式二：通过某个类的实例对象的getClass()方法获取

                String s = "lmy";

                Class cls = s.getClass();

                方式三：通过Class类的静态方法Class.forName()获取--(需要知道类的完整类名)

                 Class cls = Class.forName("java.lang.String");

        Class类的常用方法

类型	访问方法	返回值类型	说明
包路径	getPackage()	Package 对象	获取该类的存放路径
类名称	getName()	String 对象	获取该类的名称
继承类	getSuperclass()	Class 对象	获取该类继承的类
实现接口	getlnterfaces()	Class 型数组	获取该类实现的所有接口
构造方法	getConstructors()	Constructor 型数组	获取所有权限为 public 的构造方法
	getDeclaredContruectors()	Constructor 对象	获取当前对象的所有构造方法
方法	getMethods()	Methods 型数组	获取所有权限为 public 的方法
	getDeclaredMethods()	Methods 对象	获取当前对象的所有方法
成员变量	getFields()	Field 型数组	获取所有权限为 public 的成员变量
	getDeclareFileds()	Field 对象	获取当前对象的所有成员变量

                 动态加载机制：

                      JVM执行Java程序时，并不是一次性把所有用到的class全部加载到内存，而是第一次需要用时才加载。

通过反射调用构造方法

        通过反射调用构造方法来创建对象实例，可以调用Class类提供的newInstance()方法：

                String s = "lmy";

                Class cls = s.getClass();

                String s1 = cls.newInstance();  

         newInstance()只能调用该类的public无参构造。

        Constructor类

                为了调用任意的构造方法，Java的反射API提供了Constructor对象，它包含一个构造方法的所有信息，可以创建一个实例。

                 getConstructor(Class...)：获取某个public的Constructor

Constructor cons = Integer.class.getConstructor(int.class);

Integer n1 = (Integer)cons.newInstance(123);

             getDeclaredConstructor(Class...)：获取某个定义的Constructor

                 

Constructor cons = Integer.class.getDeclaredConstructor(int.class);

Integer n1 = (Integer)cons.newInstance(123);

                 getConstructors()：获取所有public的Constructor

                getDeclaredConstructors()：获取所有定义的Constructor

        Constructor类总结：

                Constructor对象封装了构造方法的所有信息；

                通过Class实例的方法可以获取Constructor实例：getConstructor()，getConstructors()，getDeclaredConstructor()，getDeclaredConstructors()；

                通过Constructor实例可以创建一个实例对象：newInstance(Object... parameters)； 通过设置setAccessible(true)来访问非public构造方法。

 通过反射获取继承关系

        可以通过Class实例的getSuperClass()方法来获取父类信息

                例如：        

                        

        Class i = Integer.class;
        Class n = i.getSuperclass();
        System.out.println(n);
        
        Class o = n.getSuperclass();
        System.out.println(o);
        System.out.println(o.getSuperclass());
        /*
            运行上述代码，可以看到，Integer的父类类型是Number，
        Number的父类是Object，Object的父类是null。
    除Object外，其他任何非interface的Class都必定存在一个父类类型。

        */

               通过getInterfaces()可以获取到实现的接口类型

                

        Class s = Integer.class;
        Class[] is = s.getInterfaces();
        for (Class i : is) {
            System.out.println(i);
        }

                如果两个Class实例，要判断一个向上转型是否成立，可以调用isAssignableFrom()

        

// Integer i = ?
Integer.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Integer

// Number n = ?
Number.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Number

// Object o = ?
Object.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Object

// Integer i = ?
Integer.class.isAssignableFrom(Number.class); // false，因为Number不能赋值给Integer

通过反射访问字段（成员变量）

        Class类提供了以下几个方法来获取字段：

                Field getField(name)：根据字段名获取当前类中某个public的field（包括父类）
                Field getDeclaredField(name)：根据字段名获取当前类中定义的某个field（不包括父类）
                Field[] getFields()：获取所有public的field（包括父类）
                Field[] getDeclaredFields()：获取当前类中定义的所有field（不包括父类）

         一个Field对象包含了一个字段的所有信息：
                getName()：返回字段名称，例如，"name"；
                getType()：返回字段类型，也是一个Class实例，例如，String.class；
                getModifiers()：返回字段的修饰符，它是一个int，不同的bit表示不同的含义。

                获取字段值：

                        

public class Main {

    public static void main(String[] args) throws Exception {
        Object p = new Person("贝吉塔");
        
        Class c = p.getClass();
        
        Field f = c.getDeclaredField("name");
        //设置访问权限。（可以访问private 修饰的字段值）
        f.setAccessible(true);
        
        Object value = f.get(p);
        
        System.out.println(value); // "贝吉塔"
    }
}

class Person {
    private String name;

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

设置字段值 

public class Main {

    public static void main(String[] args) throws Exception {
        Person p = new Person("Xiao Ming");
        System.out.println(p.getName()); // "Xiao Ming"
        
        Class c = p.getClass();
        Field f = c.getDeclaredField("name");
        f.setAccessible(true);
        f.set(p, "Xiao Hong");
        
        System.out.println(p.getName()); // "Xiao Hong"
    }
}

class Person {
    private String name;

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

    public String getName() {
        return this.name;
    }
}

 访问字段小结

        Java的反射API提供的Field类封装了字段的所有信息：
        通过Class实例的方法可以获取Field实例：getField()，getFields()，getDeclaredField()，getDeclaredFields()；
        通过Field实例可以获取字段信息：getName()，getType()，getModifiers()；
        通过Field实例可以读取或设置某个对象的字段，如果存在访问限制，要首先调用setAccessible(true)来访问非public字段。
        通过反射读写字段是一种非常规方法，它会破坏对象的封装。

通过反射调用方法 

        Class实例可以获取所有方法（Method类型的对象）。

        Method getMethod(name, Class...)：获取某个public的Method（包括父类）
        Method getDeclaredMethod(name, Class...)：获取当前类的某个Method（不包括父类）
        Method[] getMethods()：获取所有public的Method（包括父类）
        Method[] getDeclaredMethods()：获取当前类的所有Method（不包括父类

        一个Method对象包含一个方法的所有信息：

                getName()：返回方法名称，例如："getScore"；
                getReturnType()：返回方法返回值类型，也是一个Class实例，例如：String.class；
                getParameterTypes()：返回方法的参数类型，是一个Class数组，例如：{String.class, int.class}；
                getModifiers()：返回方法的修饰符，它是一个int，不同的value表示不同的访问修饰符；

         调用方法：        

                当我们获取到一个Method对象时，就可以对它进行调用。

                

public class Main {
    public static void main(String[] args) throws Exception {
        // String对象:
        String s = "Hello world";
        
        // 获取String substring(int)方法，参数为int:
        Method m = String.class.getMethod("substring", int.class);
        
        // 在s对象上调用该方法并获取结果:
        String r = (String) m.invoke(s, 6);
        
        // 打印调用结果:
        System.out.println(r);
    }
}

             调用静态方法：

                调用静态方法只需要将invoke()方法的第一个参数改为null即可。

                例如：

                        

public class Main {
    public static void main(String[] args) throws Exception {
        // 获取Integer.parseInt(String)方法，参数为String:
        Method m = Integer.class.getMethod("parseInt", String.class);
        
        // 调用该静态方法并获取结果:
        Integer n = (Integer) m.invoke(null, "12345");
        
        // 打印调用结果:
        System.out.println(n);
    }
}

         对于非public的方法，类似Field，通过Method.setAccessible(true)允许其调用。

                            

public class Main {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        Method m = p.getClass().getDeclaredMethod("setName", String.class);
        m.setAccessible(true);
        m.invoke(p, "Bob");
        System.out.println(p.name);
    }
}

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

        多态

                 我们来考察这样一种情况：一个Person类定义了hello()方法，并且它的子类Student也覆写了hello()方法，那么，从Person.class获取的Method，作用于Student实例时，调用的方法到底是哪个？

        

public class Main {
    public static void main(String[] args) throws Exception {
        // 获取Person的hello方法:
        Method h = Person.class.getMethod("hello");
        
        // 对Student实例调用hello方法:
        h.invoke(new Student());
    }
}

class Person {
    public void hello() {
        System.out.println("Person:hello");
    }
}

class Student extends Person {
    public void hello() {
        System.out.println("Student:hello");
    }
}

            运行上述代码，发现打印出的是Student:hello，因此，使用反射调用方法时，仍然遵循多态原则：即总是调用实际类型的覆写方法（如果存在）。

动态代理

        了解动态代理之前，先了解以下代理模式（Java设计模式的一种）

        代理模式：

                给某一个对象提供一个代理，并由代理对象来控制对真实对象的访问。代理模式是一种结构型设计模式。

                代理模式角色分为3种

                        Subject（抽象主题角色）：定义代理类和真实主题的公共对外方法，通常被设计成接口；
                        RealSubject（真实主题角色）：真正实现业务逻辑的类；
                        Proxy（代理主题角色）：用来代理和封装真实主题；

                

 如果根据字节码的创建时机来分类，可以分为静态代理和动态代理：
        所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和真实主题角色的关系在运行前就确定了。
        而动态代理的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以在运行前并不存在代理类的字节码文件

        静态代理 

                假设有UserService接口及其实现类UserServiceImpl，我们需要在不改变实现类代码的基础上，增加日志记录的功能。

        

public interface UserService {
    public void select();   
    public void update();
}

public class UserServiceImpl implements UserService {  
    public void select() {  
        System.out.println("查询 selectById");
    }
    public void update() {
        System.out.println("更新 update");
    }
}

 我们将通过静态代理对 UserServiceImpl 进行功能增强，在调用select和update之前记录一些日志。
静态代理通过 UserServiceProxy实现，代理类同时也需要实现 UserService接口。

public class UserServiceProxy implements UserService {
    private UserService target; // 被代理的对象

    public UserServiceProxy(UserService target) {
        this.target = target;
    }
    public void select() {
        before();
        target.select();    // 这里才实际调用真实主题角色的方法
        after();
    }
    public void update() {
        before();
        target.update();    // 这里才实际调用真实主题角色的方法
        after();
    }

    private void before() {     // 在执行方法之前执行
        System.out.println(String.format("log start time [%s] ", new Date()));
    }
    private void after() {      // 在执行方法之后执行
        System.out.println(String.format("log end time [%s] ", new Date()));
    }
}

         测试：

                

public class Test {
    public static void main(String[] args) {
        UserService userServiceImpl = new UserServiceImpl();
        UserService proxy = new UserServiceProxy(userServiceImpl);

        proxy.select();
        proxy.update();
    }
}

 通过静态代理，我们达到了功能增强的目的，而且没有侵入原代码，这是静态代理的一个优点。
虽然静态代理实现简单，且不侵入原代码，但是，当场景稍微复杂一些的时候，静态代理的缺点也会暴露出来。
1、 当需要代理多个类的时候，由于代理对象要实现与目标对象一致的接口，有两种方式：
        只维护一个代理类，由这个代理类实现多个接口，但是这样就导致代理类过于庞大
        新建多个代理类，每个目标对象对应一个代理类，但是这样会产生过多的代理类
2、 当接口需要增加、删除、修改方法的时候，目标对象与代理类都要同时修改，不易维护。

         JDK动态代理

                JDK动态代理主要涉及两个类：java.lang.reflect.Proxy java.lang.reflect.InvocationHandler。我们通过编写一个调用逻辑处理器 LogHandler 类案例来提供日志增强功能，并实现 InvocationHandler 接口；在 LogHandler 中维护一个目标对象，这个对象是被代理的对象（真实主题角色）；在 invoke()方法中编写方法调用的逻辑处理。

         动态代理的处理类

                

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Date;

public class LogHandler implements InvocationHandler {
    Object target;  // 被代理的对象，实际的方法执行者

    public LogHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法被调用");
        Object result = method.invoke(target, args);  // 调用 target 的 method 方法
        System.out.println("方法调用完毕");
        return result;  // 返回方法的执行结果
    }
   
}

        //测试类

                

import proxy.UserService;
import proxy.UserServiceImpl;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        
        // 1. 创建被代理的对象，UserService接口的实现类
        UserServiceImpl userServiceImpl = new UserServiceImpl();
        
        // 2. 获取对应的 ClassLoader
        ClassLoader classLoader = userServiceImpl.getClass().getClassLoader();
        
        // 3. 获取所有接口的Class，这里的UserServiceImpl只实现了一个接口UserService，
        Class[] interfaces = userServiceImpl.getClass().getInterfaces();
        
        // 4. 创建一个将传给代理类的调用请求处理器，处理所有的代理对象上的方法调用
        //     这里创建的是一个自定义的日志处理器，须传入实际的执行对象 userServiceImpl
        InvocationHandler logHandler = new LogHandler(userServiceImpl);
        /*
		   5.根据上面提供的信息，创建代理对象 在这个过程中，
               a.JDK会通过根据传入的参数信息动态地在内存中创建和.class 文件等同的字节码
               b.然后根据相应的字节码转换成对应的class，
               c.然后调用newInstance()创建代理实例
		 */
        UserService proxy = (UserService) Proxy.newProxyInstance(classLoader, interfaces, logHandler);
        
        // 调用代理的方法
        proxy.select();
        proxy.update();
    }
}

         动态代理在Java中有着广泛的应用，比如Spring AOP、Hibernate数据查询、测试框架的后端mock、RPC远程调用、Java注解对象获取、日志、用户鉴权、全局性异常处理、性能监控，甚至事务处理等。

        Java标准库提供了动态代理功能，允许在运行期动态创建一个接口的实例；
        动态代理是通过Proxy创建代理对象，然后将接口方法“代理”给InvocationHandler完成的。