前言：
二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。
使用代理前
如下，我们创建了一个接口，然后实现接口方法，模拟了计算器的加法，传入两个数字返回结果。
public interface Calculator {
int add(int i, int j);
}public class CalculatorImpl implements Calculator{
@Override
public int add(int i, int j) {
int result = i + j;
System.out.println("i+j="+result);
return result;
}
}
就是简单的调用方法然后返回数据
使用代理后
使用了代理就是相当于代理帮我们去调用方法，可以理解为生活中明星的经纪人
静态代理
public class CalculatorStaticProxy implements Calculator{
private CalculatorImpl target;
public CalculatorStaticProxy(CalculatorImpl target) {
this.target = target;
}
@Override
public int add(int i, int j) {
System.out.println("日志，方法：add，参数："+i+","+j);
int result = target.add(i, j);
System.out.println("日志，方法：add，结果：" + result);
return result;
}比如我们要在刚刚的add方法中加入一些日志功能，先创建一个代理类，实现接口的add方法，我们在接口类中声明一个CalculatorImpl类型的target，将它私有化，然后给一个构造方法，我们在日志中间加入内部方法，用构造方法传进来的CalculatorImpl类型的target来调用int result = target.add(i, j);即CalculatorImpl类的👇
public class CalculatorImpl implements Calculator{
@Override
public int add(int i, int j) {
int result = i + j;
System.out.println("i+j="+result);
return result;
}
}我们在测试类里测试一下
public class ProxyTest {
@Test
public void testProxy(){
CalculatorStaticProxy proxy = new CalculatorStaticProxy(new CalculatorImpl());
proxy.add(1,2);
}
}
静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。这就需要使用动态代理技术了
动态代理
动态代理通过自己的方式创建出代理对象，实际操作时候直接操作代理对象即可，解决了代码冗余的弊端。市面上常见的两种动态代理方式，jdk动态代理和cglib动态代理。
这里演示的是jdk动态代理。
JDK动态代理是jdk自带的，是通过java.lang.reflect.Proxy创建的代理对象，它的创建方式是通过传入java.lang.reflect.InvocationHandler匿名内部类的方式，在通过反射创建代理对象时让代理对象同时实现被代理的接口和java.lang.reflect.InvocationHandler接口，从而达到一个动态代理的目的。因此，jdk动态代理需要被代理对象实现一个接口。
创建一个代理工厂，之前创建对象都是new一个类的构造方法()，现在我们是使用Proxy类的方法，让他代替我们new一个类
public class ProxyFactory {
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
public Object getProxy() {
//classLoader：加载动态生成的代理类的类加载器
ClassLoader classLoader = this.getClass().getClassLoader();
//interfaces：目标对象实现的所有接口的class对象所组成的数组
Class<?>[] interfaces = target.getClass().getInterfaces();
/**invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接
口中的抽象方法*/
InvocationHandler handler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
/**
* proxy：代理对象
* method：代理对象需要实现的方法，即其中需要重写的方法
* args：method所对应方法的参数*/
System.out.println("日志，方法：" + method.getName() + ",参数：" + Arrays.toString(args));
Object result = method.invoke(target, args);
System.out.println("日志，方法：" + method.getName() + ",参数：" + result);
return result;
}
};
return Proxy.newProxyInstance(classLoader, interfaces, handler);
}
}测试一下
@Test
public void testProxy2(){
ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
Calculator proxy =(Calculator) proxyFactory.getProxy();
proxy.add(1,2);
}
}
