声明：本文中通过Java的动态代理实现的拦截器只是能够在目标方法执行之前、之后调用拦截器方法，属于比较初级的应用。
在软件开发领域，有一条很重要的规则：Don’t Repeat Yourself，即DRY规则，意思是不要书写重复的代码。此处所说的重复的代码是指功能性的代码，比如在很多方法里面用到排序，就可以将排序方法提取出来，写成一个功能方法，在需要用到的地方调用一下即可。这样做，比重复书写（或者使用复制、粘贴）相同的代码节省时间，而且更有益于软件后期的升级、维护中。
拦截器更是对调用方法的改进。拦截器只是一种行为，从代码的角度，拦截器是一个类，包含方法，只是这个方法可以在目标方法调用之前“自动”执行（所谓自动，是指无需开发者关心，由系统来驱动调用）。
首先定义一个Dog接口，因为JDK动态代理只能对实现了接口的实例生成代理。
public interface Dog { // info方法声明 public void info(); // run方法声明 public void run(); // stand方法声明 public void stand(); }
为了正常使用该Dog实例，需提供该接口的实现类。
public class DogImpl implements Dog{ public void info() { System.out.println("猎狗"); } public void run() { System.out.println("飞速移动中。。。"); } public void stand(){ System.out.println("站立不动。"); } }
上面代码没有丝毫特别，比较常见的定义接口，并实现接口。
下面实现拦截Dog实例的拦截器类：
public class DogIntercepter { public void method1() { System.out.println("=======模拟通用方法一======"); } public void method2() { System.out.println("=======模拟通用方法二======"); } public void method3() { System.out.println("=======模拟通用方法三======"); } public void method4() { System.out.println("=======模拟通用方法四======"); } }
可以发现，上面的拦截器类只是一个普通的Java类。所以要想该拦截类实现其拦截的目的，就需要通知系统。关键就在下面的ProxyHandler类了。该类需要实现InvocationHandler接口，InvocationHandler是代理实例的调用处理程序实现的接口。每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。
public class ProxyHandler implements InvocationHandler{ // 需要代理的目标对象 private Object target; // 创建拦截器实例 DogIntercepter di = new DogIntercepter(); // 执行代理的目标方法时，该invoke方法会被自动调用。 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result = null; // 如果被调用方法的方法名为info if(method.getName().equals("info")){ di.method1(); result = method.invoke(target, args); di.method2(); } else if ("run".equals(method.getName())){ di.method3(); result = method.invoke(target, args); di.method4(); } else { result = method.invoke(target, args); } return result; } // 用于设置传入目标对象的方法 public void setTarget(Object o) { this.target = o; } }
可以看到，ProxyHandler类与Dog类没有丝毫关联之处（如果说info是Dog的方法名，但是info方法是否属于Dog实例，却没有限定，因此，可以认为ProxyHandler与Dog实例没有丝毫关联），这样就实现了Dog实例与拦截器类的解耦（解耦这个词用在这个地方只是显得很很牛的样子，实际上在ProxyHandler中的info方法使用的是字符串，相对于直接调用，不易排错，仁者见仁智者见智吧）。
通过ProxyHandler类，系统实现了在执行info方法之前，调用拦截器method1方法，在执行info方法之后，调用拦截器method2方法（run方法类似）。
到了此时，系统还需要一个能够根据目标对象生成一个代理对象的代理工厂。代理工厂负责根据目标对象和对应的拦截器生成新的代理对象，代理对象里的方法时目标方法和拦截器方法的组合。
public class MyProxyFactory { /** * 实例Service对象 */ public static Object getProxy(Object objext) throws Exception { // 代理的处理类 ProxyHandler handler = new ProxyHandler(); // 把该Dog实例托付给代理操作 handler.setTarget(objext); // return Proxy.getProxyClass(DogImpl.class.getClassLoader(), objext.getClass().getInterfaces()) // .getConstructor(new Class[]{InvocationHandler.class}) // .newInstance(new Object[]{handler}); // 等价于： // 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。 // 第一个参数是用来创建动态代理的ClassLoader对象，只要该对象能访问Dog接口即可 // 第二个参数是接口数组，代理该接口数组。代理类要实现的接口列表。 // 第三个参数是代理包含的处理实例，指派方法调用的调用处理程序 。 return Proxy.newProxyInstance(DogImpl.class.getClassLoader(), objext.getClass().getInterfaces(), handler); } }
仔细研读上面代理工厂的返回对象是Proxy.newProxyInstance方法根据数组动态创建代理类实例的，第二个参数是获取代理类的接口数组，创建的代理类是JVM在内存中动态创建，该类实现参数里接口数组中的全部接口。因此，本文中的动态代理要求被代理的必须是接口的实现类，否则无法为其构造相应的动态实例。
下面编写主程序进行测试：
public class TestDog { public static void main(String[] args) throws Exception { // 创建一个Dog实例，该实例将被作为代理的目标对象 Dog targetObject = new DogImpl(); Dog dog = null; // 以目标对象创建代理 Object proxy = MyProxyFactory.getProxy(targetObject); if(proxy instanceof Dog){ dog = (Dog)proxy; } // 测试代理的方法 dog.info(); dog.run(); dog.stand(); } }
在主程序中，先创建一个Dog实例作为目标对象，然后以该目标对象为基础，创建该对象的代理对象（将拦截器方法和目标方法拼接在一起），生成的代理对象就能够有拦截器的效果了。
效果如图：
以上便是实现拦截器功能的动态代理的简单实现。
![[Java]代理模式](https://ucc.alicdn.com/3mfxe2r26qbaq/developer-article1631770/20241030/b2dd70a9c2904095849199017fa1e462.png?x-oss-process=image/resize,h_160,m_lfit)
