Comment gérer les catégories de documents à l'aide de JAX-RS avec Jersey

Remarque: assurez-vous de lire la mise à JOUR au bas

@CrossOriginResourceSharing est un CXF d'annotation, de sorte qu'il ne fonctionne pas avec Jersey.

Avec Jersey, pour traiter les CORS, j'ai l'habitude de simplement utiliser un ContainerResponseFilter. Le ContainerResponseFilter pour Maillot 1 et 2 sont un peu différentes. Puisque vous n'avez pas mentionné la version que vous utilisez, je vais poster deux à la fois.

Jersey 2

import java.io.IOException;
import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerResponseContext;
import javax.ws.rs.container.ContainerResponseFilter;

@Provider
public class CORSFilter implements ContainerResponseFilter {

    @Override
    public void filter(ContainerRequestContext request,
            ContainerResponseContext response) throws IOException {
        response.getHeaders().add("Access-Control-Allow-Origin", "*");
        response.getHeaders().add("Access-Control-Allow-Headers",
                "origin, content-type, accept, authorization");
        response.getHeaders().add("Access-Control-Allow-Credentials", "true");
        response.getHeaders().add("Access-Control-Allow-Methods",
                "GET, POST, PUT, DELETE, OPTIONS, HEAD");
    }
}

Si vous utilisez le package de numérisation de découvrir les fournisseurs et les ressources, la @Provider annotation devrait prendre soin de la configuration pour vous. Si pas, alors vous aurez besoin d'inscrire explicitement avec la ResourceConfig ou la Application sous-classe.

Exemple de code à inscrire explicitement filtre avec le ResourceConfig:

final ResourceConfig resourceConfig = new ResourceConfig();
resourceConfig.register(new CORSFilter());
final final URI uri = ...;
final HttpServer httpServer = GrizzlyHttpServerFactory.createHttpServer(uri, resourceConfig);

Pour Le Jersey 2.x, si vous rencontrez des problèmes à l'enregistrement de ce filtre, voici quelques ressources qui pourraient vous aider

• L'enregistrement de Ressources et de Fournisseurs de en Maillot 2
• Quel est exactement le ResourceConfig classe en Jersey 2?

Maillot 1

import com.sun.jersey.spi.container.ContainerRequest;
import com.sun.jersey.spi.container.ContainerResponse;
import com.sun.jersey.spi.container.ContainerResponseFilter;

public class CORSFilter implements ContainerResponseFilter {
    @Override
    public ContainerResponse filter(ContainerRequest request,
            ContainerResponse response) {

        response.getHttpHeaders().add("Access-Control-Allow-Origin", "*");
        response.getHttpHeaders().add("Access-Control-Allow-Headers",
                "origin, content-type, accept, authorization");
        response.getHttpHeaders().add("Access-Control-Allow-Credentials", "true");
        response.getHttpHeaders().add("Access-Control-Allow-Methods",
                "GET, POST, PUT, DELETE, OPTIONS, HEAD");

        return response;
    }
}

web.xml de configuration, vous pouvez utiliser

<init-param>
  <param-name>com.sun.jersey.spi.container.ContainerResponseFilters</param-name>
  <param-value>com.yourpackage.CORSFilter</param-value>
</init-param>

Ou ResourceConfig vous pouvez faire

resourceConfig.getContainerResponseFilters().add(new CORSFilter());

Ou le paquet de la numérisation avec le @Provider annotation.

---

MODIFIER

Veuillez noter que l'exemple ci-dessus peut être amélioré. Vous aurez besoin d'en savoir plus sur la façon de la SCRO œuvres. Veuillez voir ici. Pour un, vous obtiendrez les en-têtes pour toutes les réponses. Cela peut ne pas être souhaitable. Vous aurez juste besoin de gérer le contrôle en amont (ou des OPTIONS). Si vous voulez voir une meilleure mise en œuvre de la SCRO filtre, vous pouvez consulter le code source de la RESTeasy CorsFilter

---

Mise à JOUR

J'ai donc décidé d'ajouter un plus à leur application correcte. Ci-dessus la mise en œuvre est paresseux et ajoute tous les CORS des en-têtes à toutes les demandes. L'autre erreur, c'est que, que c'est seulement un réponse filtre, la demande est toujours en processus. Cela signifie que lorsque le contrôle en amont requête, qui est une des OPTIONS de demande, il n'y aura pas d'OPTIONS méthode mise en œuvre, donc, nous aurons une 405 de réponse, ce qui est incorrect.

