【Java】Java中解决跨域问题的几种方法（建议收藏）

你的名字 2023-10-13 19:42 16阅读 0赞

#### 文章目录 ####

*  背景
 *  一、什么是跨域？为什么会出现跨域
 *  二、Java实现跨域方式
 *   *  2.1、返回新的 CorsFilter(全局跨域)
     *  2.2、重写 WebMvcConfigurer(全局跨域)
     *  2.3、使用注解 (局部跨域)
     *  2.4、手动设置响应头(局部跨域)
     *  2.5、使用自定义filter实现跨域
     *  2.6、Spring Cloud Gateway 跨域配置
     *  2.7、使用Nginx配置
     *  2.8、继承 HandlerInterceptorAdapter

## 背景 ##

我们在开发过程中经常会遇到前后端分离而导致的跨域问题，导致无法获取返回结果。跨域就像分离前端和后端的一道鸿沟，君在这边，她在那边，两两不能往来.

## 一、什么是跨域？为什么会出现跨域 ##

*  定义
    
     *  跨域（CORS）是指不同域名之间相互访问。跨域，指的是浏览器不能执行其他网站的脚本，它是由浏览器的同源策略所造成的，是浏览器对于JavaScript所定义的安全限制策略。  
        当一个请求url的协议、域名、端口三者之间任意一个与当前页面url不同即为跨域。
 *  原因
    
     *  在前后端分离的模式下，前后端的域名是不一致的，此时就会发生跨域访问问题。在请求的过程中我们要想回去数据一般都是post/get请求，所以…跨域问题出现。
     *  跨域问题来源于JavaScript的同源策略，即只有 协议+主机名+端口号(如存在)相同，则允许相互访问。也就是说JavaScript只能访问和操作自己域下的资源，不能访问和操作其他域下的资源。跨域问题是针对JS和ajax的，html本身没有跨域问题，比如a标签、script标签、甚至form标签（可以直接跨域发送数据并接收数据）等
 *  什么情况会跨域
    
     *  同一协议， 如http或https
     *  同一IP地址, 如127.0.0.1
     *  同一端口, 如8080  
        以上三个条件中有一个条件不同就会产生跨域问题。

## 二、Java实现跨域方式 ##

### 2.1、返回新的 CorsFilter(全局跨域) ###

package org.chuancey.config;
     
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.cors.CorsConfiguration;
    import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
    import org.springframework.web.filter.CorsFilter;
     
    @Configuration
    public class GlobalCorsConfig {
        
     
        @Bean
        public CorsFilter corsFilter() {
        
            //1. 添加 CORS配置信息
            CorsConfiguration config = new CorsConfiguration();
            // 放行哪些原始域
            config.addAllowedOrigin("*");
            // 是否发送 Cookie
            config.setAllowCredentials(true);
            // 放行哪些请求方式
            config.addAllowedMethod("*");
            // 放行哪些原始请求头部信息
            config.addAllowedHeader("*");
            // 暴露哪些头部信息
            config.addExposedHeader("*");
            //2. 添加映射路径
            UrlBasedCorsConfigurationSource corsConfigurationSource = new UrlBasedCorsConfigurationSource();
            corsConfigurationSource.registerCorsConfiguration("/**",config);
            //3. 返回新的CorsFilter
            return new CorsFilter(corsConfigurationSource);
        }
     
    }

### 2.2、重写 WebMvcConfigurer(全局跨域) ###

package org.chuancey.config;
     
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.CorsRegistry;
    import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
     
    @Configuration
    public class CorsConfig implements WebMvcConfigurer {
        
     
        @Override
        public void addCorsMappings(CorsRegistry registry) {
        
            registry.addMapping("/**")
                    //放行哪些原始域
                    .allowedOrigins("*")
                    .allowedHeaders("*")
                    // 是否发送Cookie
                    .allowCredentials(true)
                    .allowedMethods("GET", "POST", "OPTIONS", "DELETE", "PUT", "PATCH")
                    .maxAge(3600);
        }
     
        @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
        
            registry.addResourceHandler("/**")
                    .addResourceLocations("classpath:/static/");
            registry.addResourceHandler("swagger-ui.html")
                    .addResourceLocations("classpath:/META-INF/resources/");
            registry.addResourceHandler("doc.html")
                    .addResourceLocations("classpath:/META-INF/resources/");
            registry.addResourceHandler("/webjars/**")
                    .addResourceLocations("classpath:/META-INF/resources/webjars/");
        }
    }

### 2.3、使用注解 (局部跨域) ###

在控制器(类上)上使用注解 @CrossOrigin，表示该类的所有方法允许跨域。

@RestController
    @CrossOrigin(origins = "*")
    public class VerificationController {
        
     
    }

在方法上使用注解 `@CrossOrigin`

@PostMapping("/check/phone")
        @CrossOrigin(origins = "*")
        public boolean checkPhoneNumber(@RequestBody @ApiParam VerificationPojo verification) throws BusinessException {
        
            return false;
        }

