Java内功修炼系列一拦截器

在动态代理中，我们知道在代理类中，执行真实对象的方法前后可以增加一些其他的逻辑，这些逻辑并不是真实对象能够实现的方法，比如一个租房的用户希望租一套公寓，但是中介所代理的这个房东并没有可以出租的公寓，那么这时候就需要在出租房屋之前进行一些其他操作了，比如中介拒绝用户的请求或者帮助找其他用户等。对这部分逻辑的实现我们可以提取成一个拦截器，就在用户租房之前先问中介有没有公寓可以出租，如果中介所代理的房东没有公寓，则中介不接受这个请求，否则接受请求并代理房东出租公寓，出租完成之后中介还可以执行其他操作。顾名思义，拦截器的功能就是拦截真实对象的方法，怎么拦截呢？首先在调用之前先执行一个before() 的方法，这个方法用来判断能不能调用真实对象的方法，如果能则调用，否则对其进行拦截，即不让它执行，并进行自己的处理，执行around() 方法，在调用真实对象或者around()方法之后，还可以调用after()方法进行其他操作。但是拦截器的使用是需要以来动态代理的，通过动态代理来决定各个方法的执行顺序，所以我们自己在实现一个拦截器的时候，还是要定义一个接口，这是jdk动态代理必须的。

下面以最常见的用户登陆为例，假设客户端的请求是登陆，它只关心能不能登陆成功，但是服务器在处理这个登陆请求的时候要进行一些自己的判断，不能不管三七二十一就让登陆成功了吧？比如登陆成功之前先判断用户的用户名和密码是否正确，如果成功则执行登陆请求，否则再次跳转到登陆页，让用户重新输入用户名或密码。而不管登陆成功与否，都对这次登陆过程进行日志记录。

第一步：定义一个用户登陆的拦截器接口LoginInterceptor

 /**
  * @author hyc
  * 定义一个登陆的拦截器接口：一般由开发者实现
  */
 public interface LoginInterceptor{

     /**
      * @param proxy  代理对象
      * @param target 真实对象
      * @param metod  代理方法
      * @param args   方法参数
      * @return
      * 定义三个接口:如果before方法执行成功，则反射真实对象方法
      *               如果before方法执行失败，则调用executeAction方法进行拦截
      *               在真实对象方法或拦截处理方法调用之后，则调用after方法
      * 应用实例：用户登陆时，对登陆方法拦截，登陆之前检查用户名密码是否正确，如果正确则调用登陆方法，否则返回登陆页面
      */

     //登陆之前执行，用来验证用户名密码是否正确
     public boolean before(Object proxy,Object target,Method metod,Object[] args);

     //如果用户名和密码不正确，则跳转到登陆页面，否则进行登陆
     public void around(Object proxy,Object target,Method metod,Object[] args);

     //跳转到登陆页或继续登陆之后需要执行的一些方法，比如记录日志
     public void after(Object proxy,Object target,Method metod,Object[] args);
 }

第二步：定义一个登陆类LoginInterceptorImpl，实现上面的接口

 /*
  * 实现接口中的方法
  */
 public class LoginInterceptorImpl implements LoginInterceptor{

     public boolean before(Object proxy, Object target, Method metod, Object[] args) {
         System.out.println("反射方法之前逻辑:登陆之前校验用户名和密码是否正确");
         String userName = "";
         String pwd = "";
         boolean result = false;
         try {
             userName = (String) args[0];
             pwd = (String) args[1];
             if(userName.equals("zhangsan") && pwd.equals("123456")) {
                 result = true;
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return result;
     }

     public void around(Object proxy, Object target, Method Method , Object[] args) {
         System.out.println("取代被代理对象的方法：校验失败后跳转到登陆页面");

     }

     public void after(Object proxy, Object target, Method method, Object[] args) {
         System.out.println("反射方法之后逻辑：记录登陆日志");
     }

 }

第三步：定义真实对象接口LoginInterface

 /*
  * 定义登陆接口，由登陆类实现
  */
 public interface LoginInterface {

     /**
      * 使用用户名和密码进行登陆
      * @param name
      * @param pwd
      * LoginInterface.java
      */
     public void login(String name,String pwd);
 

第四步：定义真实类UserLogin，实现上述接口，并添加登陆逻辑

 /*
  * 定义登陆类，实现具体的登陆逻辑
  */
 public class UserLogin implements LoginInterface {
     @Autowired
     HttpServletRequest request;

     /**
      * 这个方法中只执行登陆成功后的逻辑：比如设置session、登陆跳转等
      */
     public void login(String name, String pwd) {
         System.out.println("登陆成功，跳转到首页");
     }

 }

第五步：定义中介类，实现动态代理的逻辑，动态获取代理对象

 /**
  * 中介类：实现动态代理的逻辑
  *
  * @author hyc
  *
  */
 public class InterceptorJdkProxy implements InvocationHandler {

     private Object target;//真实对象
     private String interceptorClass = null;//拦截器名称

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

     // 通过反射获取代理对象
     public static Object bind(Object target, String interceptorClassName) {
         return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                 new InterceptorJdkProxy(target, interceptorClassName));
     }

     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         // 如果拦截器为空，则执行真实对象的方法
         if (interceptorClass == null) {
             return method.invoke(target, args);
         }

         Object result = null;
         // 否则使用反射生成拦截器
         LoginInterceptor interceptor = (LoginInterceptor) Class.forName(interceptorClass).newInstance();
         // 如果拦截前方法执行成功，则执行真实对象的方法，否则执行拦截器中的方法
         if (interceptor.before(proxy, target, method, args)) {
             result = method.invoke(target, args);
         } else {
             interceptor.around(proxy, target, method, args);
         }

         // 执行完拦截方法或真实对象方法之后，调用after方法
         interceptor.after(proxy, target, method, args);
         return result;
     }

 }

第六步：用户请求，通过中介类获取代理对象并执行登陆请求

 /*
  * 用户请求登陆
  */
 public class LoginController {
     public static void main(String[] args) {
         //创建真实对象
         LoginInterface loginObject = new UserLogin();
         //获取代理对象
         LoginInterface proxy = (LoginInterface) InterceptorJdkProxy.bind(loginObject, "com.daily.interceptor.LoginInterceptorImpl");
         //调用代理方法
         proxy.login("zhangsan1","123456");
     }
 }

第七步：查看执行结果

1⃣️将用户名传zhangsan时

 反射方法之前逻辑:登陆之前校验用户名和密码是否正确
 登陆成功，跳转到首页
 反射方法之后逻辑：记录登陆日志

1⃣️将用户名传zhangsan1时

 反射方法之前逻辑:登陆之前校验用户名和密码是否正确
 取代被代理对象的方法：校验失败后跳转到登陆页面
 反射方法之后逻辑：记录登陆日志

从执行结果可以看到，当用户名传的值，和在拦截器中校验的相同时，登陆方法没有被拦截；反之登陆被拦截并跳转至登陆页，可见该拦截器实现了拦截的功能。

一般来说，动态代理的逻辑由架构设计者完成，他只要将接口暴露给普通开发人员，普通开发人员不需要知道动态代理的实现过程，只要定义自己的拦截器并完成拦截逻辑就可以，就像上面的例子，我们可以看到动态代理的实现过程对普通开发者是“不可见的”，他们只需根据设计者的接口提供相关的参数即可。

以上就是自己实现拦截器的过程。