Java 播放框架2.3-CORS标题

更新新的Play 2.5提供了新的

随着新的2.3Java版本完成了响应类到Promise类的迁移，下面的代码不再工作

public class CorsAction extends Action.Simple {

 public Result call(Context context) throws Throwable{ 
 Response response = context.response(); 
 response.setHeader("Access-Control-Allow-Origin", "*"); 
 //Handle preflight requests 
 if(context.request().method().equals("OPTIONS")) { 
   response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE"); 
   response.setHeader("Access-Control-Max-Age", "3600"); 
   response.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-    Type, Accept, Authorization, X-Auth-Token"); 
   response.setHeader("Access-Control-Allow-Credentials", "true"); 
   response.setHeader("Access-Control-Allow-Origin", "*"); 
 return ok() 

 } 

 response.setHeader("Access-Control-Allow-Headers","X-Requested-With, Content-Type, X-    Auth-Token"); 
 return delegate.call(context); 
 } 
}

我正在开发一个applicationinplay（Java）2.3，我已经研究并尝试了不同的方法来启用CORS，包括向routes文件添加/OPTIONS方法，但没有成功

我非常希望了解新的响应实现将如何处理这种类型的拦截，因为在新的Promise类中实现时，它在头中似乎没有任何影响

---

提前感谢所有的帮助

看起来你可能已经解决了你的问题，但为了清楚起见

您非常接近……我相信您不需要实例化自己的响应对象，您只需调用通过方法传入的响应对象即可：

public Result call() throws Throwable
{     
    response().setHeader("Access-Control-Allow-Origin", "*"); 
       //Handle preflight requests 
    if(request().method().equals("OPTIONS")) 
    { 
        response().setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE");     
        response().setHeader("Access-Control-Max-Age", "3600"); 
        response().setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-    Type, Accept, Authorization, X-Auth-Token"); 
        response().setHeader("Access-Control-Allow-Credentials", "true"); 
        response().setHeader("Access-Control-Allow-Origin", "*"); 
        return ok();
    } 
    else
    {
          return badRequest();
    }
}

希望能有所帮助。

通过以下方式解决此问题：

来自服务器的所有API响应都应包含一个标题：“访问控制允许来源”、“*”。我们需要为所有操作响应编写一个包装器

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

}

应用程序中的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：通过这种方法，我不必为此创建scala过滤器。

从中交叉发布

当请求引发异常（内部服务器错误）时，@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（））；
}
}

这对我很有效。但是，您可能需要调整一些参数（application.conf）

步骤1 创建过滤器类（UrlFilter）

步骤2 在build.sbt中导入筛选器包

步骤3 在application.conf中注册UrlFilter类

注意：请记住指向其确切位置。我的在app/filters/UrlFilter.java中

步骤4 添加允许“访问控制允许原点”和更多的实际配置。转到application.conf

信用

---

在chrome、firefox和explorer中为我配置：

我使用和前一个解决了它。进一步详情

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

}

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

}

package filters;

    import play.mvc.EssentialFilter;
    import play.filters.cors.CORSFilter;
    import play.http.DefaultHttpFilters;

    import javax.inject.Inject;

    public class UrlFilter extends DefaultHttpFilters {
        @Inject public UrlFilter(CORSFilter corsFilter) {
            super(corsFilter);
        }
    }

libraryDependencies += filters

play.http.filters = "filters.UrlFilter"

 play.filters.cors {

  # The path prefixes to filter.
  pathPrefixes = ["/"]

  # The allowed origins. If null, all origins are allowed.
  allowedOrigins = null

  # The allowed HTTP methods. If null, all methods are allowed
  allowedHttpMethods = null

  # The allowed HTTP headers. If null, all headers are allowed.
  allowedHttpHeaders = null

  # The exposed headers
  exposedHeaders = []

  # Whether to support credentials
  supportsCredentials = true

  # The maximum amount of time the CORS meta data should be cached by the client
  preflightMaxAge = 1 hour
}