在Java Play Framework 2.2.x中启用CORS

我在Java Play 2.2.x中启用跨域时遇到问题

在Java Play 2.1.3中，此代码通过将其放在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));
  }

}

但当我尝试在java play 2.2.x上编译时，它不再编译了

编译错误消息：

Global.ActionWrapper不是抽象的，并且不重写操作中的抽象方法调用（上下文）

java play 2.2.x是否有任何等效代码

谢谢。

看起来是这样的：

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

导入play.GlobalSettings；
导入play.libs.F.Promise；
导入play.mvc.Action；
导入play.mvc.Http；
导入play.mvc.SimpleResult；
公共类全局扩展全局设置{
私有类ActionWrapper扩展了Action.Simple{
公共动作包装器（动作动作）{
这个代表=行动；
}
@凌驾
公共承诺调用（Http.Context ctx）抛出java.lang.Throwable{
承诺结果=this.delegate.call（ctx）；
Http.Response=ctx.Response（）；
response.setHeader（“访问控制允许原点“，“*”）；
返回结果；
}
}
@凌驾
公共操作onRequest（Http.Request-Request，java.lang.reflect.Method-actionMethod）{
返回新的ActionWrapper（super.onRequest（request，actionMethod））；
}
}

对于任何使用2.3.1+（截至本文撰写时）游戏的人来说，现在是

Promise

而不是

Promise

导入play.GlobalSettings；
导入play.libs.F.Promise；
导入play.mvc.Action；
导入play.mvc.Http；
导入play.mvc.Result；
公共类全局扩展全局设置{
私有类ActionWrapper扩展了Action.Simple{
公共动作包装器（动作动作）{
这个代表=行动；
}
@凌驾
公共承诺调用（Http.Context ctx）抛出java.lang.Throwable{
承诺结果=this.delegate.call（ctx）；
Http.Response=ctx.Response（）；
response.setHeader（“访问控制允许原点“，“*”）；
返回结果；
}
}
@凌驾
公共操作onRequest（Http.Request-Request，java.lang.reflect.Method-actionMethod）{
返回新的ActionWrapper（super.onRequest（request，actionMethod））；
}
}

另一个选项可能正在使用。目前只有Scala过滤器可用。但是，正如中所指出的，为了简单地修改响应头，您可以复制并粘贴以下内容以启用CORS

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 -> "*"))
  }
}

然后在您的

Global.java

中添加过滤器，以便：

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

@覆盖
公共类[]过滤器（）{
返回新类[]{EnableCORS.Class}；
}

当请求引发异常（内部服务器错误）时，@alexhanschke提出的解决方案不起作用，因为发生异常时不会应用过滤器（请参阅）。要解决这个问题，您必须包装一个scala类并返回它，如下所示。请注意，这仍然需要指定的选项路由和一个控制器来处理选项请求

看看这里的一切

导入static play.core.j.JavaResults.BadRequest；
导入静态play.core.j.JavaResults.InternalServerError；
导入static play.core.j.JavaResults.NotFound；
导入java.util.ArrayList；
导入java.util.List；
导入play.GlobalSettings；
导入play.api.mvc.Results.Status；
导入play.libs.F.Promise；
导入play.libs.Scala；
导入play.mvc.Action；
导入play.mvc.Http；
导入play.mvc.Result；
导入scala.Tuple2；
导入scala.collection.Seq；
公共类全局扩展全局设置{
私有类ActionWrapper扩展了Action.Simple{
公共动作包装器（动作动作）{
这个代表=行动；
}
@凌驾
公共承诺调用（Http.Context ctx）抛出java.lang.Throwable{
承诺结果=this.delegate.call（ctx）；
Http.Response=ctx.Response（）；
response.setHeader（“访问控制允许原点“，“*”）；
返回结果；
}
}
/*
*将所需的CORS标头“Access Control Allow Origin”添加到成功的请求中
*/
@凌驾
公共操作onRequest（Http.Request-Request，java.lang.reflect.Method-actionMethod）{
返回新的ActionWrapper（super.onRequest（request，actionMethod））；
}
私有静态类CORSResult实现结果{
最终私密播放.api.mvc.Result wrappedResult；
公共公司结果（状态）{
列表=新的ArrayList（）；
tuple2t=新的Tuple2（“访问控制允许原点”、“*”）；
列表。添加（t）；
Seq Seq=Scala.toSeq（列表）；
wrappedResult=status.withHeaders（seq）；
}
public play.api.mvc.Result toScala（）{
返回此.wrappedResult；
}
}
/*
*将所需的CORS标头“访问控制允许来源”添加到错误请求
*/
@凌驾
公共承诺onBadRequest（Http.RequestHeader请求，字符串错误）{
return Promise.pure（新的CORSResult（BadRequest（））；
}
/*
*将所需的CORS标头“Access Control Allow Origin”添加到导致异常的请求中
*/
@凌驾
公共承诺onError（Http.RequestHeader请求，Throwable t）{
return Promise.pure（新的CORSResult（InternalServerError（））；
}
/*
*当找不到路由时，添加所需的CORS标头“访问控制允许原点”
*/
@凌驾
公共承诺onHandlerNotFound（Http.RequestHeader请求）{
return Promise.pure（新的CORSResult（NotFound（））；
}
}

我们使用了这种方法，在请求时遇到了问题，导致了错误。我们稍微修改了代码，以便在调用委托之前设置响应头。

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

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

}