Voici comment il devrait travail. Il y a donc deux types de la SCRO demandes: demandes simples et le contrôle en amont des demandes. Pour une demande simple, le navigateur va envoyer la demande réelle et ajouter le Origin - tête de la demande. Le navigateur attend la réponse pour avoir la Access-Control-Allow-Origin en-tête, en disant que l'origine de la Origin en-tête est autorisé. Pour qu'il soit considéré comme un "simple demande", il doit répondre aux critères suivants:

• Être l'une des méthodes suivantes:
  • OBTENIR
  • TÊTE
  • POST
• Outre les en-têtes de définir automatiquement par le navigateur, la demande ne peut contenir les éléments suivants manuellement définir les en-têtes:
  • Accept
  • Accept-Language
  • Content-Language
  • Content-Type
  • DPR
  • Save-Data
  • Viewport-Width
  • Width
• Les seules valeurs autorisées pour la Content-Type d'en-tête sont:
  • application/x-www-form-urlencoded
  • multipart/form-data
  • text/plain

Si la demande ne remplit pas l'une de ces trois critères, un contrôle en amont de la requête. C'est une demande qui est faite au serveur, avant à la réelle demande. Il contient différentes Access-Control-XX-XX en-têtes, et le serveur doit répondre à ces en-têtes avec son propre CORS en-têtes de réponse. Voici la correspondance des en-têtes:

                 Preflight Request and Response Headers
+-----------------------------------+--------------------------------------+
|  REQUEST HEADER                   |  RESPONSE HEADER                     |
+===================================+======================================+
|  Origin                           |  Access-Control-Allow-Origin         |
+-----------------------------------+--------------------------------------+
|  Access-Control-Request-Headers   |  Access-Control-Allow-Headers        |
+-----------------------------------+--------------------------------------+
|  Access-Control-Request-Method    |  Access-Control-Allow-Methods        |
+-----------------------------------+--------------------------------------+
|  XHR.withCredentials              |  Access-Control-Allow-Credentials    |
+-----------------------------------+--------------------------------------+

• Avec le Origin - tête de la requête, la valeur sera à l'origine de domaine du serveur, et la réponse Access-Control-Allow-Header doivent être à cette même adresse ou * pour spécifier que toutes les origines sont autorisés.

• Si le client tente de définir manuellement les en-têtes de pas dans la liste ci-dessus, alors le navigateur va définir le Access-Control-Request-Headers en-tête, avec la valeur étant une liste de tous les en-têtes que le client tente de définir. Le serveur doit répondre de retour avec un Access-Control-Allow-Headers en-tête de réponse, avec la valeur d'une liste d'en-têtes de elle permet.

• Le navigateur permet également de définir la Access-Control-Request-Method en-tête de requête, avec la valeur de la méthode HTTP de la requête. Le serveur doit répondre avec la Access-Control-Allow-Methods en-tête de réponse, avec la valeur d'une liste des méthodes qu'il permet.

• Si le client utilise le XHR.withCredentials, puis le serveur doit répondre avec la Access-Control-Allow-Credentials en-tête de réponse, avec une valeur de true. Lire la suite ici.

Donc, avec tout cela dit, voici une meilleure mise en œuvre. Même si c'est mieux que la mise en œuvre, il est toujours inférieure à la RESTEasy un je lien, que cette mise en œuvre permet encore de toutes origines. Mais ce filtre permet de mieux adhérer à la SCRO spec de filtre qui ajoute juste de la SCRO en-têtes de réponse à toutes les demandes. Notez que vous pouvez aussi avoir besoin de modifier le Access-Control-Allow-Headers de faire correspondre les en-têtes de votre application; vous pouvez o ajouter ou supprimer des en-têtes de la liste dans cet exemple.

