Ich versuche, Spring für CORS zu konfigurieren, um die Angular-Web-Benutzeroberfläche zu verwenden:

Ich habe es versucht:

@Configuration
@ComponentScan("org.datalis.admin.config")
public class AppConfig {

    @Bean
    public static PropertySourcesPlaceholderConfigurer propertyConfigurer() {
        PropertySourcesPlaceholderConfigurer conf = new PropertySourcesPlaceholderConfigurer();
        conf.setLocation(new ClassPathResource("application.properties"));
        return conf;
    }

    @Bean
    public FilterRegistrationBean<CorsFilter> corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("127.0.0.1");
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        source.registerCorsConfiguration("/**", config);
        FilterRegistrationBean<CorsFilter> bean = new FilterRegistrationBean<CorsFilter>(new CorsFilter(source));
        bean.setOrder(0);
        return bean;
    }
}

Der Apache-Server mit Angular FE wird mit dem Wildly-Server auf demselben Server ausgeführt, daher habe ich 127.0.0.1 für die Quelle konfiguriert.

Aber trotzdem bekomme ich:

Access to XMLHttpRequest at 'http://123.123.123.123:8080/api/oauth/token' from origin 'http://123.123.123.123' has been blocked by CORS policy: Response to preflight request doesn't pass access control check: It does not have HTTP ok status.
auth:1 Failed to load resource: the server responded with a status of 404 (Not Found)

Wissen Sie, wie ich dieses Problem beheben kann?

Zweiter Weg, den ich versucht habe:

