一文了解拦截器与拦截器链的实现

拦截器和拦截器链

本文中的拦截器是使用 JDK 动态代理来实现的
前文须知：JDK的动态代理☆★☆

1. 拦截器

package com.eric.proxy;

public interface Interceptor {
    void printInfo();
}

接着我们来设计一个拦截器的实现类，InterceptorImpl.java
：

package com.eric.proxy;

public class InterceptorImpl implements Interceptor {
    @Override
    public void printInfo() {
        System.out.println("执行拦截器中的方法");
    }
}

package com.eric.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JDKProxy implements InvocationHandler {
    private Object target;
    // 定义拦截器，使用全限定名
    private String interceptorClass;

    public JDKProxy(Object target, String interceptorClass) {
        this.target = target;
        this.interceptorClass = interceptorClass;
    }

    // 绑定带有拦截器的代理对象
    public static Object bind(Object target, String interceptorClass) {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), new JDKProxy(target, interceptorClass));
    }

    // 绑定不带有拦截器的代理对象
    public static Object bind(Object target) {
        return JDKProxy.bind(target, null);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 如果未设置拦截器，则直接返回原方法调用
        if (interceptorClass == null) {
            return method.invoke(target, args);
        }
        // 否则就是使用了拦截器
        Interceptor interceptor = (Interceptor) Class.forName(interceptorClass).newInstance();
        // 则先执行拦截器之中的处理逻辑
        interceptor.printInfo();
        // 然后执行原方法调用或者由拦截器决定不执行原方法的调用
        return method.invoke(target, args);
        // 原方法调用后也可以再次使用拦截器进行结果处理
    }
}

• 私有变量 interceptorClass
  ：它是字符串类型，用来存储某个具体拦截器的全限定名称，这样就可以利用反射机制构建出其实例对象并使用。
• 构造方法：为两个成员变量赋值。
• bind
  方法：这里设计了两个重载的 bind
  方法：
• bind(Object target, String interceptorClass)
  方法是为真实对象绑定代理对象，同时使用拦截器，需要提供具体的拦截器全限定名；
• bind(Object target)
  方法则是为真实对象绑定代理对象，并不使用拦截器。
• 修改后的 invoke
  方法：在方法中新增了处理逻辑，首先需要判断是否使用了拦截器，如果没有使用，则直接返回真实对象的方法调用；如果使用了拦截器，则首先利用反射构建出拦截器实例，然后再处理拦截器中的处理逻辑，最后由拦截器再决定是否要返回真实对象中的方法调用，这样就实现了拦截器的过滤作用。

package com.eric.proxy;

public class JDKProxyTest {
    public static void main(String[] args) {
        System.out.println("设置拦截器的代理执行结果：");
        // 生成指定拦截器的代理对象
        SayHello proxy = (SayHello) JDKProxy.bind(new SayHelloImpl(), "com.eric.proxy.InterceptorImpl");
        proxy.sayHello("Eric");
        System.out.println("\n不设置拦截器的执行结果：");
        // 生成未设置拦截器的代理对象
        proxy = (SayHello) JDKProxy.bind(new SayHelloImpl());
        proxy.sayHello("Jack");
    }
}

执行结果：

设置拦截器的代理执行结果： 
执行拦截器中的方法 
Hello Eric

不设置拦截器的执行结果： 
Hello Jack

2. 拦截器链

package com.eric.proxy;

public class InterceptorImpl2 implements Interceptor {
    @Override
    public void printInfo() {
        System.out.println("执行拦截器2");
    }
}

InterceptorImpl3.java

package com.eric.proxy;

public class InterceptorImpl3 implements Interceptor {
    @Override
    public void printInfo() {
        System.out.println("执行拦截器3");
    }
}

package com.eric.proxy;

public class JDKProxyTest {
    public static void main(String[] args) {
        System.out.println("设置拦截器链，执行结果：");
        // 设计具有拦截器链的代理，注意每个bind方法中的真实对象的改变
        SayHello proxy = (SayHello) JDKProxy.bind(new SayHelloImpl(),
                "com.eric.proxy.InterceptorImpl");
        SayHello proxy2 = (SayHello) JDKProxy.bind(proxy,
                "com.eric.proxy.InterceptorImpl2");
        SayHello proxy3 = (SayHello) JDKProxy.bind(proxy2,
                "com.eric.proxy.InterceptorImpl3");
        // 由最终的代理进行调用方法
        proxy3.sayHello("Eric");
    }
}

执行结果：

设置拦截器链，执行结果：

执行拦截器3
执行拦截器2
执行拦截器中的方法
Hello Eric

👉JDK动态代理模式

👉简单了解一下Java反射技术？

👉逆向工程Mybatis Generator代码生成

「分享、点赞、在看」