Jouer Cadre 2.3 - SCRO-Têtes

Résolu ce problème en:

Toutes les API réponses du serveur doit contenir un en-tête: “Access-Control-Allow-Origin”, “*”. Nous avons besoin d'écrire un wrapper pour toutes les réponses du plan d'action.

Dans Global.java

import java.net.URL;

import play.*;
import play.libs.F.Promise;
import play.mvc.Action;
import play.mvc.Http;
import play.mvc.Result;

public class Global extends GlobalSettings {

  //For CORS
  private class ActionWrapper extends Action.Simple {
    public ActionWrapper(Action<?> action) {
      this.delegate = action;
    }

    @Override
    public Promise<Result> call(Http.Context ctx) throws java.lang.Throwable {
      Promise<Result> result = this.delegate.call(ctx);
      Http.Response response = ctx.response();
      response.setHeader("Access-Control-Allow-Origin", "*");
      return result;
    }
  }

  @Override
  public Action<?> onRequest(Http.Request request,
      java.lang.reflect.Method actionMethod) {
    return new ActionWrapper(super.onRequest(request, actionMethod));
  }

}

Serveur de requêtes comme POST, PUT faire un contrôle en amont demande au serveur avant de la requête principale. La réponse de contrôle en amont pour ces demandes doivent contenir ci-dessous des en-têtes:

“Access-Control-Allow-Origin”, “”
“Permettre”, “”
“Access-Control-Allow-Méthodes”, “POST, GET, PUT, DELETE, les OPTIONS”
“Access-Control-Allow-Les En-Têtes”, “Origine", " X-Requested-With, Content-Type, D'Accepter, De Referer, User-Agent”

Dans les itinéraires ajouter:

OPTIONS /*all                           controllers.Application.preflight(all)

En Application Coltroller:

package controllers;

import play.mvc.*;

public class Application extends Controller {

    public static Result preflight(String all) {
        response().setHeader("Access-Control-Allow-Origin", "*");
        response().setHeader("Allow", "*");
        response().setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE, OPTIONS");
        response().setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Referer, User-Agent");
        return ok();
    }

}

PS: Par cette approche, je n'ai pas eu à créer un scala filtre pour ce.

De la croix-poste de enable-scro-en-java-jeu-cadre-2-2-x.

Les solutions proposées par @alexhanschke ne fonctionne pas lorsque la demande déclenche une exception (erreur interne du serveur), comme les filtres ne sont pas appliquées lorsque cela se produit (voir https://github.com/playframework/playframework/issues/2429). Pour résoudre ce que vous avez à envelopper un scala de classe et de retour que comme un résultat, comme illustré ci-dessous dans son intégralité. Veuillez noter que cela nécessite encore les options de l'itinéraire spécifié et un contrôleur pour gérer la demande options.

Voir en entier ici https://gist.github.com/tinusn/38c4c110f7cd1e1ec63f.

import static play.core.j.JavaResults.BadRequest;
import static play.core.j.JavaResults.InternalServerError;
import static play.core.j.JavaResults.NotFound;
import java.util.ArrayList;
import java.util.List;
import play.GlobalSettings;
import play.api.mvc.Results.Status;
import play.libs.F.Promise;
import play.libs.Scala;
import play.mvc.Action;
import play.mvc.Http;
import play.mvc.Result;
import scala.Tuple2;
import scala.collection.Seq;
public class Global extends GlobalSettings {
private class ActionWrapper extends Action.Simple {
public ActionWrapper(Action<?> action) {
this.delegate = action;
}
@Override
public Promise<Result> call(Http.Context ctx) throws java.lang.Throwable {
Promise<Result> result = this.delegate.call(ctx);
Http.Response response = ctx.response();
response.setHeader("Access-Control-Allow-Origin", "*");
return result;
}
}
/*
* Adds the required CORS header "Access-Control-Allow-Origin" to successfull requests
*/
@Override
public Action<?> onRequest(Http.Request request, java.lang.reflect.Method actionMethod) {
return new ActionWrapper(super.onRequest(request, actionMethod));
}
private static class CORSResult implements Result {
final private play.api.mvc.Result wrappedResult;
public CORSResult(Status status) {
List<Tuple2<String, String>> list = new ArrayList<Tuple2<String, String>>();
Tuple2<String, String> t = new Tuple2<String, String>("Access-Control-Allow-Origin","*");
list.add(t);
Seq<Tuple2<String, String>> seq = Scala.toSeq(list);
wrappedResult = status.withHeaders(seq);
}
public play.api.mvc.Result toScala() {
return this.wrappedResult;
}
}
/*
* Adds the required CORS header "Access-Control-Allow-Origin" to bad requests
*/
@Override
public Promise<Result> onBadRequest(Http.RequestHeader request, String error) {
return Promise.<Result>pure(new CORSResult(BadRequest()));
}
/*
* Adds the required CORS header "Access-Control-Allow-Origin" to requests that causes an exception
*/
@Override
public Promise<Result> onError(Http.RequestHeader request, Throwable t) {
return Promise.<Result>pure(new CORSResult(InternalServerError()));
}
/*
* Adds the required CORS header "Access-Control-Allow-Origin" when a route was not found
*/
@Override
public Promise<Result> onHandlerNotFound(Http.RequestHeader request) {
return Promise.<Result>pure(new CORSResult(NotFound()));
}
}

pour moi de configuration de travail dans chrome, firefox et explorer :

Jouer Cadre de la SCRO-Têtes