拦截器是个好东西，之前用到过，现在记录一下，供以后参考使用！
 
其一，使用org.aspectj.lang.annotation.Aspect
 
先上代码：
 
 
 

  
 
 
 
package com.test.interceptors.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Aspect
@Component
public class TaskAspect {

    private static final Logger logger = LoggerFactory.getLogger(TaskAspect.class);
    
    @Pointcut("execution(* com.test.controller.TestController.addTask(..))")
    private void addTaskAction(){};
    
    private ThreadLocal<String> tLocal = new ThreadLocal<String>();
    
    @Before("execution(* com.test.controller.TestController.addTask(..)) && args(id,userId,name)")
    public void getInterview(String moid,int taskType,String otherAttr, String actDefName, String taskName,String userId){
        tLocal.set(moid);
    }
    @Around("addTaskAction()")
    public Object aroundInterviewTask(ProceedingJoinPoint pjp) throws Throwable{
            Object[] args = pjp.getArgs();
            Object retVal = pjp.proceed(args);
            
            try {
            //获取参数
            String id = args[0].toString();
            String name = args[2].toString();
                //业务逻辑处理
        } catch (Throwable e) {
            //异常处理
        }
            
            return retVal;
    }
    
    @AfterReturning(returning="result",pointcut="addTaskAction()")
    public void addCount(Object result){
        
    }
}
 
 

  
 
 
 
@Aspect:切面
 
@Pointcut:指定需要拦截的方法；
 
@Arround: 当拦截到方法被调用时的处理逻辑，可获取方法参数；
 
@AfterReturning：方法执行完成后的处理逻辑
 
@Before:方法执行之前的处理逻辑；
 
可以看出来，这个不是真正意义上的拦截器，而只是功能来说是拦截数据（面向切面编程）；
 
由于之前使用拦截器时发现，拦截器会读取数据后不释放，导致拦截后数据无法流转！其形式如以下代码；
 
 
 

  
 
 
 
package com.test.interceptors;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class TestInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        // TODO Auto-generated method stub
        //System.out.println("=postHandle==============");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        // TODO Auto-generated method stub
        //System.out.println("拦截url==="+request.getRequestURI());
    }

}
 
 

  
 
 
 
其二，org.springframework.web.bind.annotation.ControllerAdvice
 
先上代码：
 

 
 TestInterceptor.java
 
这个是真正意义上的拦截器；
 
supports：需要拦截的方法名称
 
afterBodyRead：具体业务处理逻辑
 
 

拦截器是个好东西，之前用到过，现在记录一下，供以后参考使用！
 
https://www.cnblogs.com/liangblog/p/7234757.html
 
其一，使用org.aspectj.lang.annotation.Aspect
 
先上代码：
 
 
package com.test.interceptors.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Aspect
@Component
public class TaskAspect {

    private static final Logger logger = LoggerFactory.getLogger(TaskAspect.class);
    
    @Pointcut("execution(* com.test.controller.TestController.addTask(..))")
    private void addTaskAction(){};
    
    private ThreadLocal<String> tLocal = new ThreadLocal<String>();
    
    @Before("execution(* com.test.controller.TestController.addTask(..)) && args(id,userId,name)")
    public void getInterview(String moid,int taskType,String otherAttr, String actDefName, String taskName,String userId){
        tLocal.set(moid);
    }
    @Around("addTaskAction()")
    public Object aroundInterviewTask(ProceedingJoinPoint pjp) throws Throwable{
            Object[] args = pjp.getArgs();
            Object retVal = pjp.proceed(args);
            
            try {
            //获取参数
            String id = args[0].toString();
            String name = args[2].toString();
                //业务逻辑处理
        } catch (Throwable e) {
            //异常处理
        }
            
            return retVal;
    }
    
    @AfterReturning(returning="result",pointcut="addTaskAction()")
    public void addCount(Object result){
        
    }
}
 
 
@Aspect:切面
 
@Pointcut:指定需要拦截的方法；
 
@Arround: 当拦截到方法被调用时的处理逻辑，可获取方法参数；
 
@AfterReturning：方法执行完成后的处理逻辑
 
@Before:方法执行之前的处理逻辑；
 
可以看出来，这个不是真正意义上的拦截器，而只是功能来说是拦截数据（面向切面编程）；
 
由于之前使用拦截器时发现，拦截器会读取数据后不释放，导致拦截后数据无法流转！其形式如以下代码；
 
 
package com.test.interceptors;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class TestInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        // TODO Auto-generated method stub
        //System.out.println("=postHandle==============");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        // TODO Auto-generated method stub
        //System.out.println("拦截url==="+request.getRequestURI());
    }

}
 
 
其二，org.springframework.web.bind.annotation.ControllerAdvice
 
