Springboot

springBoot—拦截器

2019-07-02  本文已影响25人  小胖学编程

1. 拦截器的基本使用

1.1 拦截器的实现类

  1. 实现Spring的HandlerInterceptor接口；
  2. 继承实现HandlerInterceptor接口的类，例如：HandlerInterceptorAdapter；

1.2 HandlerInterceptor方法介绍

    boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception;

    void postHandle(
            HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
            throws Exception;

    void afterCompletion(
            HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception;

1.3 将拦截器加入到MVC中

在SpringBoot 2.0以上， WebMvcConfigurerAdapter已过时，但是WebMvcConfigurerAdapter实际上是WebMvcConfigurer接口的空实现类。故有两种方法可以实现：推荐使用：implements WebMvcConfigurer

1. @EnableWebMvc + implements WebMvcConfigurer
在扩展类中重写父类的方法即可，这种方法会屏蔽springboot对SpringMVC的自动配置。
2. implements WebMvcConfigurer
在扩展类中重写父类的方法即可，这种方法会使用springboot对SpringMVC的自动配置。
3. extends WebMvcConfigurationSupport
在扩展类中重写父类的方法即可，这种方法会屏蔽springboot对SpringMVC的自动配置。

根据官方文档，尽量不要使用@EnableWebMvc注解，因为他会关闭自动配置。

详情请了解——SpringBoot中对SpringMVC的自动配置

@Component
public class LogInterceptor implements HandlerInterceptor {
    private final static Logger logger = LoggerFactory.getLogger(LogInterceptor.class);
    //业务处理器处理请求之前被调用，对用户的request进行处理
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        logger.info("【拦截器】-【已进入拦截器！！】");
        return true;
    }
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        
    }
}

@Configuration
public class WebMvcConfiguration implements WebMvcConfigurer {
    @Autowired
    private LogInterceptor logInterceptor;
    //配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //指定拦截器，指定拦截路径
        registry.addInterceptor(logInterceptor).addPathPatterns("/**");
    }
}

2. 拦截器的自定义注解

创建注解类。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.METHOD})  ////作用于类、接口等与方法上
@Retention(value = RetentionPolicy.RUNTIME)
public @interface MyLimit {
    int intVal() default 5;
    String stringVal() default "";
}

创建拦截器类-AnnotationInterceptor

@Component
public class AnnotationInterceptor implements HandlerInterceptor {
    private final static Logger logger = LoggerFactory.getLogger(AnnotationInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断当前被拦截的方法是否含有注解
        boolean assignableFromMethod = handler.getClass().isAssignableFrom(HandlerMethod.class);//[额赛额包] 指定的
        logger.info("当前方法上是否有注解" + assignableFromMethod);
        if (assignableFromMethod) {
            //获取当前方法的自定义注解拦截器的注解
            MyLimit methodAnnotation = ((HandlerMethod) handler).getMethodAnnotation(MyLimit.class);
            logger.info("当前方法的注解：" + methodAnnotation);
            if (methodAnnotation == null) {
                return true;
            }
            //获取注解上的参数
            int intVal = methodAnnotation.intVal();
            String stringVal = methodAnnotation.stringVal();
            logger.info("打印注解上的参数：[intVal={}][stringVal={}]", intVal, stringVal);
        }
        return true;
    }
}

配置拦截器

@Configuration
public class WebMvcConfiguration implements WebMvcConfigurer {
    @Autowired
    private LogInterceptor logInterceptor;
    @Resource
    private AnnotationInterceptor annotationInterceptor;
    //配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //指定拦截器，指定拦截路径
        registry.addInterceptor(logInterceptor).addPathPatterns("/**");
        registry.addInterceptor(annotationInterceptor);
    }
}

使用注解

    @RequestMapping(value = "/get", method = RequestMethod.GET)
    @ResponseBody
    @MyLimit(stringVal = "哈哈，哈哈哈")
    public String getUesr(@RequestParam(value = "str", required = false) Integer integer) {
        try {
            if (integer == 2) {
                throw new RuntimeException("请求地址不合法");
            }
        }catch (Exception e){
            logger.error("请求参数不合法",e);
        }
        logger.info("请求参数：str={}",integer);
        SysQuartzJobConfig sysQuartzJobConfig = sysQuartzJobConfigMapper.selectByPrimaryKey(integer);
        return JSON.toJSONString(sysQuartzJobConfig);
    }

效果：

MyPrefix 16591 INFO com.Interceptor.impl.AnnotationInterceptor - 当前方法上是否有注解true
MyPrefix 16591 INFO com.Interceptor.impl.AnnotationInterceptor - 当前方法的注解：@com.Interceptor.annotation.MyLimit(intVal=5, stringVal=哈哈，哈哈哈)
MyPrefix 16592 INFO com.Interceptor.impl.AnnotationInterceptor - 打印注解上的参数：[intVal=5][stringVal=哈哈，哈哈哈]

3. 获取请求参数解决java.io.IOException: Stream closed

在拦截器中通过request.getInputStream();获取body中的信息后，此时在Controller中使用@RequestBody注解获取参数出现异常。

流关闭异常出现原因分析

