Wie löst Springboot domänenübergreifende Probleme?

Der Inhalt dieses Artikels handelt davon, wie Springboot domänenübergreifende Probleme löst. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird Ihnen hilfreich sein.

1. Was ist eine domänenübergreifende HTTP-Anfrage?

Aus Sicherheitsgründen müssen moderne Browser dieselbe Ursprungsrichtlinie einhalten, wenn sie das XMLHttpRequest-Objekt zum Initiieren von HTTP verwenden Anfragen, andernfalls sind domänenübergreifende HTTP-Anfragen standardmäßig verboten. Domänenübergreifende HTTP-Anfragen beziehen sich auf Ressourcen in Domäne A, die Ressourcen in Domäne B anfordern. Beispielsweise fordert der auf Nginx auf Maschine A bereitgestellte js-Code die auf Tomcat auf Maschine B bereitgestellte RESTful-Schnittstelle über Ajax an. (Empfohlen: Java Video Tutorial)

Unterschiedliche IP-Adressen (Domänennamen) oder unterschiedliche Ports führen zu domänenübergreifenden Problemen. Um domänenübergreifende Probleme zu lösen, gab es Lösungen wie JSONP und Proxy-Dateien. Die Anwendungsszenarien waren begrenzt und die Wartungskosten waren hoch, bis HTML5 das CORS-Protokoll auf den Markt brachte.

CORS ist ein W3C-Standard. Der vollständige Name lautet „Cross-Origin Resource Sharing“ (Cross-Origin Resource Sharing), der es Browsern ermöglicht, XMLHttpRequest-Anfragen an Cross-Origin-Server zu senden und so das Problem von AJAX zu überwinden kann nur ab demselben Ursprungslimit verwendet werden. Es fügt dem Server einen speziellen Header [Access-Control-Allow-Origin] hinzu, um dem Client die domänenübergreifenden Einschränkungen mitzuteilen. Wenn der Browser CORS unterstützt und feststellt, dass Origin erfolgreich ist, darf XMLHttpRequest domänenübergreifende Anforderungen initiieren.

CROS common header

Access-Control-Allow-Origin: http://somehost.com bedeutet, dass http://somehost.com domänenübergreifende Anfragen initiieren darf.
Access-Control-Max-Age:86400 bedeutet, dass innerhalb von 86400 Sekunden keine Vorverifizierungsanfragen gesendet werden müssen.
Access-Control-Allow-Methods: GET, POST, PUT, DELETE gibt Methoden an, die domänenübergreifende Anfragen ermöglichen.
Access-Control-Allow-Headers: Content-Type gibt an, dass domänenübergreifende Anforderungen Content-Type enthalten dürfen

2. CORS implementiert domänenübergreifenden Zugriff

Autorisierungsmethode
Methode 1: Einen neuen CorsFilter zurückgeben
Methode 2: WebMvcConfigurer überschreiben
Methode 3: Anmerkungen verwenden (@CrossOrigin)
Methode 4: Antwortheader manuell festlegen (HttpServletResponse)

Hinweis: Die Methoden 1 und 2 gehören zur globalen CORS-Konfiguration und die Methoden 3 und 4 gehören zur lokalen CORS-Konfiguration. Wenn lokale domänenübergreifende Regeln verwendet werden, werden die globalen domänenübergreifenden Regeln außer Kraft gesetzt, sodass die Annotation @CrossOrigin für eine detailliertere domänenübergreifende Ressourcensteuerung verwendet werden kann.

1. Neuen CorsFilter zurückgeben (global domänenübergreifend)

2. WebMvcConfigurer überschreiben (global domänenübergreifend)

Jede Konfigurationsklasse, Geben Sie ein neues WebMvcConfigurer-Bean zurück und schreiben Sie die von ihm bereitgestellte Schnittstelle zur domänenübergreifenden Anforderungsverarbeitung neu, um Zuordnungspfade und spezifische CORS-Konfigurationsinformationen hinzuzufügen.

package com.hehe.yyweb.config;

