L'en-tête de la réponse ne doit pas être le caractère générique '*' lors de la demande d'informations d'identification du mode "inclure"

Problème:

Vous n'êtes pas de la configuration de 'Access-Control-Allow-Origin' correctement et de votre configuration actuelle est tout simplement ignoré par le serveur.

Situation:

La trace de la pile d'Erreur dit:

La valeur de la 'Access-Control-Allow-Origin' en-tête de la réponse ne doit pas être le générique '*' lors de la demande d'informations d'identification du mode "inclure". Origine " http://localhost:4200 ' est donc pas autorisé à accéder.

Cela signifie que, hormis le fait que vous ne pouvez pas définir de 'Access-Control-Allow-Origin' pour le générique "*", votre nom de domaine 'http://localhost:4200' n'est pas autorisé à accéder trop.

Pour répondre à votre question:

Comment puis-je résoudre ce problème quand j'ai déjà le permis origine dans le WebSocketConfig pour le client de domaine?

Solution:

Je suppose que vous n'avez pas besoin de définir le permis origine dans le WebSocketConfig parce qu'il est destiné à configurer WebSocket style de messagerie dans les applications web comme indiqué dans WebSocket Support au Printemps de la documentation, vous devez le configurer dans un CORSFilter classe de configuration qu'il est destiné à configurer le Printemps des Filtres de l'application Web access.

C'est ce que vous aurez besoin dans votre CORSFilter.java classe de configuration:

public class CORSFilter implements Filter {

    //This is to be replaced with a list of domains allowed to access the server
  //You can include more than one origin here
    private final List<String> allowedOrigins = Arrays.asList("http://localhost:4200"); 

    public void destroy() {

    }

    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        //Lets make sure that we are working with HTTP (that is, against HttpServletRequest and HttpServletResponse objects)
        if (req instanceof HttpServletRequest && res instanceof HttpServletResponse) {
            HttpServletRequest request = (HttpServletRequest) req;
            HttpServletResponse response = (HttpServletResponse) res;

            //Access-Control-Allow-Origin
            String origin = request.getHeader("Origin");
            response.setHeader("Access-Control-Allow-Origin", allowedOrigins.contains(origin) ? origin : "");
            response.setHeader("Vary", "Origin");

            //Access-Control-Max-Age
            response.setHeader("Access-Control-Max-Age", "3600");

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

            //Access-Control-Allow-Methods
            response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");

            //Access-Control-Allow-Headers
            response.setHeader("Access-Control-Allow-Headers",
                "Origin, X-Requested-With, Content-Type, Accept, " + "X-CSRF-TOKEN");
        }

        chain.doFilter(req, res);
    }

    public void init(FilterConfig filterConfig) {
    }
}

Vous pouvez voir l'utilisation de :

private final List<String> allowedOrigins = Arrays.asList("http://localhost:4200");

Pour définir la liste des domaines autorisés à accéder au serveur.

Références:

Vous pouvez avoir besoin de prendre un coup d'oeil à soutien de la SCRO dans Spring Framework et Activation de l'Origine de la Croix de Demandes pour un Service Web RESTful pour en savoir plus à ce sujet.

ma réponse est trop tard mais je vais poster ce que si quelqu'un pouvait faire face au même problème, j'ai été confronté au même cross-origin question.

Fondamentalement, si vous utilisez le Printemps de Sécurité mis en place sur votre serveur d'application côté, c'est Probablement lui qui bloque websocket handshaker

Vous avez à dire à Ressort de sécurité pour permettre à votre websocket points de terminaison afin de permettre à douille poignée de main...
à l'aide de

.antMatchers("/socket/**").permitAll()

Donc sockjs sera en mesure maintenant d'envoyer un GET (Http) demande de la poignée de main avant de passer au protocole Websocket

C'est le Printemps, la Configuration de sécurité

package org.souhaib.caremy.security.module.config;
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
            .exceptionHandling().authenticationEntryPoint(restAuthenticationEntryPoint).and()
            .authorizeRequests()
            .antMatchers(SecurityParams.PUBLIC_ROUTES).permitAll()
            .antMatchers("/socket/**").permitAll();

    http.csrf().disable();
}}

C'est WebSocket de configuration du Broker

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/socket")
                .setAllowedOrigins("http://localhost:4200")
                .withSockJS();
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.setApplicationDestinationPrefixes("/app")
                .enableSimpleBroker("/chat");
    }
}