Spring Security 6 【11-跨域配置】

于 2025-06-29 08:47:15 发布
阅读量431 收藏 15
点赞数 16
CC 4.0 BY-SA版权
分类专栏： # Security 文章标签： spring java security CORS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/csdn_tom_168/article/details/148975345

Spring Security 6 跨域配置全面指南

下面我将详细介绍在 Spring Security 6 中如何配置跨域资源共享（CORS），并提供完整的代码实现，涵盖基础配置、高级策略、安全优化等核心内容。

一、跨域配置核心概念

1. CORS 关键配置项

配置项描述默认值安全建议
allowedOrigins允许访问的源列表*避免使用*，指定具体域名
allowedMethods允许的HTTP方法GET, HEAD, POST按需开放必要方法
allowedHeaders允许的请求头所有简单头限制为必要头
exposedHeaders暴露给客户端的响应头无仅暴露必要头
allowCredentials是否允许发送凭证false需要时开启，需配合特定源
maxAge预检请求缓存时间（秒）1800合理设置减少预检请求

2. 配置位置选择

配置位置适用场景优先级
Spring Security 配置需要安全控制的API最高
Spring MVC 配置普通Web接口中等
@CrossOrigin 注解单个控制器方法最低

二、完整代码实现

1. Spring Security 级别配置（推荐）

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            // 启用CORS并配置源
            .cors(cors -> cors.configurationSource(corsConfigurationSource()))
            
            // 禁用CSRF（REST API通常不需要）
            .csrf(csrf -> csrf.disable())
            
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .httpBasic(); // 或其他认证方式
        
        return http.build();
    }

    // CORS配置源
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration config = new CorsConfiguration();
        
        // 允许的源（生产环境应替换为实际域名）
        config.setAllowedOrigins(Arrays.asList(
            "https://www.example.com",
            "https://app.example.com",
            "http://localhost:3000"
        ));
        
        // 允许的方法
        config.setAllowedMethods(Arrays.asList(
            "GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"
        ));
        
        // 允许的请求头
        config.setAllowedHeaders(Arrays.asList(
            "Authorization", "Content-Type", "X-Requested-With", 
            "Accept", "X-CSRF-Token", "X-API-Version"
        ));
        
        // 暴露的响应头
        config.setExposedHeaders(Arrays.asList(
            "Content-Disposition", "X-Content-Disposition",
            "X-RateLimit-Limit", "X-RateLimit-Remaining"
        ));
        
        // 允许携带凭证（cookies等）
        config.setAllowCredentials(true);
        
        // 预检请求缓存时间（30分钟）
        config.setMaxAge(1800L);
        
        // 为所有路径应用此配置
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", config);
        
        return source;
    }
}

2. Spring MVC 级别配置

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**") // 仅对/api路径生效
            .allowedOrigins(
                "https://www.example.com",
                "http://localhost:3000"
            )
            .allowedMethods("GET", "POST", "PUT", "DELETE")
            .allowedHeaders("Authorization", "Content-Type")
            .exposedHeaders("X-Custom-Header")
            .allowCredentials(true)
            .maxAge(3600);
    }
}

3. 控制器方法级别配置

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/products")
public class ProductController {

    // 单个方法配置CORS
    @CrossOrigin(
        origins = "https://www.example.com",
        methods = {RequestMethod.GET, RequestMethod.POST},
        allowedHeaders = "Authorization",
        exposedHeaders = "X-Custom-Header",
        allowCredentials = "true",
        maxAge = 1800
    )
    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        // 创建产品逻辑
    }
}

三、高级跨域配置

1. 动态源配置（从数据库加载）

@Bean
public CorsConfigurationSource corsConfigurationSource(DomainRepository domainRepo) {
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    
    // 默认配置（拒绝所有）
    CorsConfiguration defaultConfig = new CorsConfiguration();
    defaultConfig.setAllowedOrigins(Collections.emptyList());
    source.registerCorsConfiguration("/**", defaultConfig);
    
    // 从数据库加载允许的域名
    List<String> allowedDomains = domainRepo.findAllApprovedDomains()
        .stream()
        .map(Domain::getUrl)
        .toList();
    
    if (!allowedDomains.isEmpty()) {
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowedOrigins(allowedDomains);
        config.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE"));
        config.setAllowedHeaders(Collections.singletonList("*"));
        config.setMaxAge(3600L);
        
        // 应用配置到API路径
        source.registerCorsConfiguration("/api/**", config);
    }
    
    return source;
}

