web-dev-qa-db-ger.com

Spring CORS Es ist kein Header 'Access-Control-Allow-Origin' vorhanden

Nach der Portierung von web.xml in Java-Konfig kommt es zu folgendem Problem:

No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://localhost:63342' is therefore not allowed access.

Basierend auf einigen Springreferenzen wurde der folgende Versuch versucht:

@Configuration
@ComponentScan(basePackageClasses = AppConfig.class, useDefaultFilters = false, includeFilters = {
        @Filter(org.springframework.stereotype.Controller.class) })
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/*").allowedOrigins("*").allowedMethods("GET", "POST", "OPTIONS", "PUT")
                .allowedHeaders("Content-Type", "X-Requested-With", "accept", "Origin", "Access-Control-Request-Method",
                        "Access-Control-Request-Headers")
                .exposedHeaders("Access-Control-Allow-Origin", "Access-Control-Allow-Credentials")
                .allowCredentials(true).maxAge(3600);
    }

}

Die ausgewählten Werte wurden einem funktionierenden web.xml-Filter entnommen:

<filter>    
<filter-name>CorsFilter</filter-name>
<filter-class>org.Apache.catalina.filters.CorsFilter</filter-class>
<init-param>
    <param-name>cors.allowed.origins</param-name>
    <param-value>*</param-value>
</init-param>
<init-param>
    <param-name>cors.allowed.methods</param-name>
    <param-value>GET,POST,HEAD,OPTIONS,PUT</param-value>
</init-param>
<init-param>
    <param-name>cors.allowed.headers</param-name>
    <param-value>Content-Type,X-Requested-With,accept,Origin,Access-Control-Request-Method,Access-Control-Request-Headers</param-value>
</init-param>
<init-param>
    <param-name>cors.exposed.headers</param-name>
    <param-value>Access-Control-Allow-Origin,Access-Control-Allow-Credentials</param-value>
</init-param>
<init-param>
    <param-name>cors.support.credentials</param-name>
    <param-value>true</param-value>
</init-param>
<init-param>
    <param-name>cors.preflight.maxage</param-name>
    <param-value>10</param-value>
</init-param> </filter> <filter-mapping>

<filter-name>CorsFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

Irgendwelche Ideen, warum der Spring Java-Konfigurationsansatz nicht wie die Datei web.xml funktioniert?

52
Ian Mc

Ändern Sie das CorsMapping in der addCorsMappings-Methode von registry.addMapping("/*") in registry.addMapping("/**").

Schauen Sie sich diesen Spring CORS Documentation an.

Aus der Dokumentation

Das Aktivieren von CORS für die gesamte Anwendung ist so einfach wie folgt:

@Configuration
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**");
    }
}

Sie können alle Eigenschaften leicht ändern und diese CORS-Konfiguration nur auf ein bestimmtes Pfadmuster anwenden:

@Configuration
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
            .allowedOrigins("http://domain2.com")
            .allowedMethods("PUT", "DELETE")
            .allowedHeaders("header1", "header2", "header3")
            .exposedHeaders("header1", "header2")
            .allowCredentials(false).maxAge(3600);
    }
}

Controller-Methode CORS-Konfiguration

@RestController
@RequestMapping("/account")
public class AccountController {
  @CrossOrigin
  @RequestMapping("/{id}")
  public Account retrieve(@PathVariable Long id) {
    // ...
  }
}

So aktivieren Sie CORS für den gesamten Controller:

@CrossOrigin(origins = "http://domain2.com", maxAge = 3600)
@RestController
@RequestMapping("/account")
public class AccountController {

    @RequestMapping("/{id}")
    public Account retrieve(@PathVariable Long id) {
        // ...
    }

    @RequestMapping(method = RequestMethod.DELETE, path = "/{id}")
    public void remove(@PathVariable Long id) {
        // ...
    }
}

Sie können sogar CORS-Konfigurationen auf Controller- und Methodenebene verwenden. Spring kombiniert dann Attribute aus beiden Anmerkungen, um die zusammengeführte CORS-Konfiguration zu erstellen.

@CrossOrigin(maxAge = 3600)
@RestController
@RequestMapping("/account")
public class AccountController {

    @CrossOrigin("http://domain2.com")
    @RequestMapping("/{id}")
    public Account retrieve(@PathVariable Long id) {
        // ...
    }

    @RequestMapping(method = RequestMethod.DELETE, path = "/{id}")
    public void remove(@PathVariable Long id) {
        // ...
    }
}
77

Wir hatten das gleiche Problem und haben es mit der XML-Konfiguration von Spring wie folgt gelöst: 

Fügen Sie dies in Ihre XML-Kontextdatei ein

<mvc:cors>
    <mvc:mapping path="/**"
        allowed-origins="*"
        allowed-headers="Content-Type, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Authorization, X-Requested-With, requestId, Correlation-Id"
        allowed-methods="GET, PUT, POST, DELETE"/>
</mvc:cors>
7
Sabarish

Nützlicher Tipp - Wenn Sie Spring Data Rest verwenden, benötigen Sie einen anderen Ansatz.

@Component
public class SpringDataRestCustomization extends RepositoryRestConfigurerAdapter {

 @Override
 public void configureRepositoryRestConfiguration(RepositoryRestConfiguration config) {
    config.getCorsRegistry().addMapping("/**")
            .allowedOrigins("http://localhost:9000");
  }
}
6
ms.one

Wenn Sie Spring Security ver> = 4.2 verwenden, können Sie die native Unterstützung von Spring Security verwenden, anstatt Apache hinzuzufügen:

@Configuration
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**");
    }
}

Das obige Beispiel wurde aus einem Spring blog post kopiert, in dem Sie auch Informationen zur Konfiguration von CORS auf einem Controller, zu bestimmten Controller-Methoden usw. finden. Darüber hinaus gibt es auch XML-Konfigurationsbeispiele sowie Spring Boot-Integration .

4
matsev

Nach Omars Antwort habe ich in meinem REST API-Projekt eine neue Klassendatei namens WebConfig.Java mit dieser Konfiguration erstellt:

@Configuration
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {

  @Override
  public void addCorsMappings(CorsRegistry registry) {
    registry.addMapping("/**").allowedOrigins("*");
  }
} 

Dadurch kann jeder Origin auf die API zugreifen und diese auf alle Controller im Spring-Projekt anwenden.

3
Shane

Omkars Antwort ist sehr umfassend.

Ein Teil des globalen Konfigurationsabschnitts hat sich jedoch geändert.

Entsprechend dem Spring Boot 2.0.2.RELEASE-Verweis

Ab Version 4.2 unterstützt Spring MVC CORS. Verwendung der Controller-Methode CORS-Konfiguration mit @ CrossOrigin-Anmerkungen in Ihrem Spring Boot Anwendung erfordert keine spezifische Konfiguration. Global CORS Die Konfiguration kann durch Registrieren eines WebMvcConfigurer-Beans .__ definiert werden. mit einer angepassten addCorsMappings-Methode (CorsRegistry), wie in .__ gezeigt. das folgende Beispiel:

@Configuration
public class MyConfiguration {

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

Die meisten Antworten in diesem Beitrag verwenden jedoch WebMvcConfigurerAdapter

Der Typ WebMvcConfigurerAdapter ist veraltet

Seit Spring 5 müssen Sie nur noch die Schnittstelle implementieren WebMvcConfigurer:

public class MvcConfig implements WebMvcConfigurer {

Dies liegt daran, dass Java 8 Standardmethoden für Schnittstellen eingeführt hat, die decken die Funktionalität der WebMvcConfigurerAdapter-Klasse ab

2
Shihe Zhang

Wenn jemand CORS noch immer nicht umgehen kann, schreiben Sie aus irgendeinem Grund den Header, über den der Browser auf Ihre Anfrage zugreifen möchte.

Fügen Sie diese Bean in Ihre Konfigurationsdatei ein.

@Bean
public WebSecurityConfigurerAdapter webSecurity() {
    return new WebSecurityConfigurerAdapter() {

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http.headers().addHeaderWriter(
                    new StaticHeadersWriter("Access-Control-Allow-Origin", "*"));


        }
    };
}

Auf diese Weise können wir dem Browser mitteilen, dass wir Cross-Origin von allen Origin zulassen. Wenn Sie einen bestimmten Pfad einschränken möchten, ändern Sie "*" in {' http: // localhost: 30 ', ""}.

Nützliche Hinweise zum Verständnis dieses Verhaltens https://www.concretepage.com/spring-4/spring-4-rest-cors-integration- using-crossorigin-annotation-xml-filter-example

0
Anshul Kabra

Ich hatte auch Nachrichten wie No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://localhost:63342' is therefore not allowed access.

Ich hatte Cors richtig konfiguriert, aber was in webflux in RouterFuncion fehlte, waren die Kopfzeilen Accept und contenttype APPLICATION_JSON wie in diesem Code:

@Bean
RouterFunction<ServerResponse> routes() {
    return route(POST("/create")
                              .and(accept(APPLICATION_JSON))
                              .and(contentType(APPLICATION_JSON)), serverRequest -> create(serverRequest);
}
0
Rumid

wie @Geoffrey betonte, benötigen Sie für die Federsicherheit einen anderen Ansatz als hier beschrieben: Spring Boot Security CORS

0
womd