使用spring boot CORS跨域请求访问中spring security配置失效的原理解析

最新推荐文章于 2024-04-07 22:01:27 发布

杨jun丨

最新推荐文章于 2024-04-07 22:01:27 发布

阅读量1.5k

点赞数 2

分类专栏： spring boot spring security 跨域问题

本文链接：https://blog.csdn.net/weixin_42198239/article/details/101512676

版权

spring boot spring security 跨域问题专栏收录该内容

1 篇文章 0 订阅

订阅专栏

最近下了个VUE项目，然后登录是没有账号密码验证，想到自己已经写过后台逻辑了，就想这个VUE项目直接调用自己写的后台逻辑，而这两个项目属于同服务器不同端口号，去网上搜索过需要跨域访问，跨域的方法也有许多，然后自己整理整理一下。

跨域访问方法：

1. 返回新的CorsFilter(全局跨域)

package com.xh.technical.yj.frame.cors;

@Configuration
public class CORSConfiguration{
    @Bean
    public CorsFilter corsFilter() {
        //1.添加CORS配置信息
        CorsConfiguration config = new CorsConfiguration();
          //放行哪些原始域
          config.addAllowedOrigin("*");
          //是否发送Cookie信息
          config.setAllowCredentials(true);
          //放行哪些原始域(请求方式)
          config.addAllowedMethod("*");
          //放行哪些原始域(头部信息
          config.addAllowedHeader("*");
          //暴露哪些头部信息（因为跨域访问默认不能获取全部头部信息）
          config.addExposedHeader("*");
 
        //2.添加映射路径
        UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();
        configSource.registerCorsConfiguration("/**", config);
 
        //3.返回新的CorsFilter.
        return new CorsFilter(configSource);
    }
}

2. 重写WebMvcConfigurer（全局跨域）

(1). 1.5版本为继承WebMvcConfigurerAdapter 类实现抽象方法

//springboot 1.5方式
@Configuration
public class WebMvcConfig extends WebMvcConfigurerAdapter {
 
  @Override
  public void addCorsMappings(CorsRegistry registry) {
    registry.addMapping("/**").allowedHeaders("*")
      .allowedMethods("*")
      .allowedOrigins("*")
      .allowCredentials(true);
  }
}

(2). 2.0以后WebMvcConfigurerAdapter已经被弃用，改为继承WebMvcConfigurationSupport类实现抽象方法

//springboot 2.0以上方式
@Configuration
public class WebMvcConfig extends WebMvcConfigurationSupport{
 
  @Override
  public void addCorsMappings(CorsRegistry registry) {
    registry.addMapping("/**").allowedHeaders("*")
      .allowedMethods("*")
      .allowedOrigins("*")
      .allowCredentials(true);
  }
}

提醒：我使用过第2中方法后：发现使用继承会将spring boot 的WebMvc自动配置失效(WebMvcAutoConfiguration自动化配置)，导致视图解析器无法解析并返回到对应的视图。
如果只是接口的调用，无需返回逻辑视图的话可以使用此方法

3. 重写WebMvcConfigurer（全局跨域）

(1). 实现WebMvcConfigurer 接口重写方法需要 jdk8

//jdk8 及以上
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
 
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedHeaders("Content-Type","X-Requested-With","accept,Origin","Access-Control-Request-Method","Access-Control-Request-Headers","token")
                .allowedMethods("*")
                .allowedOrigins("*")
                .allowCredentials(true);
    }
}

因为jdk8中有默认实现接口关键字default，所以重写自己所需要的功能方法，其他默认配置还是存在的。

4. 编写Filter过滤器或者拦截器（全局跨域）

(1)、使用拦截器实现跨域：

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new HandlerInterceptor() {
            @Override
            public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
                response.addHeader("Access-Control-Allow-Origin", "*");
                response.addHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
                response.addHeader("Access-Control-Allow-Headers",
                        "Content-Type,X-Requested-With,accept,Origin,Access-Control-Request-Method,Access-Control-Request-Headers,token");
                return true;
            }
 
            @Override
            public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
 
            }
 
            @Override
            public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
 
            }
        });
    }
 
}