先上代码：
 
 
 
package com.test.interactive.interceptors;

import java.io.IOException;
import java.lang.reflect.Type;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdvice;


@ControllerAdvice(assignableTypes = { TestRSImpl.class })
public class TestInterceptor implements HandlerInterceptor, RequestBodyAdvice {

    private static final Logger logger = LoggerFactory.getLogger(TestInterceptor.class);

    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType,
            Class<? extends HttpMessageConverter<?>> converterType) {
        return methodParameter.getMethod().getName().equals("submit");;
    }

    @Override
    public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter,
            Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return body;
    }

    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType,
            Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
        return inputMessage;
    }

    @Override
    public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType,
            Class<? extends HttpMessageConverter<?>> converterType) {
        try{
            //业务处理逻辑
        } catch (Throwable e) {
            logger.error("", e);
        }
        return body;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        try {

        } catch (Throwable e) {
            logger.error("", e);
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        // nothing to do
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        // nothing to do
    }
}
 
 
这个是真正意义上的拦截器；
 
supports：需要拦截的方法名称
 
afterBodyRead：具体业务处理逻辑

对于Java中拦截器我也是一知半解，但是可以实现，大家可以借鉴
 
首先
 
需要添加一个文件与启动器同级
 
package com.example.demo.controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class Interceptor1 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,Object handler) throws Exception{
        HttpSession session=request.getSession();
        Object ob=session.getAttribute("name");//name是与登录验证中的name一致，同一变量
        if (ob!=null) {
            return true;
        }
        session.setAttribute("preurl",request.getRequestURI());
        StringBuffer url = request.getRequestURL();
        String tempContextUrl = url.delete(url.length() - request.getRequestURI().length(), url.length()).append(request.getServletContext().getContextPath()).append("/").toString();
        response.sendRedirect("/user/login");  //跳转到您的登录页面，这是路径
        return false;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
           Object handler,ModelAndView model) throws Exception{
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
             Object handler,Exception ex) throws Exception{
    }

}

 
所有的代码我已经复制上去了，你直接复制即可，其中我注释的两个地方需要更改，登录验证在其他文章中
 
在启动类中的拦截器代码
 
@Override 
	  public void addInterceptors(InterceptorRegistry registry){
	  InterceptorRegistration ir=registry.addInterceptor(new Interceptor1());//导上面那个文件的包
	  ir.addPathPatterns("/**");
	  ir.excludePathPatterns("/user/dologin","/user/login","/user/yzm","/js/**","/html/**","/images/**","/css/**");//拦截器放开的代码
	  
	  }
 
其中，本地的vue与jq都需要放到js包中，也就是第四个双引号的那个包

之前记录了SpringBoot中使用过滤器，其实拦截器和过滤器从功能上来说，拦截器/过滤器所能实现的功能过滤器/拦截器都能够实现。但是过滤器是java实现的，它需要依赖于Servlet容器，而拦截器是SprignMVC实现的一个机制，独立于Servlet容器，而且能实现IOC容器中的各个bean。简单的说：过滤器的urlPattern针对的是所有的请求，而拦截器的urlPattern针对的SpringMVC中的Controller控制器处理的请求，并不会拦截Servlet容器。过滤器和拦截器触发时机不一样。
 
 
 1、编写拦截器类MyHandlerInterceptor，实现HandlerInterceptor接口
 
public class MyHandlerInterceptor implements HandlerInterceptor {

    private Logger logger = LoggerFactory.getLogger(MyHandlerInterceptor.class);

    long start;

    @Override
    //请求执行前执行
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        logger.info("preHandle starter");
        start = System.currentTimeMillis();
        return true;
    }

    @Override
    /**
     * 视图渲染完成后行
     * 但必须是preHandle()返回为true时才执行
     */
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        logger.info("preHandle end");
        logger.info("time："+(System.currentTimeMillis()-start));
    }

    @Override
    /**
     * 请求结束执行
     * 但必须是preHandle()返回为true时才执行
     */
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

    }
}
 
2、编写config类
 
@Configuration
public class InterConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyHandlerInterceptor()).addPathPatterns("/hello");
        super.addInterceptors(registry);
    }
}
 
3、编写controller类进行测试
 
    @RequestMapping("/hello")
    @ResponseBody
    public String hello(){
        return "hello123!";
    }
 
4、页面请求hello请求，查看控制台打印结果
 
 
这里，基本上拦截器的配置就算是成功了，本人小白一枚，还在学习...