在Java后端如何添加拦截器

在安全编码规范中，在Java后端controller层接口需要对调用者的身份进行确认，以防非法用户进行访问。若是在controller层的每个接口处都添加逻辑判断，那么代码重复度高，并且费力费时。此时，就需要在请求到达controller层时提前截取数据流，对相关数据进行校验。在这里将要提到的方式就是在后端添加http拦截器，这样每一次的http请求都需要经过拦截器的认证后才可以继续往下走。那么如何有效地添加拦截器呢？下面将会详细给告诉你怎么添加。

　　（1）为了方便代码管理，我们先创建一个文件夹，其名为interceptor，与controller文件夹处于同一级，该文件夹主要是用来存放拦截器相关的文件，如下图所示：

　　

　　（2）在interceptor文件夹中创建以下几个文件：InterceptorConfig.java、InterceptorPathPatterns.java和AuthorityIntercepor.java

　　

• InterceptorConfig.java文件：主要是用来配置拦截器的
• InterceptorPathPatterns.java文件：是一个拦截规则实体类
• AuthorityIntercepor.java文件：主要是拦截的具体实现

　　三个文件的大致内容具体如下： 

1)InterceptorConfig.java文件内容如下：

import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

　　// 这里通过配置文件来配置拦截规则,后续会提供配置文件内容

　　@Autowired
　　private InterceptorPathPatterns interceptorPathPatterns;

　　@Override
　　public void addInterceptors(InterceptorRegistry registry) {

　　　　// addInterceptor 添加拦截器后默认会拦截所有的http请求
　　　　InterceptorRegistration interceptorRegistration = registry.addInterceptor(newAuthorityInterceptor());
　　　　List includePathPatternsList = interceptorPathPatterns.getIncludePathPatternsList();
　　　　if (null == includePathPatternsList) {
　　　　interceptorRegistration.addPathPatterns("");
　　　　} else {
　　　　　　// addPathPatterns 用于添加拦截规则
　　　　　　interceptorRegistration.addPathPatterns(includePathPatternsList);
　　　　}
　　　　List excludePathPatternsList = interceptorPathPatterns.getExcludePathPatternsList();
　　　　if (null == excludePathPatternsList) {
　　　　　　interceptorRegistration.excludePathPatterns("");
　　　　} else {
　　　　　　// excludePathPatterns 用于排除拦截规则
　　　　　　interceptorRegistration.excludePathPatterns(excludePathPatternsList);
　　　　}
　　}

　　public AuthorityIntercepor newAuthorityInterceptor() {
　　　　AuthorityInterceptor authorityInterceptor = new AuthorityInterceptor();
　　　　// 以下主要是用来设定token在缓存中的有效时长

       // 设定缓存过期时间
　　　　String expiredTime = 30;
　　　　// 设置缓存大小
　　　　Cache cache = CacheBuilder.newBuilder()
　　　　　　　　　　　　　　　　　　　　　　.maximumSize(10000)
　　　　　　　　　　　　　　　　　　　　　　.expireAfterAccess(Integer.parseInt(expiredTime), TimeUnit.MINUTES)
　　　　　　　　　　　　　　　　　　　　　　.build();
　　　　authorityInterceptor.setCache(cache);
　　　　return authorityInterceptor;
　　}
}

 

(2)InterceptorPathPatterns.java文件内容如下：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.List;


@Component
@ConfigurationProperties(prefix = "interceptor")
public class InterceptorPathPatterns {
　　private List includePathPatternsList;
　　private List excludePathPatternsList;

　　public List getIncludePathPatternsList() {
　　　　return includePathPatternsList;
　　}

　　public void setIncludePathPatternsList(List includePathPatternsList) {
　　　　this.includePathPatternsList = includePathPatternsList;
　　}

　　public List getExcludePathPatternsList() {
　　　　return excludePathPatternsList;
　　}

　　public void setExcludePathPatternsList(List excludePathPatternsList) {
　　　　this.excludePathPatternsList = excludePathPatternsList;
　　}
}

 

(3)AuthorityInterceptor.java文件内容如下：

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.util.StreamUtils;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import com.google.common.cache.Cache;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.util.concurrent.Callable;


