拦截器配置文件里配置不拦截静态资源

package com.minglei.hotnews.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
@Configuration
public class WebAppConfig extends WebMvcConfigurationSupport {
    @Autowired
    LoginInterceptor loginInterceptor;
    //实现拦截器 要拦截的路径以及不拦截的路径
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //注册自定义拦截器，添加拦截路径和排除拦截路径
        registry.addInterceptor(loginInterceptor).addPathPatterns("/**").excludePathPatterns("/doc.html").excludePathPatterns("/webjars/**");
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        //配置拦截器访问静态资源
        registry.addResourceHandler("doc.html").addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/favicon.ico").addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
登录拦截器详细配置
 
package com.minglei.hotnews.config;
import com.minglei.hotnews.Utils.*;
import io.jsonwebtoken.Claims;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
@Component
public class LoginInterceptor implements HandlerInterceptor {
    //方法执行前
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        //判断前端是否传来token如果没传进行拦截
        String token=request.getHeader("token");//从http请求头中获取token
        System.out.println("handler:"+handler);
        if(!(handler instanceof HandlerMethod)){
            return true;
        HandlerMethod handlerMethod=(HandlerMethod)handler;
        PassToken handlePass = handlerMethod.getBean().getClass().getDeclaredAnnotation(PassToken.class);
        System.out.println("拿到的handlePass“"+handlePass);
        System.out.println("handle拿到的类是："+handlerMethod.getBean().getClass().getName());
        System.out.println("handle拿到的类是否是swagger的控制器类："+handlerMethod.getBean().getClass().getName().equals("springfox.documentation.swagger.web.ApiResourceController"));
        //判断如果请求的类是swagger的控制器，直接通行。
        if(handlerMethod.getBean().getClass().getName().equals("springfox.documentation.swagger.web.ApiResourceController")){
            return  true;
        if(null != handlePass){
            System.out.println("类上带PassToken注解，直接通行");
           return true;
        }else {
            Method method=handlerMethod.getMethod();
            //检查是否有@passtoken注解，有则跳过验证
            if(method.isAnnotationPresent(PassToken.class))
                PassToken passToken=method.getAnnotation(PassToken.class);
                if(passToken.required())
                    //方法带passToken直接通行
                    System.out.println("方法带passToken直接通行");
                    return  true;
                }else {
                    System.out.println("方法没有带passToken，进行token验证");
                    //判断token是否过期
                    if(token!=null)
                        Claims claims = JWTUtil.parseJWT(token);
                        //解析token判断是否过期
                        if(claims!=null) {
                            long expTime = Long.parseLong(claims.get("ExpTime").toString());
                            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            Date nowDate = new Date();
                            Date expDate = new Date(expTime);
                            String nowDateStr = sdf.format(nowDate);
                            String expDateStr=sdf.format(expDate);
                            if (nowDate.getTime() >= expDate.getTime()) {
                                response.setContentType("json/html; charset=utf-8");
                                //response.sendError(HttpServletResponse.SC_FORBIDDEN,"用户无权限,请登录");
                                PrintWriter printWriter = response.getWriter();
                                Map<String, String> resultError = new HashMap<>();
                                resultError.put("code", "403");
                                resultError.put("message", "Token已过期，请重新登录");
                                Object ces = JsonUtil.objectToString(resultError);
                                printWriter.write(ces.toString());
                                return false;
                                //把当前登录信息保存到threadLocal
                                LocalThreadRelUserInfo localThreadRelUserInfo=new LocalThreadRelUserInfo();
                                localThreadRelUserInfo.setUserId(Long.parseLong(claims.get("UserId").toString()));
                                localThreadRelUserInfo.setUserName(claims.get("UserName").toString());
                                LocalThreadRelUser.set(localThreadRelUserInfo);
                            response.setContentType("json/html; charset=utf-8");
                            //response.sendError(HttpServletResponse.SC_FORBIDDEN,"用户无权限,请登录");
                            PrintWriter printWriter = response.getWriter();
                            Map<String, String> resultError = new HashMap<>();
                            resultError.put("code", "403");
                            resultError.put("message", "Token已过期，请重新登录");
                            Object ces = JsonUtil.objectToString(resultError);
                            printWriter.write(ces.toString());
                            return false;
                    }else {
                        //提示无权限访问
                        response.setContentType("json/html; charset=utf-8");
                        //response.sendError(HttpServletResponse.SC_FORBIDDEN,"用户无权限,请登录");
                        PrintWriter printWriter=response.getWriter();
                        Map<String,String> resultError=new HashMap<>();
                        resultError.put("code","403");
                        resultError.put("message","用户无权限访问,请登录");
                        Object ces = JsonUtil.objectToString(resultError);
                        printWriter.write(ces.toString());
                        return false;
            }else {
                System.out.println("方法没有带passToken，进行token验证");
                //判断token是否过期
                if(token!=null)
                    Claims claims = JWTUtil.parseJWT(token);
                    //解析token判断是否过期
                    if(claims!=null) {
                        long expTime = Long.parseLong(claims.get("ExpTime").toString());
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                        Date nowDate = new Date();
                        Date expDate = new Date(expTime);
                        String nowDateStr = sdf.format(nowDate);
                        String expDateStr=sdf.format(expDate);
                        if (nowDate.getTime() >= expDate.getTime()) {
                            response.setContentType("json/html; charset=utf-8");
                            //response.sendError(HttpServletResponse.SC_FORBIDDEN,"用户无权限,请登录");
                            PrintWriter printWriter = response.getWriter();
                            Map<String, String> resultError = new HashMap<>();
                            resultError.put("code", "403");
                            resultError.put("message", "Token已过期，请重新登录");
                            Object ces = JsonUtil.objectToString(resultError);
                            printWriter.write(ces.toString());
                            return false;
                            //把当前登录信息保存到threadLocal
                            LocalThreadRelUserInfo localThreadRelUserInfo=new LocalThreadRelUserInfo();
                            localThreadRelUserInfo.setUserId(Long.parseLong(claims.get("UserId").toString()));
                            localThreadRelUserInfo.setUserName(claims.get("UserName").toString());
                            LocalThreadRelUser.set(localThreadRelUserInfo);
                        response.setContentType("json/html; charset=utf-8");
                        //response.sendError(HttpServletResponse.SC_FORBIDDEN,"用户无权限,请登录");
                        PrintWriter printWriter = response.getWriter();
                        Map<String, String> resultError = new HashMap<>();
                        resultError.put("code", "403");
                        resultError.put("message", "Token已过期，请重新登录");
                        Object ces = JsonUtil.objectToString(resultError);
                        printWriter.write(ces.toString());
                        return false;
                }else {
                    //提示无权限访问
                    response.setContentType("json/html; charset=utf-8");
                    //response.sendError(HttpServletResponse.SC_FORBIDDEN,"用户无权限,请登录");
                    PrintWriter printWriter=response.getWriter();
                    Map<String,String> resultError=new HashMap<>();
                    resultError.put("code","403");
                    resultError.put("message","用户无权限访问,请登录");
                    Object ces = JsonUtil.objectToString(resultError);
                    printWriter.write(ces.toString());
                    return false;
        return true;// 只有返回true才会继续向下执行，返回false取消当前请求
    //方法执行结束后
    @Override
     public   void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
                         @Nullable Exception ex) throws Exception {
        //清楚掉线程保存的用户信息
        LocalThreadRelUser.remove();
除此之外可能还有别的原因
 
需要结合你自己的业务来判断是那种原因造成的。
 knife官方文档针对此错误的说明：https://doc.xiaominfo.com/faq/knife4j-exception.html
                    SpringBoot拦截器全局拦截登陆当集成knife4j遇到的“Knife4j文档请求异常问题”问题解决方案拦截器配置文件里配置不拦截静态资源登录拦截器详细配置除此之外可能还有别的原因问题集成knife4j后，无法访问api文档。解决方案拦截器配置文件里配置不拦截静态资源因为swagger的页面都属于静态资源，需要在拦截器里排除掉。package com.minglei.hotnews.config;import org.springframework.beans.factory.ann
				
通过SpringBoot集成Api文档（Swagger文档）和（knife4j文档）。启动项目后
Swaggger文档访问地址：localhost:8888/swagger-ui.html
knife4j文档访问地址:localhost:8888/doc.html
自己无意把@RestControllerAdvice的扫描范围删除了，导致Knife4j的接口返回也被封装了。。。把basePackages范围限制到Controller类解决。
				
今天来分享一下自己爬过的坑，就是在使用swgger的时候，页面老是提示“Knife4j文档请求异常”的报错信息，如下图所示：
这个时候在检查完配置文件，以及接口文件都没有错的情况下，可以找找是否出现了下面的情况：
1、接口返回参数中带有List集合，且集合的属性赋予了exmpale属性，例如：
2、接口返回参数中带有对象，且对象属性赋予了exmpale属性，例如：
以上两种情况的出现会直接影响swgger页面的显示，删掉之后就正常了：
后来发现是因为我配置了统一token校验，而拦截器把swagger给拦截了
所以我们只需要在注册生效的拦截器中加入对swagger的判定和放行就可以了
 //判断是不是swagger是就放行
        HandlerMethod handlerMethod=(HandlerMethod)handler;
        if("springfox.documentation.swagger.web.ApiResourceController".equals
				
什么是Swagger？Swagger 是一个用于生成、描述和调用 RESTful 接口的 Web 服务。通俗的来讲，Swagger 就是将项目中所有（想要暴露的）接口展现在页面上，并且可以进行接口调用和测试的服务。从上述 Swagger 定义我们不难看出 Swagger 有以下 3 个重要的作用：将项目中所有的接口展现在页面上，这样后端程序员就不需要专门为前端使用者编写专门的接口文档；当接口更新之后，只需要修改代码中的 Swagger 描述就可以实时生成新的接口文档了，从而规避了接口文档老旧不能使用的问题；通过 Swagger 页面，我们可以直接进行接口调用，降低了项目开发阶段的调试成本。
什么是Knife4J? 和Swagger什么关系？本质是Swagger的增强解决方案，前身只是一个SwaggerUI（swagger-bootstrap-ui）Knife4j是为Java MVC框架集成Swagger生成Api文档的增强解决方案, 前身是swagger-bootstrap-ui,取名kni4j是希望她能像一把匕首一样小巧,轻量,并且功能强悍!Knife4j的前身是swagger-bo
				
Knife4j是为Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui，取名kni4j是希望她能像一把匕首一样小巧，轻量，并且功能强悍！
Knife4j的前身是swagger-bootstrap-ui，为了契合微服务的架构发展，由于原来swagger-bootstrap-ui采用的是后端Java代码+前端Ui混合打包的方式，在微服务架构下显的很臃肿，因此项目正式更名为knife4j。
更名后主要专注的方面：
前后端Java代码以及前端Ui模块进行分离，在微服务架构下使用更加灵活
提供专注于Swagger的增强解决方案，不同于只是改善增强前端Ui部分