为什么要使用java动态代理

在设计模式中，我们最常用的或者经常听到的就是代理模式了吧。那么使用代理模式有什么作用呢？他可以在不修改别代理对象代码的基础上，通过扩展代理类，进行一些功能的附加与增强（例如Spring AOP中编写切面日志时，读到这里，相信你对代理模式并没有什么清晰的认识，下面我们就代码来看一下如此简单的代理模式！

---

在Java中主要分为静态代理和动态代理模式，动态代理是一种比较常用的代理模式，它让我们不需要手动去编写代理类，而只要去实现代理的扩展即可。

一、静态代理

静态代理

面向接口的编程，代理类与真实类继承自同一个接口（或者继承某个类），下面是具体的代码

• 接口

public interface Subject {
    void doSomething();
}

• 真实类继承自该接口

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("I'm watching s8 in Korea!");
    }
}

• 代理类在不影响真实类的情况下，实现功能的扩展

public class Proxy implements Subject {

    Subject subImp = new RealSubject();

    @Override
    public void doSomething() {
        subImp.doSomething();
        after();
    }
    public void after(){
        System.out.println("Congratulations to IG for winning the championship!");
    }
}

这里我们可以看到，代理类不仅实现了原有类中的功能在看s8，同时它又在为IG加油。下面进行测试：

public class Main {
    public static void main(String[] args) {
        Subject sub = new Proxy();
        sub.doSomething();
    }
}

得到结果如下：
I'm watching s8 in Korea!
Congratulations to IG for winning the championship!

二、动态代理

那么什么是动态代理呢，它通过java反射机制（关于java反射请看这里），获取某个被代理类的所有接口，并创建代理类。接口类和被代理类同上

• 动态代理类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Proxy1 implements InvocationHandler {

    private Object tar;

    //绑定委托对象并返回代理类
    public Object bind(Object tar) {
        this.tar = tar;
        return Proxy.newProxyInstance(tar.getClass().getClassLoader(),
                tar.getClass().getInterfaces(),
                this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        //这里可以进行类似于AOP的操作
        System.out.println(this.getClass().getSimpleName()+":G2 enters the quarterfinals"); //在调用具体函数方法前，执行功能扩展
        result = method.invoke(tar,args);
        System.out.println("EDG lost to AFS");//在调用具体函数方法后，执行功能处理
        return result;
    }
}

编写测试类：

    public static void main(String[] args) {
       Proxy1 proxy = new Proxy1();
        //返回一个实现该类所有接口的代理类
        Subject sub = (Subject)  proxy.bind(new RealSubject());
        sub.doSomething();
    }
}

可得到如下结果：

结果输出

可以看到，动态代理使我们免于去重写接口中的方法，而着重于去扩展相应的功能或是方法的增强，与静态代理相比简单了不少，减少了项目中的业务量

三、java动态代理类

动态代理

动态代理涉及了一个非常重要的类Proxy。正是通过Proxy的静态方法newProxyInstance才会动态创建代理

Proxy

public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)

• loader为类加载器
• interfaces被代理类的接口
• h为一个InvocationHandler对象

InvocationHandler

InvacationHandler为一个接口，每一个动态代理的实例都要继承自该接口，如果代理的方法被调用，那么代理便会通知和转发给内部的InvocationHandler实现类，由它决定处理

public interface InvocationHandler {

    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

• proxy为代理对象
• method为代理对象调用的方法
• args为方法中对应的参数

本文参考自：轻松学，Java 中的代理模式及动态代理（https://blog.csdn.net/briblue/article/details/73928350）
知乎（https://www.zhihu.com/question/20794107）