public class AuthorityInterceptor extends HandlerInterceptorAdapter {

　　private Cache cache = null;

　　public Cache getCache () {
　　　　return cache;
　　}

　　public void setCache(Cache cache) {
　　　　this.cache = cache;
　　}

　　public AuthorityInterceptor() {
　　　　super();
　　}

　　/**
　　* 返回false：从当前的拦截器往回执行所有拦截器的afterCompletion(),再退出拦截器链
　　* 返回true：执行下一个拦截器,直到所有的拦截器都执行完毕
　　*/
　　@Override
　　public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
　　　　OutputStream outputStream = null;
　　　　try {
　　　　　　String number = request.getHeader("X—Person-Number");
　　　　　　String token = request.getHeader("X-Person-Token");
　　　　　　if (StringUtils.isEmpty(number) || StringUtils.isEmpty(token)) {
　　　　　　　　this.setResponseMsg(outputStream, "认证失败", response);
　　　　　　　　return false;
　　　　　　}

　　　　　　// 调用校验方法校验token
　　　　　　boolean bVerify = this.verifyToken(request);
　　　　　　if (bVerify) {
　　　　　　　　// 校验通过
　　　　　　　　return true;
　　　　　　} else {
　　　　　　　　// 认证失败
　　　　　　　　this.setResponseMsg(outputStream, "认证失败", response);
　　　　　　　　return false;
　　　　　　}

　　　　} catch (Exception exception){
　　　　　　throw new Exception(); // 可以抛出指定的异常
　　　　} finally {
　　　　　　if (outputStream != null) {
　　　　　　　　outputStream.close();
　　　　　　　　outputStream = null;
　　　　　　}
　　　　}
　　}

　　@Override
　　public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modeAndView) throws Exception {

　　　　// 拦截器返回时的处理

　　}

 

　　@Override
　　public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception) throws Exception {

　　　　// 视图渲染回调

　　}

　　private void setResponseMsg(OutputStream outputStream, String responseStr, HttpServletResponse response) throws IOException {
　　　　// 重新设置返回的消息类型和消息头,SPRING mvc设置为JSON类型,
　　　　// 内容修改为加密字符串后,类型也要修改为text/html,防止angularjs自动根据类型转换数据
　　　　response.setCharacterEncoding("UTF-8");
　　　　response.setContentType("application/json;charset=UTF-8");
　　　　// 将加密数据写到原始的response对象中,返回客户端
　　　　outputStream = response.getOutputStream();
　　　　StreamUtils.copy(responseStr, Charset.forName("utf-8"), outputStream);
　　}

　　private boolean verifyToken(HttpServletRequest request) throws Exception {
　　　　try {
　　　　　　// 根据具体的业务场景进行逻辑判断设计

　　　　　　// 利用Cache的get方法进行判断，先判断缓存中是否有这个key，若是有的话，直接返回T类型对象结果。

　　　　   T obj = this.cache.get(key,

　　　　　　　　　　　　new Callable() {

　　　　　　　　　　　　　　@Override

　　　　　　　　　　　　　　public T call() {

　　　　　　　　　　　　　　　　try {

　　　　　　　　　　　　　　　　　　// 具体的判断处理逻辑

　　　　　　　　　　　　　　　　} catch(Exception exception) {

　　　　　　　　　　　　　　　　　　// 可以跑出指定的异常

　　　　　　　　　　　　　　　　}

　　　　　　　　　　　　　　}

　　　　　　　　　　　　)
　　　　} catch (Exception exception) {
　　　　　　throw new Exception(exception);
　　　　}
　　}
}

说明：在实际应用中需要用具体的类型取代 T 

(4)application.properties配置文件内容如下：

#需要拦截的路径
interceptor.includePathPatternsList[1]=/**
#不需要拦截的路径
interceptor.excludePathPatternsList[0]=/test/download/**

#说明：采用这样的匹配方式是不会起作用的，例如：*.js，**.css等等

 

#注意：以上的拦截路径都是服务上下文之后的路径，比如说微服务名之后的路径，包括微服务名后的反斜杠

#/*不会匹配末尾的反斜杠，/**会匹配末尾的反斜杠

#若想要完全匹配路径的话，那必须要将路径写完整；模糊匹配的话就不需要了

小结：本文主要是讲述了整体流程思路，也许你会问为何不将拦截规则写在代码中？而是采用配置文件的方式，这主要是为了后续的扩展，比如说暂时不用拦截某个路径下的接口，此时只需要修改配置文件的排除拦截路径就可以了，不用重新修改代码、编译代码、构建版本。

       此外，由于产品之间会有各种服务，所以添加拦截器时最好在API接口层和BFF层都添加上；当然，建议每个产品都在API接口层添加拦截器进行身份验证，这样本产品通过自己的BFF层时调用其它产品的API接口时就没有必要在BFF层再拦截和校验了，不然对本产品来说就有些重复拦截和校验了。

 

此份文档详细记录了千道面试题与详解； 
！ 
   私信我回复【03】即可免费获取

很多人感叹“学习无用”，实际上之所以产生无用论，
   是因为自己想要的与自己所学的匹配不上，这也就意味着自己学得远远不够。无论是学习还是工作，
    都应该有主动性，所以如果拥有大厂梦，那么就要自己努力去实现它。

以上学习资料均免费放送，最后祝愿各位顺利拿到心仪的offer

小伙伴们有兴趣想了解内容和更多相关学习资料的请点赞收藏+评论转发+关注我，后面会有很多干货。如果在阅读过程中有疑问，请留言讨论