• Startseite
  • Artikel
  • Allgemein
  • Was ist Cross-Origin Resource Sharing (CORS) – wie füge ich es zu meinem Java-Jersey-Webserver hinzu?

Was ist Cross-Origin Resource Sharing (CORS) – wie füge ich es zu meinem Java-Jersey-Webserver hinzu?

Veröffentlicht: 2014-07-19

Cross-Origin Resource Sharing (CORS) Tutorial von Crunchify

Wie kann dieser Fehler während client-server Kommunikation behoben werden? Der Server sendet Daten im JSON- oder XML-Format und der Client löst die folgende Ausnahme aus.

1
2
3
XMLHttpRequest cannot load https : //crunchify.com/api/test.
No 'Access-Control-Allow-Origin' header is present on the requested resource .
Origin 'null' is therefore not allowed access .

Normale Webseiten können das XMLHttpRequest-Objekt verwenden, um Daten von Remoteservern zu senden und von diesen zu empfangen, aber sie sind durch dieselbe Ursprungsrichtlinie eingeschränkt. Erweiterungen sind nicht so begrenzt. Eine Erweiterung kann mit Remote-Servern außerhalb ihres Ursprungs kommunizieren, solange sie zuerst Cross-Origin-Berechtigungen anfordert.

Auch wenn Sie die folgenden Fragen haben, sind Sie hier richtig:

  1. Grundlegendes zur ursprungsübergreifenden Ressourcenfreigabe (CORS-Filter)
  2. Kann ich Cross-Origin Resource Sharing verwenden?
  3. So aktivieren Sie die ursprungsübergreifende Ressourcenfreigabe
  4. Was ist domänenübergreifendes Ajax mit ursprungsübergreifender Ressourcenfreigabe?
  5. Was ist HTTP-Zugriffskontrolle (CORS)

CORS (Cross Origin Resource Sharing) ist ein vom W3C unterstützter Mechanismus, um ursprungsübergreifende Anfragen in Webbrowsern zu ermöglichen. CORS benötigt Unterstützung sowohl vom Browser als auch vom Server, um zu funktionieren. Dies ist eine Java-Jersey-Webserver-Filterimplementierung von serverseitigem CORS für Webcontainer wie Apache Tomcat und andere eingebettete Webserver.

Crunchify CORSFilter Jersey Server Beispiel

Schritt 1:

Eine Antwort kann einen Access-Control-Allow-Origin-Header mit dem Ursprung der Anfrage als Wert enthalten, um den Zugriff auf den Inhalt der Ressource zu ermöglichen. Der Benutzeragent überprüft, ob der Wert und der Ursprung des Ursprungs der Anfrage übereinstimmen.

Schritt 2:

Benutzeragenten können über eine Preflight-Anfrage feststellen, ob eine Cross-Origin-Ressource bereit ist, Anfragen mit einer nicht einfachen Methode von einem bestimmten Ursprung zu akzeptieren. Dies wird erneut durch den Benutzeragenten validiert.

Schritt 3:

Serverseitige Anwendungen können über den Origin-Header erkennen, dass eine HTTP-Anforderung vom Benutzeragenten als Cross-Origin-Anforderung eingestuft wurde. Diese Erweiterung ermöglicht es serverseitigen Anwendungen, Beschränkungen (z. B. nichts zurückzugeben) für die Cross-Origin-Anfragen durchzusetzen, die sie bereit sind zu bedienen.

Beginnen wir nun mit Beispielen.

Beispiel-1: Java-Jersey-Webserver

Vor einigen Wochen habe ich einen Artikel über das Starten eines eingebetteten HTTP-Jersey-Servers während des Java-Anwendungsstarts geschrieben. Dieser Beitrag behandelt Schritte zum Hinzufügen von CORS-Filtern zu demselben Jersey-Server.

Wir müssen ContainerResponseFilter erweitern. Von Container-Antwortfiltern implementierte Schnittstelle. Standardmäßig, dh wenn keine Namensbindung auf die Filterimplementierungsklasse angewendet wird, wird die Filterinstanz global auf jede ausgehende Antwort angewendet.

Um dies zu beheben, versuchen wir, der Serverantwort die folgenden 4 Header hinzuzufügen:

  1. Access-Control-Allow-Origin
  2. Access-Control-Allow-Methoden
  3. Zugriffskontrolle-Max-Alter
  4. Access-Control-Allow-Header

CORS-Filtercode:

CrunchifyCORSFilter.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package com . crunchify . tutorial ;
 
