一些Springboot项目跨域请求的解决方法

达摩克利斯

在程序设计中沉浮

1. 一般的跨域请求

在Controller头上加@CrossOrigin就可以了

@RestController
@RequestMapping("/user")
@CrossOrigin
public class UserController {

是这样，我在没有使用shiro控制权限的时候一切都很不错，但是加上shiro之后就开始疯狂跨域。本人猜测应该是过滤器的问题。以下是实践中得知的一些解决方案。

先给出我的Filter类

package com.example.filter;
import com.example.shiro.JWTToken;
import org.apache.shiro.ShiroException;
import org.apache.shiro.authz.UnauthorizedException;
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.RequestMethod;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLEncoder;
 * Created with IntelliJ IDEA
 * @Author yuanhaoyue swithaoy@gmail.com
 * @Description preHandle->isAccessAllowed->isLoginAttempt->executeLogin
 * @Date 2018-04-08
 * @Time 12:36
public class JWTFilter extends BasicHttpAuthenticationFilter {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
     * 如果带有 token，则对 token 进行检查，否则直接通过
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws UnauthorizedException {
        //判断请求的请求头是否带上 "Token"
        System.out.println("在JWTFILTER 的isAccessAllowed");
        if (isLoginAttempt(request, response)) {
            //如果存在，则进入 executeLogin 方法执行登入，检查 token 是否正确
            try {
                executeLogin(request, response);
                return true;
            } catch (Exception e) {
                //token 错误
                logger.error(e.getMessage());
        //如果请求头不存在 Token，则可能是执行登陆操作或者是游客状态访问，无需检查 token，直接返回 true
        return true;
     * 判断用户是否想要登入。
     * 检测 header 里面是否包含 Token 字段
    @Override
    protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
        System.out.println("JWTFILTER 判断用户是否想要登录 isLoginAttempt");
        HttpServletRequest req = (HttpServletRequest) request;
        String token = req.getHeader("Token");
        return token != null;
     * 执行登陆操作
    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        System.out.println("在JWTUTIL执行登录操作 executeLogin");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("Token");
        JWTToken jwtToken = new JWTToken(token);
        // 提交给realm进行登入，如果错误他会抛出异常并被捕获
        getSubject(request, response).login(jwtToken);
        // 如果没有抛出异常则代表登入成功，返回true
        return true;
     * 对跨域提供支持
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        System.out.println("JWTFILTER 预处理prehandle");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
        httpServletResponse.setHeader("Access-Control-Allow-Credentials", "true");
        // 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        return super.preHandle(request, response);

2.本机8081访问8080的时候

已拦截跨源请求：同源策略禁止读取位于 http:// localhost:8080/user/log in 的远程资源。（原因：CORS 头中的 'Access-Control-Allow-Credentials' 预期为 'true'）。

解决方案：

在Filter 的prehandle函数（预处理）里面设置Access-Control-Allow-Credentials的属性
一般网上给的方法没有设置这个，但是今天自暴自弃地想加上试一下，结果成功了。就加在函数里面的一堆设置请求头的东西的下面。

httpServletResponse.setHeader("Access-Control-Allow-Credentials", "true");

一般情况下如果本机的8081访问8080没有什么错的话，服务器那边也是可以的。

3. 也遇到很多本机8081访问8080可以但是部署到服务器就不行的情况

已拦截跨源请求：同源策略禁止读取位于 http:// 47.98.238.175:8080/user /login 的远程资源。（原因:CORS 请求未能成功）（状态码：null）

解决方案：

这种情况一般就是连配置都没有，感觉这个报错是最糟糕的。可以先试一下加一个CorsConfig的类
要记得添加@Configuration的注解

package com.example.config;
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 CorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        System.out.println("在CorsConfig里了");
        registry.addMapping("/**")
                .allowedOriginPatterns("*")
                .allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS")
                .allowCredentials(true)
                .maxAge(3600)
                .allowedHeaders("*");
        System.out.println("结束CorsConfig");

不知道为什么这边已经配置了 .allowCredentials(true) 但是还是需要在Filter里面配置allowCredentials为true，不然就不行。

如果还是不行：

如果和权限（shiro）结合起来的话，去重写Filter里面的preHandle方法，设置请求头。

preHandle函数：

    /**
     * 对跨域提供支持
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        System.out.println("JWTFILTER 预处理prehandle");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
        httpServletResponse.setHeader("Access-Control-Allow-Credentials", "true");
        // 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        return super.preHandle(request, response);
    }

4.一些其他的报错

已拦截跨源请求：同源策略禁止读取位于 http:// 47.98.238.175:8080/user /login 的远程资源。（原因：CORS 头缺少 'Access-Control-Allow-Origin'）（状态码：401）

这个报错非常常见，而且有很大的概率可能已经设置了但是还是不行，或者是进行了一番设置然后报了一堆其他的错。总之可以先看一下浏览器的检查里面，这个请求的头里面到底有没有这个该死的 Access-control-Allow-Origin ,再看看它这个玩意到底设置成了啥。

按照它说的做

看一下preHandle函数里面有没有那个'Access-Control-Allow-Origin'

httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));

一个经常出现的情况：

已拦截跨源请求：同源策略禁止读取位于 ‘ http:// localhost:8080/user/log in ’ 的远程资源。（原因：凭据不支持，如果 CORS 头 ‘Access-Control-Allow-Origin’ 为 ‘*’）。

这个时候肯定是

httpServletResponse.setHeader("Access-control-Allow-Origin", "*");
httpServletResponse.setHeader("Access-Control-Allow-Credentials", "true");

同时，还把那个Credentials设置成了true

就是说这个Credential是true的时候Access-control-Allow-Origin必须非常具体才行，如果有一个固定的ip地址（就是前端部署在哪里就填哪里），可以直接写进去。

所以说比较建议用那个 httpServletRequest.getHeader("Origin")

options请求被拦截的情况：

一般是部署到服务器的时候，有时候也会报跨域的错，然后仔细观察会发现有一个options请求被拦截，这时候需要对options请求做一些处理。

在Filter类里面，仍然是preHandle函数：

httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
// 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
    httpServletResponse.setStatus(HttpStatus.OK.value());
    return false;
}

就是如果是OPTIONS请求的话直接给他放行的意思

另外还有一些地方似乎和OPTIONS有关，应该也要写：

在CorsConfig里面：

@Override
public void addCorsMappings(CorsRegistry registry) {
    System.out.println("在CorsConfig里了");
    registry.addMapping("/**")
            .allowedOriginPatterns("*")
            .allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS")
            .allowCredentials(true)
            .maxAge(3600)
            .allowedHeaders("*");
     System.out.println("结束CorsConfig");
}

偶尔会出现的一个比较特殊的情况：

（原因：不允许有多个 'Access-Control-Allow-Origin' CORS 头）

这个情况一般就是重复定义了 'Access-Control-Allow-Origin' ，删掉一个留一个就行了。比如我在老师给的那个 GlobalCorsConfig 类里面已经定义过了 config.addAllowedOrigin("http://192.168.59.168:8081") ,那就把Filter里面的

httpServletResponse.setHeader("Access-control-Allow-Origin", "*");

相关的注释掉就可以了。

5. 如果还是不行

老师给了一个解决方案，虽然看不出来有哪里比较特别
把那个 config.addAllowedOrigin("*"); 直接写成自己的前端的部署的服务器的域名或者ip就可以了。

package com.example.config;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
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 FilterRegistrationBean corsFilter() {
//1.添加CORS配置信息
        CorsConfiguration config = new CorsConfiguration();
//1) 允许的域,不要写*，否则cookie就无法使用了
// config.addAllowedOrigin("http://localhost:8081");
// config.addAllowedOrigin("http://192.168.59.168:8081")
        config.addAllowedOrigin("*");
//2) 是否发送Cookie信息
        config.setAllowCredentials(true);
//3) 允许的请求方式
        config.addAllowedMethod("OPTIONS");
        config.addAllowedMethod("HEAD");
        config.addAllowedMethod("GET");
        config.addAllowedMethod("PUT");
        config.addAllowedMethod("POST");
        config.addAllowedMethod("DELETE");
        config.addAllowedMethod("PATCH");
        config.setMaxAge(3600L);
// 4）允许的头信息
        config.addAllowedHeader("*");
//2.添加映射路径，我们拦截一切请求
        UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();