Java 反射与动态代理相关介绍

Java 反射与动态代理

反射概念介绍

反射机制是 Java 语言提供的一种基础功能，赋予程序在运行时自省（introspect）的能力。简单来说就是通过反射，可以在运行期间获取、检测和调用对象的属性和方法。
反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

使用场景

• 编程工具 IDEA 或 Eclipse 等，在写代码时会有代码（属性或方法名）提示，就是因为使用了反射。
• 很多知名的框架，为了让程序更优雅更简洁，也会使用到反射。
• 数据库连接池，也会使用反射调用不同类型的数据库驱动。

反射的基本使用

使用反射调用类中的方法，分为三种情况：

• 调用静态方法
• 调用公共方法
• 调用私有方法

  myClass = Class.forName("com.lzs.ccnu.utils.MyReflect");

            //反射调用静态方法
            Method method = myClass.getMethod("staticMd");
            method.invoke(myClass);

            // 创建实例对象（相当于 new ）,反射调用公共方法
            Object instance = myClass.newInstance();
            Method method2 = myClass.getMethod("publicMd");
            method2.invoke(instance);

            // 反射调用私有方法
            //Object instance = myClass.newInstance();
            Method method3 = myClass.getDeclaredMethod("privateMd");
            method3.setAccessible(true);
            method3.invoke(instance);

package com.lzs.ccnu.utils;

public class MyReflect {
    // 静态方法
    public static void staticMd() {
        System.out.println("Static Method");
    }
    // 公共方法
    public void publicMd() {
        System.out.println("Public Method");
    }
    // 私有方法
    private void privateMd() {
        System.out.println("Private Method");
    }
}

反射获取调用类可以通过 Class.forName()，反射获取类实例要通过 newInstance()，相当于 new 一个新对象，反射获取方法要通过 getMethod()，获取到类方法之后使用 invoke() 对类方法进行调用。如果是类方法为私有方法的话，则需要通过 setAccessible(true) 来修改方法的访问限制，以上的这些操作就是反射的基本使用。

动态代理

动态代理可以理解为，本来应该自己做的事情，却交给别人代为处理，这个过程就叫做动态代理。

使用场景

动态代理被广为人知的使用场景是 Spring 中的面向切面编程（AOP）。例如，依赖注入 @Autowired 和事务注解 @Transactional 等，都是利用动态代理实现的。

动态代理还可以封装一些 RPC 调用，也可以通过代理实现一个全局拦截器等。

动态代理和反射的关系

JDK 原生提供的动态代理就是通过反射实现的，但动态代理的实现方式还可以是 ASM（一个短小精悍的字节码操作框架）、cglib（基于 ASM）等，并不局限于反射。

• JDK 原生动态代理

interface Animal {
    void eat();
}
class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("The dog is eating");
    }
}
class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("The cat is eating");
    }
}

// JDK 代理类
class AnimalProxy implements InvocationHandler {
    private Object target; // 代理对象
    public Object getInstance(Object target) {
        this.target = target;
        // 取得代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用前");
        Object result = method.invoke(target, args); // 方法调用
        System.out.println("调用后");
        return result;
    }
}

public static void main(String[] args) {
    // JDK 动态代理调用
    AnimalProxy proxy = new AnimalProxy();
    Animal dogProxy = (Animal) proxy.getInstance(new Dog());
    dogProxy.eat();
}

以上代码，我们实现了通过动态代理，在所有请求前、后都打印了一个简单的信息。

注意： JDK Proxy 只能代理实现接口的类（即使是 extends 继承类也是不可以代理的）。

• cglib 动态代理
  要是用 cglib 实现要添加对 cglib 的引用，如果是 maven 项目的话，直接添加以下代码：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.12</version>
</dependency>

实现代码如下:

class Panda {
    public void eat() {
        System.out.println("The panda is eating");
    }
}
class CglibProxy implements MethodInterceptor {
    private Object target; // 代理对象
    public Object getInstance(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        // 设置父类为实例类
        enhancer.setSuperclass(this.target.getClass());
        // 回调方法
        enhancer.setCallback(this);
        // 创建代理对象
        return enhancer.create();
    }
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("调用前");
        Object result = methodProxy.invokeSuper(o, objects); // 执行方法调用
        System.out.println("调用后");
        return result;
    }
}
public static void main(String[] args) {
    // cglib 动态代理调用
    CglibProxy proxy = new CglibProxy();
    Panda panda = (Panda)proxy.getInstance(new Panda());
    panda.eat();
}

JDK 原生动态代理和 cglib 区别

• JDK 原生动态代理是基于接口实现的，不需要添加任何依赖，可以平滑的支持 JDK 版本的升级；
• cglib 不需要实现接口，可以直接代理普通类，需要添加依赖包，性能更高。