@Configuration
@EnableResourceServer
public class ResourceSecurityConfig extends ResourceServerConfigurerAdapter {

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) {
        resources.resourceId("resource_id").stateless(true);
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/users/**").permitAll()
                .anyRequest().authenticated()
                .and()
        .cors().disable()
        .authorizeRequests()
        .antMatchers(HttpMethod.OPTIONS, "/**").permitAll()
        .anyRequest()
        .fullyAuthenticated()
        .and()
        .httpBasic()
        .and()
        .csrf().disable();
    }

    @Bean
    public CorsConfigurationSource corsConfigurationSources() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedOrigins(Arrays.asList("*"));
        configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"));
        configuration.setAllowedHeaders(Arrays.asList("authorization", "content-type", "x-auth-token"));
        configuration.setExposedHeaders(Arrays.asList("x-auth-token"));
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}

Bei der zweiten Konfiguration wurde durch die CORS-Richtlinie blockiert: Die Antwort auf die Preflight-Anforderung besteht die Zugriffskontrollprüfung nicht: Sie hat keinen HTTP-OK-Status. auth: 1 Fehler beim Laden der Ressource: Der Server hat mit dem Status 404 (Nicht gefunden) geantwortet

Was ist der beste Weg, um dieses Ergebnis zu erzielen?

9
Peter Penzov 18 Jän. 2019 im 17:25

6 Antworten

Beste Antwort

Sie müssen Spring Security anweisen, die von Ihnen erstellte CORS-Konfiguration zu verwenden.

In meinem Projekt habe ich Spring Security folgendermaßen konfiguriert:

@Override
protected void configure(HttpSecurity http) throws Exception
{
    http
        .authorizeRequests()
        .antMatchers("/rest/protected/**")
        .authenticated()
     //Other spring sec configruation and then:
    .and()
        .cors()
        .configurationSource(corsConfigurationSource())

}

Wo corsConfigurationSource() ist:

@Bean
    CorsConfigurationSource corsConfigurationSource() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();

        boolean abilitaCors = new Boolean(env.getProperty("templating.oauth.enable.cors"));
        if( abilitaCors )
        {
            if( logger.isWarnEnabled() )
            {
                logger.warn("CORS ABILITATI! Si assume ambiente di sviluppo");
            }
            CorsConfiguration configuration = new CorsConfiguration();
            configuration.setAllowedOrigins(Arrays.asList("http://localhost:4200","http://localhost:8080", "http://localhost:8180"));
            configuration.setAllowedMethods(Arrays.asList(  RequestMethod.GET.name(),
                    RequestMethod.POST.name(), 
                    RequestMethod.OPTIONS.name(), 
                    RequestMethod.DELETE.name(),
                    RequestMethod.PUT.name()));
            configuration.setExposedHeaders(Arrays.asList("x-auth-token", "x-requested-with", "x-xsrf-token"));
            configuration.setAllowedHeaders(Arrays.asList("X-Auth-Token","x-auth-token", "x-requested-with", "x-xsrf-token"));
            source.registerCorsConfiguration("/**", configuration);
        }
        return source;
    }

Ich hoffe es ist nützlich

Angelo

4
Angelo Immediata 21 Jän. 2019 im 07:54

Ihr zulässiger Ursprung ist 127.0.0.1, aber Ihre Client-Seite hat die IP 123.123.123.123. Versuchen Sie dies zu ändern:

config.addAllowedOrigin("127.0.0.1");

Dazu:

config.addAllowedOrigin("123.123.123.123");
6
Roddy of the Frozen Peas 18 Jän. 2019 im 16:34

Dies ist meine @Configuration Arbeitsklasse, um CORS-Anforderungen zu verarbeiten, die nur in der Entwicklungsumgebung verwendet werden.

@Configuration
//@Profile(PROFILE_DEV)
  public class CorsConfiguration {

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

Sie müssen Spring Security auch so konfigurieren, dass HttpMethod.OPTIONS, das von Preflight-Anforderungen verwendet wird, ignoriert wird (als die von Ihnen erwähnte Ausnahme).

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
  //...
    @Override
    public void configure(WebSecurity web) throws Exception {
      web.ignoring()
            //others if you need
            .antMatchers(HttpMethod.OPTIONS, "/**");

    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
            .csrf()
            .disable()
            .exceptionHandling()
            .and()
            .headers()
            .frameOptions()
            .disable()
            .and()
            .authorizeRequests()
            .antMatchers("/api/register").permitAll()
            .antMatchers("/api/activate").permitAll()
            .antMatchers("/api/authenticate").permitAll()
            .antMatchers("/api/**").authenticated();
    }

}

Denn wenn Sie cors verwenden, haben Sie Simple Request und Preflighted Request, die eine HttpMethod.OPTIONS auslöst

3
ValerioMC 21 Jän. 2019 im 21:46

Ich empfehle Ihnen, einen WebMvcConfigurer zu verwenden und in der Methode addCorsMappings die CORS-Konfiguration festzulegen.

Etwas wie das

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
            .allowedOrigins("http://localhost:9798")
            .allowedMethods("POST", "GET")
            //.allowedHeaders("header1", "header2", "header3")
            //.exposedHeaders("header1", "header2")
            .allowCredentials(true).maxAge(3600);
    }
}

Hier gibt es einen Link zu einem voll funktionsfähigen Spring with CORS-Projekt. Laden Sie es einfach herunter und führen Sie es aus.

https://github.com/reos79/spring-cors

Es hat eine HTML-Seite (person.html). Diese Seite ruft lediglich den Dienst am Port (9797) auf. Sie müssen dieses Projekt also zweimal laden, einmal auf Port 9797, um den Dienst zu laden, und das andere Mal auf Port (9798). Dann rufen Sie in Ihrem Browser die Seitenperson auf dem Server localhost: 9798 auf und der Dienst auf localhost: 9797 in der Datei application.properties, in der ich den Port konfiguriert habe.

2
reos 21 Jän. 2019 im 17:23

Sie müssen Ihrer Controller-Klasse wie unten @CrossOrigin Klassenebene hinzufügen

@CrossOrigin
public class SampleController {
    // Your code goes here
}

Anmerkung zu Ihrer Rest-Controller-Klasse

2
Sasikumar Murugesan 24 Jän. 2019 im 15:41

Versuchen Sie, Ihren Bean-Namen in corsConfigurationSource zu ändern, und entfernen Sie das "s".

Dokumentation https://docs.spring.io/ spring-security / site / docs / current / reference / htmlsingle / # cors

// verwendet standardmäßig eine Bean mit dem Namen corsConfigurationSource

0
Code Junkie 1 Juli 2019 im 15:46