/**
*
* @author Crunchify.com
*/
 
import com . sun . jersey . spi . container . ContainerRequest ;
import com . sun . jersey . spi . container . ContainerResponse ;
import com . sun . jersey . spi . container . ContainerResponseFilter ;
import javax . ws . rs . core . Response ;
import javax . ws . rs . core . Response . ResponseBuilder ;
 
public class CrunchifyCORSFilter implements ContainerResponseFilter {
 
     public ContainerResponse filter ( ContainerRequest req , ContainerResponse crunchifyContainerResponse ) {
 
         ResponseBuilder crunchifyResponseBuilder = Response . fromResponse ( crunchifyContainerResponse . getResponse ( ) ) ;
        
         // *(allow from all servers) OR https://crunchify.com/ OR http://example.com/
         crunchifyResponseBuilder . header ( "Access-Control-Allow-Origin" , "https://crunchify.com/" )
        
         // As a part of the response to a request, which HTTP methods can be used during the actual request.
         . header ( "Access-Control-Allow-Methods" , "API, CRUNCHIFYGET, GET, POST, PUT, UPDATE, OPTIONS" )
        
         // How long the results of a request can be cached in a result cache.
         . header ( "Access-Control-Max-Age" , "151200" )
        
         // As part of the response to a request, which HTTP headers can be used during the actual request.
         . header ( "Access-Control-Allow-Headers" , "x-requested-with,Content-Type" ) ;
 
         String crunchifyRequestHeader = req . getHeaderValue ( "Access-Control-Request-Headers" ) ;
 
         if ( null ! = crunchifyRequestHeader && !crunchifyRequestHeader.equals(null)) {
            crunchifyResponseBuilder.header("Access-Control-Allow-Headers", crunchifyRequestHeader);
         }
 
         crunchifyContainerResponse . setResponse ( crunchifyResponseBuilder . build ( ) ) ;
         return crunchifyContainerResponse ;
     }
}

Änderung in JerseyEmbeddedHTTPServerCrunchify.java aus dem vorherigen Tutorial.

Fügen Sie einfach die folgende Zeile in createHttpServer() hinzu und starten Sie den Server neu.

1
crunchifyResourceConfig . getContainerResponseFilters ( ) . add ( CrunchifyCORSFilter . class ) ;

Ergebnis:

http://localhost:8085/api

Crunchify Response Header mit CORS-Filter

Hier sind die Header-Details.

Crunchify Response Header ohne CORS-Filter

Beispiel-2: Apache HTTP-Server

Um den Header verfügbar zu machen, können Sie die folgende Zeile in die Abschnitte <Directory>, <Location> und <Files> oder in eine .htaccess -Datei einfügen.

.htaccess file
1
2
3
< IfModule mod_headers . c >
   Header set Access - Control - Allow - Origin "*"
< / IfModule >

Beispiel-3: .NET-Server kann dies in web.config wie unten konfigurieren

web.config
1
2
3
4
5
6
< system . webServer >
   < httpProtocol >
     < customHeaders >
       < add name = "Access-Control-Allow-Origin" value = "your_clientside_websiteurl" / >
     < / customHeaders >
< system . webServer >

Beispiel-4: Für Jetty (7 und höher)

Binden Sie die jetty-servlets JAR in Ihre WEB-INF/lib ein und führen Sie diese in Ihre WEB-INF/web.xml ein

web.xml
1
2
3
4
5
6
7
8
   < filter >
       < filter - name > cross - origin < / filter - name >
       < filter - class > org . eclipse . jetty . servlets . CrossOriginFilter < / filter - class >
   < / filter >
   < filter - mapping >
       < filter - name > cross - origin < / filter - name >
       < url - pattern > /* < / url - pattern >
   < / filter - mapping >

Beispiel-5: Apache Tomcat Server (v 7.0.41 +)

web.xml
1
2
3
4
5
6
7
8
< filter >
   < filter - name > CorsFilter < / filter - name >
   < filter - class > org . apache . catalina . filters . CorsFilter < / filter - class >
< / filter >
< filter - mapping >
   < filter - name > CorsFilter < / filter - name >
   < url - pattern > /* < / url - pattern >
< / filter - mapping >

Beispiel-6: In PHP

1
2
3
<?php
header ( "Access-Control-Allow-Origin: *" ) ;
?>

Bitte lassen Sie es mich wissen, wenn Sie weitere Fragen dazu haben. Eine Liste aller Java-Tutorials finden Sie hier.