Question

我正在开发一个java脚本客户端应用程序，在服务器端我需要处理CORS，我在JAX-RS中使用JERSEY编写的所有服务。我的代码：

@CrossOriginResourceSharing(allowAllOrigins = true)
@GET
@Path("/readOthersCalendar")
@Produces("application/json")
public Response readOthersCalendar(String dataJson) throws Exception {  
     //my code. Edited by gimbal2 to fix formatting
     return Response.status(status).entity(jsonResponse).header("Access-Control-Allow-Origin", "*").build();
}

截至目前，我收到错误否＆＃39; Access-Control-Allow-Origin＆＃39;标头出现在请求的资源上。起源＆＃39; http://localhost:8080＆＃39;因此不允许访问。“

请帮助我。

谢谢＆amp;问候佛Puneeth

Answer 1

注意：请务必阅读底部的更新

@CrossOriginResourceSharing是一个CXF注释，所以它不能与泽西岛合作。

使用Jersey来处理CORS，我通常只使用ContainerResponseFilter。泽西1和2的ContainerResponseFilter有点不同。由于您还没有提到您正在使用哪个版本，我会发布这两个版本。

泽西岛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");
    }
}

如果您使用包扫描来发现提供者和资源，@Provider注释应该为您处理配置。如果没有，那么您需要使用ResourceConfig或Application子类明确注册它。

使用ResourceConfig明确注册过滤器的示例代码：

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

对于Jersey 2.x，如果您在注册此过滤器时遇到问题，可以使用以下几种资源


Registering Resources and Providers in Jersey 2

What exactly is the ResourceConfig class in Jersey 2?

泽西岛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配置，可以使用

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

或ResourceConfig你可以做到

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

或使用@Provider注释进行打包扫描。

修改

请注意，上面的例子可以改进。您需要了解有关CORS如何工作的更多信息。请参阅here。首先，您将获得所有回复的标题。这可能是不可取的。您可能只需要处理预检（或OPTIONS）。如果您想查看更好的CORS过滤器，可以查看RESTeasy CorsFilter的源代码

更新

所以我决定添加更正确的实现。上面的实现是惰性的，并将所有CORS头添加到所有请求中。另一个错误是，它只是一个响应过滤器，请求仍然是进程。这意味着当预检请求进入时，这是一个OPTIONS请求，将不会实现OPTIONS方法，因此我们将得到405响应，这是不正确的。

以下是的工作方式。因此，有两种类型的CORS请求：简单请求和preflight requests。对于简单请求，浏览器将发送实际请求并添加Origin请求标头。浏览器期望响应具有Access-Control-Allow-Origin标头，表示允许来自Origin标头的来源。为了使其被视为简单的请求＆＃34;，它必须符合以下标准：

是以下方法之一：
- GET
- HEAD
- POST
除了浏览器自动设置的标头外，该请求可能只包含以下手动设置标头：
- Accept
- Accept-Language
- Content-Language
- Content-Type
- DPR
- Save-Data
- Viewport-Width
- Width
Content-Type标头唯一允许的值为：
- application/x-www-form-urlencoded
- multipart/form-data
- text/plain

如果请求不符合所有这三个标准，则会发出预检请求。这是对服务器进行的OPTIONS请求，之前对正在进行的实际请求。它将包含不同的Access-Control-XX-XX标头，服务器应使用自己的CORS响应标头响应这些标头。以下是匹配的标题：

                 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    |
+-----------------------------------+--------------------------------------+

使用Origin请求标头，该值将是原始服务器域，响应Access-Control-Allow-Header应该是相同的地址或*以指定所有来源是允许的。
如果客户端尝试手动设置不在上面列表中的任何标头，则浏览器将设置Access-Control-Request-Headers标头，其值为客户端尝试设置的所有标头的列表。服务器应使用Access-Control-Allow-Headers响应标头进行响应，其值为允许的标头列表。
浏览器还将设置Access-Control-Request-Method请求标头，其值为请求的HTTP方法。服务器应该使用Access-Control-Allow-Methods响应标头进行响应，其值是它允许的方法列表。
如果客户端使用XHR.withCredentials，则服务器应使用Access-Control-Allow-Credentials响应标头进行响应，其值为true。 Read more here