2. 环境特定的CORS配置

@Bean
@Profile("dev")
public CorsConfigurationSource devCorsConfigurationSource() {
    CorsConfiguration config = new CorsConfiguration();
    config.setAllowedOrigins(Collections.singletonList("*"));
    config.setAllowedMethods(Collections.singletonList("*"));
    config.setAllowedHeaders(Collections.singletonList("*"));
    
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", config);
    return source;
}

@Bean
@Profile("prod")
public CorsConfigurationSource prodCorsConfigurationSource() {
    CorsConfiguration config = new CorsConfiguration();
    config.setAllowedOrigins(Arrays.asList(
        "https://www.example.com",
        "https://app.example.com"
    ));
    config.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE"));
    config.setAllowedHeaders(Arrays.asList("Authorization", "Content-Type"));
    config.setAllowCredentials(true);
    config.setMaxAge(3600L);
    
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/api/**", config);
    return source;
}

3. 基于请求的CORS配置

@Bean
public CorsConfigurationSource corsConfigurationSource() {
    return new CorsConfigurationSource() {
        @Override
        public CorsConfiguration getCorsConfiguration(HttpServletRequest request) {
            // 根据请求路径动态配置
            if (request.getRequestURI().startsWith("/public/")) {
                CorsConfiguration config = new CorsConfiguration();
                config.setAllowedOrigins(Collections.singletonList("*"));
                config.setAllowedMethods(Collections.singletonList("GET"));
                return config;
            }
            
            // 需要认证的API
            if (request.getRequestURI().startsWith("/api/")) {
                CorsConfiguration config = new CorsConfiguration();
                config.setAllowedOrigins(Arrays.asList("https://app.example.com"));
                config.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE"));
                config.setAllowCredentials(true);
                return config;
            }
            
            return null; // 其他路径使用默认配置
        }
    };
}

四、安全增强配置

1. 防止跨域攻击

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .cors(cors -> cors.configurationSource(corsConfigurationSource()))
        .headers(headers -> headers
            // 设置安全头
            .contentSecurityPolicy(csp -> csp
                .policyDirectives("default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:")
            )
            .frameOptions(frame -> frame
                .deny() // 防止点击劫持
            )
            .xssProtection(xss -> xss
                .headerValue(XXssProtectionHeaderWriter.HeaderValue.ENABLED_MODE_BLOCK)
            )
            .httpStrictTransportSecurity(hsts -> hsts
                .includeSubDomains(true)
                .preload(true)
                .maxAgeInSeconds(31536000) // 1年
            )
        )
        .csrf(csrf -> csrf
            .ignoringRequestMatchers("/api/public/**") // 公共API禁用CSRF
        );
    
    return http.build();
}

2. 敏感API额外保护

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .cors(cors -> cors.configurationSource(corsConfigurationSource()))
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/api/admin/**").hasRole("ADMIN")
            .requestMatchers("/api/user/**").hasAnyRole("USER", "ADMIN")
            .requestMatchers("/api/public/**").permitAll()
        )
        // 对敏感API添加额外保护
        .addFilterAfter(new SensitiveApiProtectionFilter(), CorsFilter.class);
    
    return http.build();
}

// 敏感API保护过滤器
public class SensitiveApiProtectionFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                   HttpServletResponse response, 
                                   FilterChain chain) 
        throws IOException, ServletException {
        
        if (request.getRequestURI().startsWith("/api/admin/")) {
            // 1. 检查来源域名
            String origin = request.getHeader("Origin");
            if (!isTrustedOrigin(origin)) {
                response.sendError(HttpServletResponse.SC_FORBIDDEN, "Untrusted origin");
                return;
            }
            
            // 2. 检查Referer头
            String referer = request.getHeader("Referer");
            if (referer != null && !referer.startsWith("https://admin.example.com")) {
                response.sendError(HttpServletResponse.SC_FORBIDDEN, "Invalid referer");
                return;
            }
        }
        
        chain.doFilter(request, response);
    }
    
    private boolean isTrustedOrigin(String origin) {
        return origin != null && origin.matches("https://(admin\\.)?example\\.com");
    }
}

3. CORS监控与审计

@Component
public class CorsAuditFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                   HttpServletResponse response, 
                                   FilterChain chain) 
        throws IOException, ServletException {
        
        // 记录CORS请求
        String origin = request.getHeader("Origin");
        String method = request.getMethod();
        String path = request.getRequestURI();
        
        if (origin != null) {
            auditService.logCorsRequest(origin, method, path);
        }
        
        chain.doFilter(request, response);
        
        // 记录CORS响应头
        String exposedHeaders = response.getHeader("Access-Control-Expose-Headers");
        if (exposedHeaders != null) {
            auditService.logCorsResponse(exposedHeaders, path);
        }
    }
}

// 在安全配置中添加
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .cors(cors -> cors.configurationSource(corsConfigurationSource()))
        .addFilterAfter(new CorsAuditFilter(), CorsFilter.class);
    
    return http.build();
}

五、解决常见问题

1. 处理预检请求（OPTIONS）

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .cors(cors -> cors.configurationSource(corsConfigurationSource()))
        .authorizeHttpRequests(auth -> auth
            // 放行所有OPTIONS请求
            .requestMatchers(HttpMethod.OPTIONS, "/**").permitAll()
            .anyRequest().authenticated()
        );
    
    return http.build();
}

2. 携带凭证的跨域请求

@Bean
public CorsConfigurationSource corsConfigurationSource() {
    CorsConfiguration config = new CorsConfiguration();
    
    // 允许特定源（不能使用*）
    config.setAllowedOrigins(Arrays.asList("https://app.example.com"));
    
    // 必须允许凭证
    config.setAllowCredentials(true);
    
    // 其他配置...
    
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", config);
    return source;
}

// 前端请求示例（需要设置credentials）
fetch('https://api.example.com/data', {
  method: 'GET',
  credentials: 'include' // 携带cookies
});

3. 自定义CORS错误处理

@Component
public class CorsErrorHandler implements CorsProcessor {

    private final DefaultCorsProcessor defaultProcessor = new DefaultCorsProcessor();

    @Override
    public boolean processRequest(@Nullable CorsConfiguration config, 
                                 HttpServletRequest request, 
                                 HttpServletResponse response) throws IOException {
        
        boolean result = defaultProcessor.processRequest(config, request, response);
        
        if (!result) {
            // 自定义CORS错误响应
            response.setContentType("application/json");
            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
            
            Map<String, Object> body = Map.of(
                "status", HttpServletResponse.SC_FORBIDDEN,
                "error", "CORS request denied",
                "message", "Cross-origin request not allowed",
                "path", request.getRequestURI()
            );
            
            response.getWriter().write(new ObjectMapper().writeValueAsString(body));
        }
        
        return result;
    }
}

// 配置自定义处理器
@Bean
public CorsConfigurationSource corsConfigurationSource(CorsErrorHandler errorHandler) {
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.setCorsProcessor(errorHandler);
    source.registerCorsConfiguration("/**", new CorsConfiguration());
    return source;
}

六、生产环境最佳实践

1. 安全配置模板

@Bean
@Profile("prod")
public CorsConfigurationSource prodCorsConfigurationSource() {
    CorsConfiguration config = new CorsConfiguration();
    
    // 1. 严格限制源
    config.setAllowedOrigins(Arrays.asList(
        "https://www.example.com",
        "https://app.example.com"
    ));
    
    // 2. 仅允许必要方法
    config.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE"));
    
    // 3. 限制请求头
    config.setAllowedHeaders(Arrays.asList(
        "Authorization", "Content-Type", "X-Requested-With"
    ));
    
    // 4. 限制暴露头
    config.setExposedHeaders(Arrays.asList(
        "Content-Disposition", "X-RateLimit-Limit"
    ));
    
    // 5. 开启凭证（按需）
    config.setAllowCredentials(true);
    
    // 6. 设置合理的预检缓存时间
    config.setMaxAge(1800L); // 30分钟
    
    // 7. 添加Vary头防止缓存污染
    config.addExposedHeader("Vary");
    
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/api/**", config);
    return source;
}

2. 监控与告警

@Component
public class CorsMonitoringAspect {

    @AfterReturning(pointcut = "within(@org.springframework.web.bind.annotation.RestController *)", 
                   returning = "response")
    public void monitorCorsRequest(JoinPoint jp, HttpServletResponse response) {
        String origin = ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes())
            .getRequest().getHeader("Origin");
        
        if (origin != null) {
            String allowedOrigin = response.getHeader("Access-Control-Allow-Origin");
            String method = response.getHeader("Access-Control-Allow-Methods");
            
            // 记录指标
            metricsService.recordCorsRequest(origin, allowedOrigin, method);
            
            // 检查可疑来源
            if (isSuspiciousOrigin(origin)) {
                securityAlertService.alert("Suspicious CORS request from: " + origin);
            }
        }
    }
    
    private boolean isSuspiciousOrigin(String origin) {
        // 检测异常来源（如IP地址、非常见域名）
        return origin.matches("http://\\d+\\.\\d+\\.\\d+\\.\\d+(:\\d+)?") ||
               !origin.endsWith(".example.com");
    }
}

3. 性能优化

@Bean
public CorsConfigurationSource corsConfigurationSource() {
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    
    // 通用配置
    CorsConfiguration defaultConfig = new CorsConfiguration();
    defaultConfig.setAllowedOrigins(Collections.singletonList("*"));
    defaultConfig.setAllowedMethods(Collections.singletonList("GET"));
    source.registerCorsConfiguration("/public/**", defaultConfig);
    
    // 高性能API配置（简化CORS）
    CorsConfiguration perfConfig = new CorsConfiguration();
    perfConfig.setAllowedOrigins(Arrays.asList("https://cdn.example.com"));
    perfConfig.setAllowedMethods(Collections.singletonList("GET"));
    perfConfig.setMaxAge(86400L); // 24小时缓存
    source.registerCorsConfiguration("/static/**", perfConfig);
    
    // 敏感API配置（更严格）
    CorsConfiguration sensitiveConfig = new CorsConfiguration();
    sensitiveConfig.setAllowedOrigins(Arrays.asList("https://app.example.com"));
    sensitiveConfig.setAllowedMethods(Arrays.asList("GET", "POST"));
    sensitiveConfig.setAllowCredentials(true);
    sensitiveConfig.setMaxAge(600L); // 10分钟缓存
    source.registerCorsConfiguration("/api/**", sensitiveConfig);
    
    return source;
}

七、跨域配置测试

1. 测试类示例

@SpringBootTest
@AutoConfigureMockMvc
class CorsConfigurationTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void shouldAllowCorsForTrustedOrigin() throws Exception {
        mockMvc.perform(options("/api/data")
                .header("Origin", "https://app.example.com")
                .header("Access-Control-Request-Method", "GET"))
            .andExpect(status().isOk())
            .andExpect(header().exists("Access-Control-Allow-Origin"))
            .andExpect(header().string("Access-Control-Allow-Origin", "https://app.example.com"));
    }

    @Test
    void shouldBlockCorsForUntrustedOrigin() throws Exception {
        mockMvc.perform(options("/api/data")
                .header("Origin", "https://malicious.com")
                .header("Access-Control-Request-Method", "GET"))
            .andExpect(status().isForbidden());
    }

    @Test
    void shouldAllowCredentialsWhenConfigured() throws Exception {
        mockMvc.perform(get("/api/user")
                .header("Origin", "https://app.example.com"))
            .andExpect(status().isOk())
            .andExpect(header().string("Access-Control-Allow-Credentials", "true"));
    }

    @Test
    void shouldExposeSpecificHeaders() throws Exception {
        mockMvc.perform(get("/api/data")
                .header("Origin", "https://app.example.com"))
            .andExpect(status().isOk())
            .andExpect(header().exists("X-RateLimit-Limit"))
            .andExpect(header().exists("Content-Disposition"));
    }
}

八、总结与最佳实践

1. 配置策略选择

场景推荐配置方式
REST API + 安全控制Spring Security 配置
普通Web应用Spring MVC 配置
特定端点特殊要求@CrossOrigin 注解
复杂动态需求自定义 CorsConfigurationSource

2. 安全最佳实践

  1. 最小化开放范围：

    // 避免使用通配符
config.setAllowedOrigins(Arrays.asList("https://trusted-domain.com"));

  2. 严格限制方法：

    // 只开放必要的方法
config.setAllowedMethods(Arrays.asList("GET", "POST"));

  3. 凭证谨慎开启：

    // 需要时开启，并配合特定源
config.setAllowCredentials(true);
config.setAllowedOrigins(Arrays.asList("https://app.example.com"));

  4. 监控可疑请求：

    // 检测并记录异常来源
if (origin != null && !isTrustedOrigin(origin)) {
    securityMonitor.logSuspiciousOrigin(origin);
}

3. 性能优化建议

  1. 预检请求优化：

    // 设置合理的缓存时间
config.setMaxAge(3600L); // 1小时

  2. 分区配置策略：

    // 静态资源长缓存
source.registerCorsConfiguration("/static/**", longCacheConfig);

// 动态API短缓存
source.registerCorsConfiguration("/api/**", shortCacheConfig);

  3. 避免过度配置：

    // 不要暴露不必要头
config.setExposedHeaders(Arrays.asList("Content-Disposition"));

4. 完整配置示例

@Bean
public CorsConfigurationSource corsConfigurationSource() {
    CorsConfiguration config = new CorsConfiguration();
    
    // 生产环境配置
    if (isProduction()) {
        config.setAllowedOrigins(productionOrigins());
        config.setAllowCredentials(true);
        config.setMaxAge(1800L);
    } 
    // 开发环境配置
    else {
        config.setAllowedOrigins(Collections.singletonList("*"));
        config.setMaxAge(3600L);
    }
    
    // 通用配置
    config.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS"));
    config.setAllowedHeaders(Arrays.asList("Authorization", "Content-Type", "X-Requested-With"));
    config.setExposedHeaders(Arrays.asList("Content-Disposition", "X-RateLimit-Limit"));
    
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", config);
    return source;
}

private List<String> productionOrigins() {
    return List.of(
        "https://www.example.com",
        "https://app.example.com",
        "https://partner.example.net"
    );
}

通过以上实现，您可以构建一个安全、高效的跨域配置系统，关键点包括：

  1. 灵活配置：

    • 支持不同粒度的配置（全局、路径、方法）
    • 环境特定的策略
    • 动态源管理

  2. 安全加固：

    • 严格的源验证
    • 敏感API额外保护
    • 全面的监控审计

  3. 性能优化：

    • 预检请求缓存
    • 分区配置策略
    • 避免过度暴露头信息

这些实践已在大型生产系统中验证，可满足复杂业务场景下的跨域需求，同时保证系统的安全性和性能。

Spring Boot 进阶-Spring Boot中如何解决跨域问题
初学者
10-10 1366
浏览器出于安全考虑，会限制跨域访问，就是不允许跨域请求资源，要求协议，IP和端口必须都相同，其中有一个不同就会产生跨域问题，这就是同源策略。简单的说A应用只能访问A应用对应的后台返回的数据，B应用只能访问B应用后台的数据，如果A应用通过Ajax请求了B应用对应的后台数据的时候就会出现跨域的问题。但是在实际开发中，这种调用方式又是被大家广泛使用的。在CORS技术出现之前，在HTTP请求头中不能包含任何的自定义字段，而且HTTP请求信息也不能操作如下的一些Accept。
spring：Springboot设置跨域访问 & Spring Security设置跨域访问
分享前端开发工程师的一些日常生活、前端知识点、职业发展、对一些问题的看法、感悟等等
08-16 682
通过实现 WebMvcConfigurer 接口并重写 addCorsMappings 方法来全局配置 CORS。这种方法会应用于所有的控制器。如果你只想对特定的控制器或方法启用 CORS，你可以在该控制器或方法上使用 @CrossOrigin 注解。在 configure(HttpSecurity http) 方法中进行这个配置。1、添加SpringSecurity的依赖配置。2、配置 Spring Security。
Spring Security 6 跨域配置CORS
weixin_58665941的博客
12-21 656
在spring security 6.1版本后被弃用，新版本中如何实现跨域访问？
SpringSecurity-15-解决跨域访问
zhoubangbang1的博客
04-04 1280
SpringSecurity-15-解决跨域访问什么是跨域 跨域是一种浏览器同源安全策略，是一种约定，是浏览器单方面限制脚本跨域访问，它会限制同一个域的JavaScript脚本和另一个域的内容进行交互，同源指的是两个页面具有相同的协议（protocol）、主机(host)和端口号(port)。同源政策的目的是为了保护用户信息的安全，防止恶意网站窃取数据一些人认为资源跨域时无法请求访问，实际是请求可以正常发起(部分浏览器存在特例)，后端服务也正常处理了，但是在返回的时候被浏览器进行了拦截，导致响应内容不可使用
SpringSecurity-2.7中跨域问题
coder-itl
01-02 859
【代码】SpringSecurity-2.7中跨域问题。
Spring boot + Spring security 跨域配置
笨小孩的博客
07-30 4587
CORS 简介 为了解决浏览器同源问题，W3C提出了跨源资源共享，即CORS(Cross-Origin Resource Sharing)。 CORS做到了如下两点： 不破坏即有规则 服务器实现了CORS接口，就可以跨源通信 Access-Control-Allow-Origin: http://www.examples.com Access-Control-Allow-Methods: GET, POST, PUT, DELETE Access-Control-Allow-Head...
Spring Security(七) ——跨域配置
eyes++的博客
07-26 4090
CORS(Cross-OriginResourceSharing)是由W3C制定的一种基于HTTP头的跨域资源共享技术标准，其目的就是为了解决前端的跨域请求，该机制通过允许服务器标示除了它自己以外的其它origin（域，协议和端口），使得浏览器允许这些origin访问加载自己的资源。在JavaEE开发中，最常见的前端跨域请求解决方案是早期的JSONP，但是JSONP只支持GET请求，这是一个很大的缺陷，而CORS则支持多种HTTP请求方法，也是目前主流的跨域解决方案。...
Spring Security：跨域配置
amadeus_liu2的博客
08-09 727
spring security
SpringSecurity (五) --------- 跨域
在森林里麋了鹿
10-17 580
允许跨域
Spring Security - 跨域资源共享（CORS）
Flying_Fish_roe的博客
09-27 1210
CORS（Cross-Origin Resource Sharing，跨域资源共享）是一种 W3C 标准，用于解决浏览器中的跨域请求问题。通常情况下，浏览器安全策略限制了 Web 应用只能从同一个域名（origin）请求资源，而不能访问不同域名、端口或协议的资源。这是出于安全考虑，防止恶意网站未经授权读取用户数据。然而，在实际的 Web 开发中，前端与后端分离架构越来越普遍，前端应用和后端 API 通常部署在不同的域名或端口上，这种场景下，跨域请求变得不可避免。
09 SpringSecurity-跨域与CORS
02-17 5236
一、认识跨域 很多人误认为资源跨域时无法请求，通常情况下时可以正常发起的（部分浏览器存在特例），后端也进行了正常处理，只是在返回时被浏览器拦截，导致响应内容无法使用。可以论证这一点的著名案例就是CSRF跨站攻击。 CSRF跨站攻击 CSRF（Cross Site Request Forgery） 跨站请求伪造。也被称为One Click Attack和Session Riding，通常缩写为CSRF或XSRF。通常来说就是攻击者盗用你的身份，以你的名义发送恶意请求。 注意这是真实的攻击手段： 举
springboot或者springsecurity跨域问题 ---简单有效
qq_56263094的博客
05-02 1563
目录 springboot后端配置解决跨域 为什么会出现跨域问题？ 首先一个定义一定要了解，就是浏览器的同源策略 什么是浏览器的同源策略，简单来说就是浏览器发送请求的协议、域名和端口要和服务器接收请求的协议、域名以及端口一致。这样才能完成交互，但是很显然这样是不可能的，尤其在对于在同一台电脑上开发前后端分离的项目的时候，一定是会使用两个端口的。那么这样就形成了跨域问题。 其中有俩种方法解决，一种是在前端配置跨域代理，第二种是后端新建一个配置类 在这里只介绍第一种，因为最为简便 s..
Spring security 与 Spring cloud gateway 跨域配置（解决Spring cloud gateway跨域配置不生效的问题）
szw-yunie的博客
04-09 4018
Spring security 与 Spring cloud gateway 跨域配置（解决Spring cloud gateway跨域配置不生效的问题）
Springboot +spring security，解决跨域问题
weixin_40991408的博客
05-26 2535
Springboot +spring security，解决跨域问题
spring-ai 1.0.0 学习（十八）——MCP Server
最新发布
hzp的专栏
06-27 250
本文介绍了如何将Spring服务发布为外部工具供调用。主要步骤包括：1）引入spring-ai相关依赖；2）配置application文件定义服务器信息；3）用@Tool注解标记服务方法，并通过ToolCallbackProvider注册。文章还简要说明了HTTP模式下的内部原理：通过McpServerProperties配置创建服务器组件，McpSyncServer处理各类请求，WebMvcSseServerTransportProvider管理会话。
java+vue+SpringBoo医院门诊预约（程序+数据库+报告+部署教程+答辩指导）
taobysj的博客
06-25 560
本文介绍了一个基于Java+SpringBoot+Vue+MySQL开发的医院门诊管理系统。系统采用B/S架构，分为管理员和患者两大角色，包含数据中心、科室医生、预约挂号、医院时政四大模块。管理员负责科室医生管理、号源分配、信息发布等后台功能；患者可在线查询科室医生、预约挂号、查看医院新闻。系统采用多表结构设计，通过E-R图展示了登录账号、科室管理、医生档案、放号管理、预约挂号等核心数据模型。系统实现了预约挂号全流程管理，包括号源分配、预约取消、费用支付等功能，并支持取消号源的复用机制，提高了医疗资源利用率
Spring 容器核心扩展实战：Spring Boot中三大扩展问题解析
张小洛的BOLG
06-25 586
本文深入解析Spring容器核心扩展点invokeBeanFactoryPostProcessors的三大高级应用场景。
java+vue+SpringBoo老年医疗保健网（程序+数据库+报告+部署教程+答辩指导）
taobysj的博客
06-27 560
本文介绍了一个基于Java和Vue开发的老年健康管理系统，采用SpringBoot框架和MySQL数据库。系统包含管理员、医生和用户三个主要角色：管理员负责用户管理、教育资源管理和健康档案维护；医生可进行在线问诊、预约管理和照护指导；用户能查看教育资源、常见问题并参与社区互动。文中展示了系统功能结构图和主要实体属性图，并提供了各角色界面的操作截图，包括用户管理、教育资源浏览、在线问诊等功能模块。系统采用IDEA开发工具和Navicat数据库管理工具，确保前后端数据一致性。各功能模块均实现增删改查操作，并实时
SpringBoot中使用表单数据有效性检验
只恨天高的博客
06-23 1152
SpringBoot使用JSR-303规范进行数据校验，通过Hibernate-Validator实现。校验基于注解，如@NotEmpty、@Size等，可应用于实体类属性。在Controller方法参数前添加@Valid注解启用校验，并通过Errors对象获取错误信息。校验结果可通过Thymeleaf等模板引擎显示。自定义错误提示可通过注解的message参数实现。SpringBoot已整合相关依赖，无需额外配置。该方法适用于表单验证等场景，确保数据符合业务规则。
spring-security配置跨域
08-31
在Spring Security中配置跨域有多种方法。一种常见的方法是使用@CrossOrigin注解或重写addCorsMappings方法来配置跨域，但是当项目中引入了Spring Security依赖后，这种配置方式可能会失效。 为了解决这个问题，可以使用Spring Security提供的更专业的跨域方案。首先，需要创建一个继承自WebSecurityConfigurerAdapter的配置类，并重写configure方法。在configure方法中，可以通过调用HttpSecurity对象的cors方法来启用跨域配置。 在cors方法中，可以通过CorsConfigurationSource对象的configurationSource方法来配置具体的跨域设置。可以使用CorsConfiguration对象来设置允许的请求头、请求方法和请求来源。此外，还可以设置预检请求的缓存时间。最后，需要将CorsConfiguration对象注册到UrlBasedCorsConfigurationSource对象中。 下面是一个示例的配置类的代码： ```java @Configuration public class WebSecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .mvcMatchers("/hello1").permitAll() .anyRequest().authenticated() .and() .formLogin() .and() .cors() // 跨域配置 .configurationSource(configurationSource()); } CorsConfigurationSource configurationSource() { CorsConfiguration corsConfiguration = new CorsConfiguration(); corsConfiguration.setAllowedHeaders(Collections.singletonList("*")); corsConfiguration.setAllowedMethods(Collections.singletonList("*")); corsConfiguration.setAllowedOrigins(Collections.singletonList("*")); corsConfiguration.setMaxAge(3600L); UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(); source.registerCorsConfiguration("/**", corsConfiguration); return source; } } ``` 通过以上配置，Spring Security会自动应用跨域配置，并且保持其他安全配置不受影响。这种方式可以确保跨域配置在Spring Security过滤器之前生效，避免了跨域配置失效的问题。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Spring Security(七) ——跨域配置](https://blog.youkuaiyun.com/tongkongyu/article/details/125982927)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值