我正在变得夸张UI 403错误如何解决？

Question

这就是我的微服务类的方式。我有两个问题。 首先，当我本地运行微服务时，Swagger文档不会自动打开。当我用手以主机/v2/api-doc的形式输入链接时，它以JSON的速度打开，但是UI部分不会出现。我可以用Swagger编辑器进行编辑和查看。我为UI部分添加了pom.xml的依赖性，但是它不起作用，如何打开UI屏幕？

第二， 除主机/V2/API-DOC外，当我特别键入指向控制器的链接时，我会收到403授权错误。这是我要克服的最重要的问题，我该怎么做？你能帮助我吗？

link/swagger-ui.html＃！/signin Localhost：8000/Swagger-UI.html＃！/Signin

Whitelabel错误页面 此应用程序没有明确的映射 /错误，因此您将其视为后备。

thu Jun Jun 23 16:04:09 TRT 2022 出乎意料的错误（类型=禁止，状态= 403）。 访问拒绝

我的pom.xml是：

<dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>${springfox.version}</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>${springfox.version}</version>
        </dependency>
<dependency>

我的SwaggerConfig类是：

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2).select().apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any()).build().apiInfo(metaData());
    }

    @Bean
    public UiConfiguration uiConfiguration() {
        return UiConfigurationBuilder.builder().deepLinking(true).validatorUrl(null).build();
    }

    private static final Contact DEFAULT_CONTACT = new Contact("Rosaline Fox,Anna Hurt", "http://www.google.com",
            "[email protected],[email protected]");

    private ApiInfo metaData() {
        return new ApiInfoBuilder().title("Auth Service Controller API Title")
                .description("Auth Service Controller API Description").version("1.0")
                .license("Apache License Version 2.0").licenseUrl("https://www.apache.org/licenses/LICENSE-2.0")
                .contact(DEFAULT_CONTACT).build();
    }

}

我的WebSecurityConfig类是：

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    private static final String XI_PARTNER =  "XIPartner";
    private static final String XI_CONSULTANT =  "XIConsultant";
    private static final String SALES =  "Sales";
    private static final String STANDART =  "Standart";
    public static final String ADMIN =  "Admin";

    @Autowired
    private JwtTokenProvider jwtTokenProvider;

    @Autowired
    private FilterChainExceptionHandler filterChainExceptionHandler;
    
    @Autowired
    private HandlerExceptionResolver handlerExceptionResolver;
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {

        // Disable CSRF (cross site request forgery)
        http.csrf().disable();
        http.cors().configurationSource(request -> new CorsConfiguration().applyPermitDefaultValues());

        // No session will be created or used by spring security
        http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        
        http.addFilterBefore(filterChainExceptionHandler, LogoutFilter.class);
        http.exceptionHandling().accessDeniedHandler((req, res, e) ->  handlerExceptionResolver.resolveException(req, res, null, e));
        
        // Entry points
        http.authorizeRequests()
                .antMatchers("/**/signin/otp", "/**/signin/**", "/**/v2/api-docs/**", "/**/swagger-ui.html#/**").permitAll()
                .antMatchers("/**/customers/create").hasAnyAuthority(SALES)
                .antMatchers("/**/customers/update").hasAnyAuthority(SALES)
                .antMatchers("/**/customers/all").hasAnyAuthority(SALES)
                .antMatchers("/**/customers/deactivate").hasAnyAuthority(SALES)
                .antMatchers("/**/customers/reactivate").hasAnyAuthority(SALES)
                .antMatchers("/**/products/create").hasAnyAuthority(SALES)
                .antMatchers("/**/products/update").hasAnyAuthority(SALES)
                .antMatchers("/**/users/create").hasAnyAuthority(SALES)
                .antMatchers("/**/users/update").hasAnyAuthority(SALES)
                .antMatchers("/**/users/deactivate").hasAnyAuthority(SALES)
                .antMatchers("/**/users/reactivate").hasAnyAuthority(SALES)
                .antMatchers("/**/admin/user/all").hasAnyAuthority(ADMIN)
                .antMatchers("/**/xicustomers/create").hasAnyAuthority(SALES)
                .antMatchers("/**/xicustomers/update").hasAnyAuthority(SALES)
                .antMatchers("/**/xicustomers/all").hasAnyAuthority(SALES)
                .antMatchers("/**/partner/create").hasAnyAuthority(SALES)
                .antMatchers("/**/xicustomers/list").hasAnyAuthority(XI_PARTNER,XI_CONSULTANT)
                .antMatchers("/**/report/list/**").hasAnyAuthority(XI_CONSULTANT)

                .antMatchers("/**/originator").hasAnyAuthority(STANDART)
                .antMatchers("/**/blackhour/add").hasAnyAuthority(STANDART)
                .antMatchers("/**/blackhour").hasAnyAuthority(STANDART)
                .antMatchers("/**/access/**").anonymous()
                .antMatchers("/**/pwd/forgot").anonymous()
                .antMatchers("/**/maximo").anonymous()

                .anyRequest().authenticated();      

        // Apply JWT
        http.apply(new JwtTokenFilterConfigurer(jwtTokenProvider));

        // Optional, if you want to test the API from a browser
        // http.httpBasic();
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        // Allow eureka client to be accessed without authentication
        web.ignoring().antMatchers("/*/")//
                .antMatchers("/eureka/**")//
                .antMatchers(HttpMethod.OPTIONS, "/**"); // Request type options
                                                            // should be
                                                            // allowed.
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12);
    }

    @Bean
    public AuthenticationManager customAuthenticationManager() throws Exception {
        return authenticationManager();
    }

}

