上篇文章讲解了什么是静态代理，但是静态代理有一个问题就是需要建立很多的代理类，这样我们需要修改代理的方法的时候，需要在每个类中都要修改，这对于我们来说：当代理类很多的时候工作量就会成倍的增加。

       于是针对上述问题，人们就提出了解决方案，我们在运行中来实现代理类的创建，也就是今天要讲解的主题——动态代理，首先先说的是JDK自带的动态代理的实现。

         JDK自带的代理实现中最重要的两个内容：一是Proxy类，另一个是InvocationHandler接口。这两个是实现动态代理必须要用到的类和接口。

         1）对于InvocationHandler接口，API给出了这样的定义：           

     InvocationHandler 是代理实例的调用处理程序 实现的接口。

                每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，

                将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法

               

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

                   proxy：指代理的那个真实对象

 

                   method：指调用真是对象的某个方法Method对象

                   args：指调用真实对象某个方法时接受的参数

          2）Proxy类：

                提供用于创建动态代理类和实例的静态方法，它还是由newProxyInstance方法创建的所有动态代理类的超类。

               

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

               loader：定义代理类的类加载器

 

               interface：代理类要实现的接口列表

               h：指派方法调用处理程序

               返回值：一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口

                               也就是（返回一个由类加载器指定的代理类，它具有代理类Proxy中方法）这是我个人的理解

           以上已经对于JDK中用到的内容进行了简单的了解，接下来我们来看如何在代码中实现动态代理，

1、定义一个接口

    

public interface Hello {    void say(String name);}

2、定义一个类来实现这个接口，这个类就是我们的真实对象，HelloImpl

 

public class HelloImpl implements Hello {    @Override    public void say(String name) {        System.out.println("Hello!"+name);    }}

3、定义一个动态代理，每个动态代理类都必须实现InvocationHandler这个接口

public class DynamicProxy implements InvocationHandler {    private Object target;    public DynamicProxy(Object target){        this.target=target;    }    @SuppressWarnings("unchecked")    public 
    
      T getProxy(){        return (T) Proxy.newProxyInstance(                target.getClass().getClassLoader(),                target.getClass().getInterfaces(),                this        );    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        before();        Object result =method.invoke(target,args);        after();        return result;    }    private void before(){        System.out.println("Before");    }    private void after(){        System.out.println("After");    }}
    

4、接下来就是在客户端调用

public class Test {       public static void main(String[] args){        Hello hello =new HelloImpl();        DynamicProxy dynamicProxy = new DynamicProxy(hello);        Hello helloProxy=(Hello) Proxy.newProxyInstance(                hello.getClass().getClassLoader(),                hello.getClass().getInterfaces(),                dynamicProxy        );        helloProxy.say("Jack");            }}

问题：由于上述在客户端调用过程中，每次动态创建代理类都会使用newProxyInstance这个方法，我们对其进行一层封装，如下：

1、封装一个类，HelloProxy

public class HelloProxy implements Hello {    private  Hello hello;    public HelloProxy(){        hello=new HelloImpl();    }    @Override    public void say(String name) {        before();        hello.say(name);        after();    }    private void before(){        System.out.println("Before");    }    private void after(){        System.out.println("After");    }}

2、客户端调用

public class Test {       public static void main(String[] args){                DynamicProxy dynamicProxy=new DynamicProxy(new HelloImpl());        Hello helloProxy =dynamicProxy.getProxy();        helloProxy.say("Jack");            }}