### 2.4、手动设置响应头(局部跨域) ###

使用 HttpServletResponse 对象添加响应头(Access-Control-Allow-Origin)来授权原始域，这里 Origin的值也可以设置为 “\*”,表示全部放行。

@RequestMapping("/home")
    public String home(HttpServletResponse response) {
        
        response.addHeader("Access-Allow-Control-Origin","*");
        return "home";
    }

### 2.5、使用自定义filter实现跨域 ###

import java.io.IOException;
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.HttpServletResponse;
    import org.springframework.stereotype.Component;
     
    @Slf4j
    @Configuration
    @WebFilter(filterName = "accessFilter", urlPatterns = "/*")
    public class MyCorsFilter implements Filter {
        
      public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        
        HttpServletResponse response = (HttpServletResponse) res;
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Headers", "x-requested-with,content-type");
        chain.doFilter(req, res);
      }
     
      public void init(FilterConfig filterConfig) {
        log.info("AccessFilter过滤器初始化！");}
     
      public void destroy() {
        }
    }

xml使自定义Filter生效方式

<filter>
     <filter-name>CorsFilter</filter-name>
     <filter-class>org.chuancey.filter.MyCorsFilter</filter-class>
    </filter>
    <filter-mapping>
     <filter-name>CorsFilter</filter-name>
     <url-pattern>/*</url-pattern>
    </filter-mapping>

### 2.6、Spring Cloud Gateway 跨域配置 ###

spring: 
      cloud:
        gateway:
          globalcors:
            cors-configurations:
              '[/**]':
                # 允许跨域的源(网站域名/ip)，设置*为全部
                # 允许跨域请求里的head字段，设置*为全部
                # 允许跨域的method， 默认为GET和OPTIONS，设置*为全部
                allow-credentials: true
                allowed-origins:
                  - "http://xb.abc.com"
                  - "http://sf.xx.com"
                allowed-headers: "*"
                allowed-methods:
                  - OPTIONS
                  - GET
                  - POST
                  - DELETE
                  - PUT
                  - PATCH
                max-age: 3600

注意： 通过gateway 转发的其他项目，不要进行配置跨域配置

有时即使配置了也不会起作用，这时你可以根据浏览器控制的错误输出来查看问题，如果提示是 response 中 header 出现了重复的 Access-Control-\* 请求头，可以进行如下操作

import java.util.ArrayList;
    import org.springframework.cloud.gateway.filter.GatewayFilterChain;
    import org.springframework.cloud.gateway.filter.GlobalFilter;
    import org.springframework.cloud.gateway.filter.NettyWriteResponseFilter;
    import org.springframework.core.Ordered;
    import org.springframework.http.HttpHeaders;
    import org.springframework.stereotype.Component;
    import org.springframework.web.server.ServerWebExchange;
    import reactor.core.publisher.Mono;
     
    @Component("corsResponseHeaderFilter")
    public class CorsResponseHeaderFilter implements GlobalFilter, Ordered {
        
     
      @Override
      public int getOrder() {
        
        // 指定此过滤器位于NettyWriteResponseFilter之后
        // 即待处理完响应体后接着处理响应头
        return NettyWriteResponseFilter.WRITE_RESPONSE_FILTER_ORDER + 1;
      }
     
      @Override
      public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        
        return chain.filter(exchange).then(Mono.defer(() -> {
        
          exchange.getResponse().getHeaders().entrySet().stream()
              .filter(kv -> (kv.getValue() != null && kv.getValue().size() > 1))
              .filter(kv -> (
                  kv.getKey().equals(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN)
                      || kv.getKey().equals(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS)
                      || kv.getKey().equals(HttpHeaders.ACCESS_CONTROL_ALLOW_METHODS)
                      || kv.getKey().equals(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS)
                      || kv.getKey().equals(HttpHeaders.ACCESS_CONTROL_MAX_AGE)))
              .forEach(kv -> {
        
                kv.setValue(new ArrayList<String>() {
        {
        
                  add(kv.getValue().get(0));
                }});
              });
          return chain.filter(exchange);
        }));
      }
    }

### 2.7、使用Nginx配置 ###

location / {
        
       add_header Access-Control-Allow-Origin *;
       add_header Access-Control-Allow-Headers X-Requested-With;
       add_header Access-Control-Allow-Methods GET,POST,PUT,DELETE,OPTIONS;
     
       if ($request_method = 'OPTIONS') {
        
         return 204;
       }
    }

### 2.8、继承 HandlerInterceptorAdapter ###

@Component
    public class CrossInterceptor extends HandlerInterceptorAdapter {
        
     
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
            response.setHeader("Access-Control-Allow-Origin", "*");
            response.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
            response.setHeader("Access-Control-Max-Age", "3600");
            response.setHeader("Access-Control-Allow-Headers", "*");
            response.setHeader("Access-Control-Allow-Credentials", "true");
            return true;
        }
    }