使用代理前

如下，我们创建了一个接口，然后实现接口方法，模拟了计算器的加法，传入两个数字返回结果。

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);
    }
}