所以尽管如此，这是一个更好的实现。即使这比上面的实现更好，它仍然不如我链接的RESTEasy one，因为这个实现仍然允许所有的起源。但是这个过滤器比上面的过滤器更好地遵守CORS规范，而过滤器只是将CORS响应头添加到所有请求中。请注意，您可能还需要修改Access-Control-Allow-Headers以匹配应用程序允许的标头;您可能希望在此示例中添加或删除列表中的某些标题。

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

要了解有关CORS的更多信息，建议您阅读Cross-Origin Resource Sharing (CORS)

上的MDN文档

Answer 2

另一个答案可能是严格正确的，但具有误导性。缺少的部分是您可以将来自不同来源的过滤器混合在一起。甚至认为泽西岛可能不提供CORS过滤器（不是我检查的事实，但我相信其他答案），你可以使用tomcat's own CORS filter。

我在泽西岛成功使用它。我有自己的基本身份验证过滤器实现，例如，与CORS一起。最重要的是，CORS过滤器是在Web XML中配置的，而不是在代码中配置的。

Answer 3

删除注释“@CrossOriginResourceSharing(allowAllOrigins = true)”

然后返回响应如下：

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

但是jsonResponse应该替换为POJO对象！

Answer 4

要为我的项目解决这个问题，我使用Micheal's回答并达到了这个目的：

    <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <executions>
            <execution>
                <id>run-embedded</id>
                <goals>
                    <goal>run</goal>
                </goals>
                <phase>pre-integration-test</phase>
                <configuration>
                    <port>${maven.tomcat.port}</port>
                    <useSeparateTomcatClassLoader>true</useSeparateTomcatClassLoader>
                    <contextFile>${project.basedir}/tomcat/context.xml</contextFile>
                    <!--enable CORS for development purposes only. The web.xml file specified is a copy of
                        the auto generated web.xml with the additional CORS filter added -->
                    <tomcatWebXml>${maven.tomcat.web-xml.file}</tomcatWebXml>
                </configuration>
            </execution>
        </executions>
    </plugin>

CORS过滤器是the tomcat site.的基本示例过滤器。

的修改：
maven.tomcat.web-xml.file 变量是项目的pom定义属性，它包含web.xml文件的路径（位于我的项目中）

Answer 5

peeskillet的回答是正确的。但是我在刷新网页时遇到这个错误（它只在第一次加载时起作用）：

function capture(id) {

        html2canvas([document.getElementById(id)], {
            logging: true,
            onrendered: function(canvas) {
                document.body.appendChild(canvas);
                var dataUrl = canvas.toDataURL("image/png")
                //console.log(dataUrl)
                $('#img-out').attr("src", canvas.toDataURL("image/png"));

                $.post("/upload-img", {img: dataUrl, name: id}, function (res) {
                    console.log(res) 


                    location.href = $("#" + id).attr("shareUrl") + "&picture=" + (window.location.protocol + "//" +window.location.host + "/" + res.filePath)

                } )
            }
        });
    }

因此，我使用put方法而不是使用add方法为响应添加标头。这是我的班级

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.

将此类添加到web.xml中的init-param

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

Answer 6

使用 JAX-RS ，您只需将注释@CrossOrigin(origin = yourURL)添加到资源控制器即可。在您的情况下，您将@CrossOrigin(origin = "http://localhost:8080")，但您也可以使用@CrossOrigin(origin = "*")来允许任何请求通过您的网络服务。
您可以查看THIS以获取更多信息。

如何使用JAX-RS和Jersey处理CORS

6 个答案:

泽西岛2

泽西岛1

修改

更新