@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 configSource = new UrlBasedCorsConfigurationSource();
        configSource.registerCorsConfiguration("/**", config);

        //3.返回新的CorsFilter.
        return new CorsFilter(configSource);
    }
}

3. Annotationen verwenden (lokal domänenübergreifend)

Verwenden Sie die Annotation @CrossOrigin auf der Methode (@RequestMapping):

package com.hehe.yyweb.config;

@Configuration
public class GlobalCorsConfig {
    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            //重写父类提供的跨域请求处理的接口
            public void addCorsMappings(CorsRegistry registry) {
                //添加映射路径
                registry.addMapping("/**")
                        //放行哪些原始域
                        .allowedOrigins("*")
                        //是否发送Cookie信息
                        .allowCredentials(true)
                        //放行哪些原始域(请求方式)
                        .allowedMethods("GET","POST", "PUT", "DELETE")
                        //放行哪些原始域(头部信息)
                        .allowedHeaders("*")
                        //暴露哪些头部信息（因为跨域访问默认不能获取全部头部信息）
                        .exposedHeaders("Header1", "Header2");
            }
        };
    }
}

oder auf dem Controller (@Controller). ) Verwenden Sie die Annotation @CrossOrigin:

@RequestMapping("/hello")
@ResponseBody
@CrossOrigin("http://localhost:8080") 
public String index( ){
    return "Hello World";
}

Antwortheader manuell festlegen (teilweise domänenübergreifend)

Verwenden Sie das HttpServletResponse-Objekt, um den Antwortheader hinzuzufügen (Access-Control -Allow-Origin) für die Autorisierung der Originaldomäne, der Wert von Origin kann hier auch auf „*“ gesetzt werden, was bedeutet, dass alle erlaubt sind.

@Controller
@CrossOrigin(origins = "http://xx-domain.com", maxAge = 3600)
public class AccountController {

    @RequestMapping("/hello")
    @ResponseBody
    public String index( ){
        return "Hello World";
    }
}

3. Testen Sie den domänenübergreifenden Zugriff

Verwenden Sie zunächst Spring Initializr, um schnell ein Maven-Projekt zu erstellen, ohne etwas zu ändern. Fügen Sie im statischen Verzeichnis eine Seite hinzu: index.html, um den domänenübergreifenden Zugriff zu simulieren. Domänenzugriff. Zieladresse: http://localhost:8090/hello

@RequestMapping("/hello")
@ResponseBody
public String index(HttpServletResponse response){
    response.addHeader("Access-Control-Allow-Origin", "http://localhost:8080");
    return "Hello World";
}

Erstellen Sie dann ein weiteres Projekt, fügen Sie das Config-Verzeichnis im Root-Paket hinzu und erstellen Sie eine Konfigurationsklasse, um globales CORS zu aktivieren.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8"/>
    <title>Page Index</title>
</head>
<body>
<h2>前台系统</h2>
<p id="info"></p>
</body>
<script src="webjars/jquery/3.2.1/jquery.js"></script>
<script>
    $.ajax({
        url: 'http://localhost:8090/hello',
        type: "POST",
        xhrFields: {
           withCredentials: true //允许跨域认证
        },
        success: function (data) {
            $("#info").html("跨域访问成功:"+data);
        },
        error: function (data) {
            $("#info").html("跨域失败!!");
        }
    })
</script>
</html>

Als nächstes schreiben Sie einfach eine Rest-Schnittstelle und geben den Anwendungsport als 8090 an.

package com.hehe.yyweb.config;

@Configuration
public class GlobalCorsConfig {

    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/**");
            }
        };
    }
}

Starten Sie abschließend die beiden Anwendungen und greifen Sie dann auf Folgendes zu: http://localhost:8080/index.html im Browser. JSON-Daten können normal empfangen werden, was darauf hinweist, dass der domänenübergreifende Zugriff erfolgreich ist ! !

Das obige ist der detaillierte Inhalt vonWie löst Springboot domänenübergreifende Probleme?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!