(2)、使用servlet提供的过滤器进行跨域配置：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

/**
 * 请求的基本过滤器 预处理请求头
 */
@Component
@WebFilter(urlPatterns = {"/*"}, filterName = "tokenAuthorFilter")
public class TokenAuthorFilter implements Filter {

    private static Logger LOG = LoggerFactory.getLogger(TokenAuthorFilter.class);

    @Override
    public void destroy() {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse rep = (HttpServletResponse) response;

        HttpSession session = req.getSession();
        LOG.info("sessionId:{}", session.getId());
        //LOG.info("Origin:{}", req.getHeader("Origin"));

        //设置允许跨域的配置
        // 这里填写你允许进行跨域的主机ip（正式上线时可以动态配置具体允许的域名和IP）
        rep.setHeader("Access-Control-Allow-Origin", "*");
        //rep.setHeader("Access-Control-Allow-Origin", "*");
        rep.setHeader("Access-Control-Expose-Headers", jwtProperties.getHeader());
        // 允许的访问方法
        rep.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, OPTIONS, DELETE, PATCH");
        // Access-Control-Max-Age 用于 CORS 相关配置的缓存
        rep.setHeader("Access-Control-Max-Age", "3600");
        rep.setHeader("Access-Control-Allow-Headers", "token, Origin, X-Requested-With, Content-Type, Accept");
        //若要返回cookie、携带seesion等信息则将此项设置我true
        rep.setHeader("Access-Control-Allow-Credentials", "true");
        // 把获取的Session返回个前端Cookie
        //rep.addCookie(new Cookie("JSSESIONID", session.getId()));
        chain.doFilter(req, rep);

    }

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

    }

}

5. 使用注解（局部跨域）

灵活的跨域方式:注解形式
(1). @CrossOrigin使用场景要求：

jdk1.8+
Spring4.2+

(2). @CrossOrigin源码解析：

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CrossOrigin {

    String[] DEFAULT_ORIGINS = { "*" };

    String[] DEFAULT_ALLOWED_HEADERS = { "*" };

    boolean DEFAULT_ALLOW_CREDENTIALS = true;

    long DEFAULT_MAX_AGE = 1800;


    /**
     * 同origins属性一样
     */
    @AliasFor("origins")
    String[] value() default {};

    /**
     * 所有支持域的集合，例如"http://domain1.com"。
     * <p>这些值都显示在请求头中的Access-Control-Allow-Origin
     * "*"代表所有域的请求都支持
     * <p>如果没有定义，所有请求的域都支持
     * @see #value
     */
    @AliasFor("value")
    String[] origins() default {};

    /**
     * 允许请求头重的header，默认都支持
     */
    String[] allowedHeaders() default {};

    /**
     * 响应头中允许访问的header，默认为空
     */
    String[] exposedHeaders() default {};

    /**
     * 请求支持的方法，例如"{RequestMethod.GET, RequestMethod.POST}"}。
     * 默认支持RequestMapping中设置的方法
     */
    RequestMethod[] methods() default {};

    /**
     * 是否允许cookie随请求发送，使用时必须指定具体的域
     */
    String allowCredentials() default "";

    /**
     * 预请求的结果的有效期，默认30分钟
     */
    long maxAge() default -1;
}

(3). @CrossOrigin的使用：

@RestController
@RequestMapping("/account")
public class AccountController {
  
     @CrossOrigin
     @GetMapping("/{id}")
     public Account retrieve(@PathVariable Long id) {
          // ...
      }
 
     @DeleteMapping("/{id}")
     public void remove(@PathVariable Long id) {
        // ...
     }
 }

package com.xh.technical.yj.base.controller;

import com.example.demo.domain.User;
import com.example.demo.service.IUserFind;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @Title: UserController
 * @ProjectName demo
 * @Description: 请求处理控制器
 * @author 
 * @date 2018/7/2022:18