IO（1）Java-BIO体系学习

  1. 输入流中含有一个“隐式指针”记录当前流读取的位置，故一旦我们在拦截器中将读取InputStream，那么后续无法使用@RequestBody注解。
  2. 可以在【拦截器】之前使用【过滤器】，包装request请求，重写getInputStream()方法；
  3. 将数据保存到内存Byte[]中，使用ByteArrayInputStream进行操作。

引入依赖

在springboot中，无需引入。

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-core</artifactId>
    <version>8.5.15</version>
</dependency>

新建拦截器

@Component
public class LogInterceptor implements HandlerInterceptor {

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

    //业务处理器处理请求之前被调用，对用户的request进行处理
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        logger.info("【拦截器】-【已进入拦截器！！】");
        logger.info("【拦截器】-request的类型{}", request.getClass());
        String bodyString = HttpHelper.getBodyString(request);
        logger.info("bodyString的值：" + bodyString);
        return true;
    }
}

新建过滤器

public class HttpServletRequestReplacedFilter implements Filter {

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

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        logger.info("【过滤器】-【已进入过滤器！】");
        ServletRequest requestWrapper = new BodyReaderHttpServletRequestWrapper((HttpServletRequest) request);
        chain.doFilter(requestWrapper, response);
    }

    @Override
    public void destroy() {

    }
}

包装request

public class BodyReaderHttpServletRequestWrapper extends HttpServletRequestWrapper {
    private final static Logger logger = LoggerFactory.getLogger(BodyReaderHttpServletRequestWrapper.class);

    private final byte[] body;

    public BodyReaderHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
        //获取到请求体
        logger.info("【过滤器】-【获取请求的body信息】");
        body = HttpHelper.getBodyString(request).getBytes(Charset.forName("UTF-8"));
    }

    //重写方法
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        //节点流
        final ByteArrayInputStream bais = new ByteArrayInputStream(body);
        return new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener listener) {
                //监听
                logger.info("【拦截器】-【BodyReaderHttpServletRequestWrapper ReadListener:{}】", this);
            }

            @Override
            public int read() throws IOException {
                return bais.read();
            }
        };
    }
}

读取Body的工具类

public class HttpHelper {
    private final static Logger logger = LoggerFactory.getLogger(HttpHelper.class);
    public static String getBodyString(HttpServletRequest request) {

        StringBuffer sb = new StringBuffer();
        InputStream inputStream;
        BufferedReader bufferedReader;
        try {
            //将数据保存到数组中，每次读取的时候，都读取一遍
            inputStream = request.getInputStream();
            //将字节数组当做输出的目的地
            //字节流转换为字符流（处理流）
            bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String line = "";
            while ((line = bufferedReader.readLine()) != null) {
                sb.append(line);
            }
        } catch (Exception e) {
            logger.error("数据读取异常", e);
        }
        return sb.toString();
    }
}

拦截器过滤器加入到容器中

@Configuration
public class WebMvcConfiguration implements WebMvcConfigurer {
    @Autowired
    private LogInterceptor logInterceptor;
//    @Resource
//    private AnnotationInterceptor annotationInterceptor;
    //配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //指定拦截器，指定拦截路径
        registry.addInterceptor(logInterceptor).addPathPatterns("/**");
//        registry.addInterceptor(annotationInterceptor);
    }

    @Bean
    public FilterRegistrationBean httpServletRequestReplacedRegistration() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(new HttpServletRequestReplacedFilter());
        registration.addUrlPatterns("/*");
        registration.addInitParameter("paramName", "paramValue");
        registration.setName("httpServletRequestReplacedFilter");
        registration.setOrder(1);
        return registration;
    }
}

执行日志

2019-07-02 16:40:07,598 INFO [22059] [http-nio-8080-exec-1] [] (DirectJDKLog.java:173): Initializing Spring DispatcherServlet 'dispatcherServlet'
2019-07-02 16:40:07,598 INFO [22059] [http-nio-8080-exec-1] [] (FrameworkServlet.java:524): Initializing Servlet 'dispatcherServlet'
2019-07-02 16:40:07,610 INFO [22071] [http-nio-8080-exec-1] [] (FrameworkServlet.java:546): Completed initialization in 12 ms
2019-07-02 16:40:07,620 INFO [22081] [http-nio-8080-exec-1] [] (HttpServletRequestReplacedFilter.java:22): 【过滤器】-【已进入过滤器！】
2019-07-02 16:40:07,623 INFO [22084] [http-nio-8080-exec-1] [] (BodyReaderHttpServletRequestWrapper.java:26): 【过滤器】-【获取请求的body信息】
2019-07-02 16:40:07,636 INFO [22097] [http-nio-8080-exec-1] [] (LogInterceptor.java:24): 【拦截器】-【已进入拦截器！！】
2019-07-02 16:40:07,636 INFO [22097] [http-nio-8080-exec-1] [] (LogInterceptor.java:25): 【拦截器】-request的类型class com.filter.BodyReaderHttpServletRequestWrapper
2019-07-02 16:40:07,638 INFO [22099] [http-nio-8080-exec-1] [] (LogInterceptor.java:27): bodyString的值：{"age":"12","name":"liming"}
2019-07-02 16:40:07,797 INFO [22258] [http-nio-8080-exec-1] [] (UserController.java:41): 请求参数：str={"age":"12","name":"liming"}
上一篇 下一篇

猜你喜欢

热点阅读