@Provider
@PreMatching
public class CorsFilter implements ContainerRequestFilter, ContainerResponseFilter {
/**
* Method for ContainerRequestFilter.
*/
@Override
public void filter(ContainerRequestContext request) throws IOException {
//If it's a preflight request, we abort the request with
//a 200 status, and the CORS headers are added in the
//response filter method below.
if (isPreflightRequest(request)) {
request.abortWith(Response.ok().build());
return;
}
}
/**
* A preflight request is an OPTIONS request
* with an Origin header.
*/
private static boolean isPreflightRequest(ContainerRequestContext request) {
return request.getHeaderString("Origin") != null
&& request.getMethod().equalsIgnoreCase("OPTIONS");
}
/**
* Method for ContainerResponseFilter.
*/
@Override
public void filter(ContainerRequestContext request, ContainerResponseContext response)
throws IOException {
//if there is no Origin header, then it is not a
//cross origin request. We don't do anything.
if (request.getHeaderString("Origin") == null) {
return;
}
//If it is a preflight request, then we add all
//the CORS headers here.
if (isPreflightRequest(request)) {
response.getHeaders().add("Access-Control-Allow-Credentials", "true");
response.getHeaders().add("Access-Control-Allow-Methods",
"GET, POST, PUT, DELETE, OPTIONS, HEAD");
response.getHeaders().add("Access-Control-Allow-Headers",
//Whatever other non-standard/safe headers (see list above) 
//you want the client to be able to send to the server,
//put it in this list. And remove the ones you don't want.
"X-Requested-With, Authorization, " +
"Accept-Version, Content-MD5, CSRF-Token");
}
//Cross origin requests can be either simple requests
//or preflight request. We need to add this header
//to both type of requests. Only preflight requests
//need the previously added headers.
response.getHeaders().add("Access-Control-Allow-Origin", "*");
}
}

Pour en savoir plus sur la SCRO, je suggère la lecture de la MDN docs sur Cross-Origin Resource sharing (SCRO)

Supprimer l'annotation "@CrossOriginResourceSharing(allowAllOrigins = true)"

Alors de Retour de Réponse, comme ci-dessous:

return Response.ok()
.entity(jsonResponse)
.header("Access-Control-Allow-Origin", "*")
.build();

Mais la jsonResponse devrait remplacer avec un POJO Objet!

peeskillet réponse est bonne. Mais j'ai cette erreur lors de l'actualisation de la page web (c'est en travaillant uniquement sur la première charge):

The 'Access-Control-Allow-Origin' header contains multiple values '*, *', but only one is allowed. Origin 'http://127.0.0.1:8080' is therefore not allowed access.

Donc, au lieu d'utiliser la méthode add pour ajouter des en-têtes de réponse, j'en utilisant la méthode put. C'est ma classe

public class MCORSFilter implements ContainerResponseFilter {
public static final String ACCESS_CONTROL_ALLOW_ORIGIN = "Access-Control-Allow-Origin";
public static final String ACCESS_CONTROL_ALLOW_ORIGIN_VALUE = "*";
private static final String ACCESS_CONTROL_ALLOW_CREDENTIALS = "Access-Control-Allow-Credentials";
private static final String ACCESS_CONTROL_ALLOW_CREDENTIALS_VALUE = "true";
public static final String ACCESS_CONTROL_ALLOW_HEADERS = "Access-Control-Allow-Headers";
public static final String ACCESS_CONTROL_ALLOW_HEADERS_VALUE = "Cache-Control, Pragma, Origin, Authorization, Content-Type, X-Requested-With, Accept";
public static final String ACCESS_CONTROL_ALLOW_METHODS = "Access-Control-Allow-Methods";
public static final String ACCESS_CONTROL_ALLOW_METHODS_VALUE = "GET, POST, PUT, DELETE, OPTIONS, HEAD";
public static final String[] ALL_HEADERs = {
ACCESS_CONTROL_ALLOW_ORIGIN,
ACCESS_CONTROL_ALLOW_CREDENTIALS,
ACCESS_CONTROL_ALLOW_HEADERS,
ACCESS_CONTROL_ALLOW_METHODS
};
public static final String[] ALL_HEADER_VALUEs = {
ACCESS_CONTROL_ALLOW_ORIGIN_VALUE,
ACCESS_CONTROL_ALLOW_CREDENTIALS_VALUE,
ACCESS_CONTROL_ALLOW_HEADERS_VALUE,
ACCESS_CONTROL_ALLOW_METHODS_VALUE
};
@Override
public ContainerResponse filter(ContainerRequest request, ContainerResponse response) {
for (int i = 0; i < ALL_HEADERs.length; i++) {
ArrayList<Object> value = new ArrayList<>();
value.add(ALL_HEADER_VALUEs[i]);
response.getHttpHeaders().put(ALL_HEADERs[i], value); //using put method
}
return response;
}
}

Et ajouter cette classe init-param dans web.xml

<init-param>
<param-name>com.sun.jersey.spi.container.ContainerResponseFilters</param-name>
<param-value>com.yourpackage.MCORSFilter</param-value>
</init-param>