**/
@RestController
//实现跨域注解
//origin="*"代表所有域名都可访问
//maxAge飞行前响应的缓存持续时间的最大年龄，简单来说就是Cookie的有效期 单位为秒
//若maxAge是负数,则代表为临时Cookie,不会被持久化,Cookie信息保存在浏览器内存中,浏览器关闭Cookie就消失
@CrossOrigin(origins = "*",maxAge = 3600)
public class UserController {
    @Resource
    private IUserFind userFind;

    @GetMapping("finduser")
    public User finduser(@RequestParam(value="id") Integer id){
        //此处省略相应代码
    }
}

6. spring security 跨域问题

(1). 配置跨域

@Configuration
public class GlobalCorsConfiguration {

    @Bean
    public CorsFilter corsFilter() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.setAllowCredentials(true);
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
//        corsConfiguration.addExposedHeader("head1");
        //corsConfiguration.addExposedHeader("Location");
        UrlBasedCorsConfigurationSource urlBasedCorsConfigurationSource = new UrlBasedCorsConfigurationSource();
        urlBasedCorsConfigurationSource.registerCorsConfiguration("/**", corsConfiguration);
        return new CorsFilter(urlBasedCorsConfigurationSource);
    }
}

或者

@Configuration
public class CorsConfig extends WebMvcConfigurerAdapter {
    private CorsConfiguration buildConfig() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        corsConfiguration.addExposedHeader("Authorization");
        return corsConfiguration;
    }
 
    @Bean
    public CorsFilter corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", buildConfig());
        return new CorsFilter(source);
    }
 
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("*")
                .allowCredentials(true)
                .allowedMethods("GET", "POST", "DELETE", "PUT")
                .maxAge(3600);
    }
}

(2). spring security下这些跨域配置后，还是会引起跨域的问题，跨域请求还是无法访问，需要在springsecurity配置中加上cors()来开启跨域以及requestMatchers(CorsUtils::isPreFlightRequest).permitAll()来处理跨域请求中的preflight请求。

		http
			.authorizeRequests().antMatchers("/register", "/getVerifyCode").permitAll()
				// 配置安全策略，就是拦截URL，验证访问权限的功能
				.withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {
					@Override
					public <O extends FilterSecurityInterceptor> O postProcess(O o) {
						o.setSecurityMetadataSource(filterInvocationSecurityMetadataSource);
						o.setAccessDecisionManager(accessDecisionManager);
						return o;
					}
				})
		.and()
				// 设置登陆页
				.formLogin().loginPage("/login/toLogin")
				.loginProcessingUrl("/login/logining")
				// 登录失败后的处理方式
				.failureHandler(myFailHandler)
				// 登录成功后的处理方式
				.successHandler(mySuccessHandler)
//				.usernameParameter("userLoginName")
//				.passwordParameter("userLoginPassword")
				.usernameParameter("username")
				.passwordParameter("password")
				.permitAll()
			.and()
				// 验证码功能实现
				.addFilterBefore(new VerifyCodeFilter(), UsernamePasswordAuthenticationFilter.class)
				// 退出登录
				.logout().permitAll().logoutUrl("/login/logout").logoutSuccessUrl("/login/toLogin")
			.and()
				.headers().frameOptions().disable()
			.and()	// 开启cors跨域
				.cors()
			.and()
				 //处理跨域请求中的Preflight请求
				 .csrf().disable().authorizeRequests().requestMatchers(CorsUtils::isPreFlightRequest).permitAll();

以上代码根据我的配置而来，酌情看待。
主要实现配置跨域的代码为：

			.and()	// 开启cors跨域
				.cors()
			.and()
				 //处理跨域请求中的Preflight请求
				 .csrf().disable().authorizeRequests().requestMatchers(CorsUtils::isPreFlightRequest).permitAll()

杨jun丨

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
使用spring boot CORS跨域请求访问中spring security配置失效的原理解析

最近下了个VUE项目，然后登录是没有账号密码验证，想到自己已经写过后台逻辑了，就想这个VUE项目直接调用自己写的后台逻辑，而这两个项目属于同服务器不同端口号，去网上搜索过需要跨域访问。跨域访问方法：1. 返回新的CorsFilter(全局跨域)package com.xh.technical.yj.frame.cors;@Configurationpublic class CORSCo...
复制链接

扫一扫