Java 实现拦截器Interceptor的拦截功能方式

java 里的拦截器是动态拦截 action 调用的对象，它提供了一种机制可以使开发者可以定义在一个 action 执行的前后执行的代码，也可以在一个 action 执行前阻止其执行，同时也提供了一种可以提取 action 中可重用部分的方式。在 aop（aspect-oriented programming）中拦截器用于在某个方法或字段被访问之前进行拦截，然后在之前或之后加入某些操作。

此外，拦截器在流行的开源框架中也很常见，其依赖的技术就是 java 的动态代理。理解拦截器的核心原理对理解这些开源框架的体系结构至关重要。下面，我们就以一个简单的模型的来说明拦截器实现的一般方法。

模型主要分为五个模块，分别：

• 业务组件，被代理和被拦截的对象；
• 代理处理器，实现了invocationhandler接口的一个对象；
• 代理对象，proxy对象；
• 拦截器，普通的 java bean，在调用业务方法之前或者之后会自动拦截并执行自己的一些方法；
• 客户端，执行业务处理的入口。

接下来，我们就用 java 语言来实现拦截器interceptor的拦截功能：

第1步：创建业务组件接口 businessfacade

/**
 * @author 维c果糖
 * @create 2017-03-30
 *
 * github：github.com/guobinhit
 *
 * 业务组件接口
 */
public interface businessfacade {
    public void dosomething();
}

第2步：创建业务组件实现类 businessclass

/**
 * @author 维c果糖
 * @create 2017-03-30
 *
 * github：github.com/guobinhit
 *
 * 业务组件接口的实现类
 */
public class businessclass implements businessfacade {
    public void dosomething() {
        system.out.println("在业务组件 businessclass 中调用方法: dosomething()");
    }
}

第3步：创建拦截器 interceptorclass

/**
 * @author 维c果糖
 * @create 2017-03-30
 *
 * github：github.com/guobinhit
 *
 * 拦截器
 */
public class interceptorclass {
    // 在 action 之前调用
    public void before(){
        system.out.println("在拦截器 interceptorclass 中调用方法: before()");
    }
    // 在 action 之后调用
    public void after(){
        system.out.println("在拦截器 interceptorclass 中调用方法: after()");
    }
}

第4步：创建动态代理处理器工具 dynamicproxyhandler

/**
 * @author 维c果糖
 * @create 2017-03-30
 *
 * github：github.com/guobinhit
 *
 * 动态代理处理器工具
 */
public class dynamicproxyhandler implements invocationhandler {
    // 声明被代理对象
    private object business;
    // 创建拦截器
    private interceptorclass interceptor = new interceptorclass();
    /**
 　　* 动态生成一个代理类对象，并绑定被代理类和代理处理器。
 　　*
 　　* @param business
 　　* @return 代理类对象
 　　*/
    public object bind(object business) {
        this.business = business;
        /**
         * proxy.newproxyinstance(参数1, 参数2, 参数3)
         *
         * 参数1, 表示被代理类的 classloader
         * 参数2, 表示被代理的接口
         * 参数3, 表示代理处理器对象
         *
         * 该方法，返回代理实例
         */
        return proxy.newproxyinstance(business.getclass().getclassloader(),
                business.getclass().getinterfaces(),
                this);
    }
    /**
 　　* 代理需要调用的方法，并在该方法调用前后，先调用连接器的方法。
 　　*
 　　* @param proxy 代理类对象
 　　* @param method 被代理的接口方法
 　　* @param args 被代理接口方法的参数
 　　* @return 方法调用返回的结果
 　　* @throws throwable
 　　*/
   public object invoke(object proxy, method method, object[] args) throws throwable {
       object result = null;
       interceptor.before();
       result = method.invoke(business, args);
       interceptor.after();
       return null;
   }
}

第5步：创建客户端 clientdemo

/**
 * @author 维c果糖
 * @create 2017-03-30
 *
 * github：github.com/guobinhit
 *
 * 客户端
 */
public class clientdemo {
    public static void main(string args[]) {
        // 创建动态代理处理工具
        dynamicproxyhandler handler = new dynamicproxyhandler();
        // 创建业务组件对象
        businessfacade business = new businessclass();
        // 创建业务组件对象，并用动态代理绑定代理类
        businessfacade businessproxy = (businessfacade) handler.bind(business);
        // 调用业务组件中的方法，演示拦截器效果
        businessproxy.dosomething();
    }
}

运行上面的项目代码，结果如下图所示：

如上图所示，显然我们拦截器的拦截功能实现啦！

通过这篇文章，我们可能会对拦截器的实现原理有一个更透彻的理解。

but，在真正的项目实践之中，要想实现拦截器的功能，我们一般采用继承类handlerinterceptoradapter或者抽象类abstractinterceptor，或者实现handleinterceptor接口。

也就是说，我们只需要关心如何重写方法，而不需要关心其内部的实现原理。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。