CORS Aktivieren in Java Play-Framework-2.2.x

Question

ich Probleme Cross-Domain habe in Java Wiedergabe 2.2.x ermöglichen

In Java Spielen 2.1.3 Dieser Code funktioniert, indem es in Global.java

public class Global extends GlobalSettings { 

    private class ActionWrapper extends Action.Simple { 
    public ActionWrapper(Action action) { 
    this.delegate = action; 
    } 

    @Override 
    public Result call(Http.Context ctx) throws java.lang.Throwable { 
     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)); 
    } 

} 

Aber als ich versuchte, auf Java 2.2.x zu kompilieren, kompiliert es nicht mehr.

Die Kompilation Fehlermeldung:

Global.ActionWrapper nicht abstrakt ist und überschreibt nicht abstrakten Methodenaufruf (Context) in Aktion ...

Gibt es eine entsprechende Code für Java-Spiel 2.2.x?

Danke.

Answer 1

Es sieht wie folgt aus:

import play.GlobalSettings; 
import play.libs.F.Promise; 
import play.mvc.Action; 
import play.mvc.Http; 
import play.mvc.SimpleResult; 

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

     @Override 
     public Promise<SimpleResult> call(Http.Context ctx) throws java.lang.Throwable { 
      Promise<SimpleResult> 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)); 
    } 
} 

Answer 2

Für jedermann mit 2.3.1+ (zum Zeitpunkt des Schreibens) des Spiels, es ist jetzt Promise<Result> statt Promise<SimpleResult>

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

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; 
     } 
    } 

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

Answer 3

Eine weitere Option könnte mit werden Filters. Derzeit sind nur Scala-Filter verfügbar. Wie jedoch in this post zum einfachen Ändern der Antwortheader aufgezeigt, können Sie & kopieren, um CORS zu aktivieren.

package filters 

import play.api.mvc._ 
import play.mvc.Http.HeaderNames 
import scala.concurrent.Future 
import scala.concurrent.ExecutionContext.Implicits.global 

class EnableCORS extends Filter { 
    def apply(f: (RequestHeader) => Future[Result])(rh: RequestHeader): Future[Result] = { 
    val result = f(rh) 
    result.map(_.withHeaders(HeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN -> "*")) 
    } 
} 

Und dann den Filter in Ihrem Global.java fügen Sie einfach so:

@Override 
public <T extends EssentialFilter> Class<T>[] filters() { 
    return new Class[] {EnableCORS.class}; 
} 

Answer 4

Die Lösungen von @alexhanschke vorgeschlagen funktioniert nicht, wenn die Anforderung eine Ausnahme (interner Serverfehler) führt, weil Filter nicht sind wenn dies geschieht (siehe https://github.com/playframework/playframework/issues/2429). Um das zu lösen, müssen Sie eine Scala-Klasse umbrechen und als Ergebnis zurückgeben, wie unten vollständig gezeigt. Bitte beachten Sie, dass dies immer noch die angegebene Optionenroute und einen Controller erfordert, um die Optionsanfrage zu bearbeiten.

Sehen Sie die ganze Sache hier 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())); 
    } 

}