My Controller Class : 

@ApiOperation(value = "Login Service", notes = "Login service with captcha verification.")
@PostMapping("/signin")
@ResponseBody
public ResponseEntity<LoginResponse> login(@RequestBody LoginRequest loginRequest) {
    LoginResponse loginResponse = this.loginService.login(loginRequest);
    return ResponseEntity.accepted().body(loginResponse);
}



My JwtTokenFilterConfigurer class :

public class JwtTokenFilterConfigurer extends SecurityConfigurerAdapter<DefaultSecurityFilterChain, HttpSecurity> {   

    private JwtTokenProvider jwtTokenProvider;
    
    public JwtTokenFilterConfigurer(JwtTokenProvider jwtTokenProvider) {
        this.jwtTokenProvider = jwtTokenProvider;
    }
    
    @Override
    public void configure(HttpSecurity http) throws Exception {
        JwtTokenFilter customFilter = new JwtTokenFilter(this.jwtTokenProvider);
        http.addFilterBefore(customFilter, UsernamePasswordAuthenticationFilter.class);
    }

}

我的JWTTOKENFILTER类：

@Slf4j
@Component
public class JwtTokenFilter extends GenericFilterBean {
    
    private JwtTokenProvider jwtTokenProvider;
    
    public JwtTokenFilter(JwtTokenProvider jwtTokenProvider) {
        this.jwtTokenProvider = jwtTokenProvider;
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        //HttpServletResponse response = (HttpServletResponse) res;
        
        String requestURI = request.getRequestURI();
        String token = getBearerToken((HttpServletRequest) req);

        if (token != null && !requestURI.contains("/signin/otp")) {
            TokenParams params = null;          
            try {
                params = this.jwtTokenProvider.validateToken(token);
            } catch (JwtException | IllegalArgumentException e) {
                log.warn("Invalid Token: {}, Error: {}", params, e.getMessage());
                //response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "INVALID JWT token");             
                //return;
                throw new UnauthorizedException();
            }

            if (!params.getRoles().contains(WebSecurityConfig.ADMIN) && params.isForOtp() == true) {
                log.warn("Invalid Token: {}, it is for OTP!", params);
                //response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "INVALID JWT token");
                //return;
                throw new UnauthorizedException();
            }
            
            Authentication auth = this.jwtTokenProvider.getAuthentication(token);           
            SecurityContextHolder.getContext().setAuthentication(auth);

            HeaderMapRequestWrapper wrappedRequest = new HeaderMapRequestWrapper(request);
            wrappedRequest.addHeader("companyId", params.getCompanyId());
            wrappedRequest.addHeader("user", params.getEmail());

            filterChain.doFilter(wrappedRequest, res);

        } else {
            filterChain.doFilter(req, res);
        }
    }
    
    private static final String AUTHORIZATION = "Authorization";
    
    private String getBearerToken(HttpServletRequest req) {
        String bearerToken = req.getHeader(AUTHORIZATION);
        /*
         * if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
         * return bearerToken.substring(7, bearerToken.length()); }
         */
        if (bearerToken != null) {
            return bearerToken;
        }
        return null;
    }
    
}