java - 如何在 RESTEasy 中启用 JSONP？

Question

标题说的是我的问题。我需要将 DTO 包装到 javascript 方法回调中。目前我返回请求 JSON。但是在 Ajax 中使用它会出现问题，因为我将 GET 发送到其他域。当然还有安全警察。

我有想法创建附加提供。您有任何示例、链接或建议如何做到这一点。

score 12 · Accepted Answer

RESTEasy 中没有明确支持 JSONP，但是在应用程序中启用 JSONP 的一种简单方法是编写 Servlet 过滤器。

以下是一些可以帮助您编写过滤器的链接：

jsonp-java：服务器端过滤器将任何响应包装到 jsonp 回调中
从您的 JAX-RS Web 服务提供 JSONP
使用 Spring 的 DelegatingFilterProxy 为 JSONP 回调实现 Servlet 过滤器（如果您使用的是 Spring）

当我有这个要求时，我最终写了自己的，因为我找到的例子似乎都没有完全解决这个问题。这是我编写自己的过滤器的建议：

仅在指定回调参数时才包装响应（显然）
仅在响应内容类型为时包装响应application/json（或者如果您想支持更广泛的变体选择，仅在响应内容类型为时包装application/json或application/*+json）
使用 HttpServletResponseWrapper 以便您可以调用正向链 ( chain.doFilter) 而无需将任何数据写入实际响应。转发链完成后，您可以检查内容类型，确保要将响应包装为 JSONP，然后将捕获的数据连同 JSONP 前缀和后缀一起写入真实响应。
当您决定将响应包装为 JSONP 时，请确保将响应内容类型更改为text/javascript

如果您之前没有对 Java EE 过滤器做过很多工作，您可能需要先阅读 Java EE 教程的相关部分：过滤请求和响应。

score 4 · Accepted Answer

我为这个问题制定了解决方案草案。试试看。该解决方案通过 http get 参数获取数据并转换为虚拟 POST 请求。

查询：

function call(){
var val = '{"routes":[{"arrivalAddress":{"fullAddress":"DME"},"destinationAddress":{"fullAddress":"SVO"}}],"carsCount":"1"}';
var jHandler = "doMap";
$.getJSON("http://xxx:yyy/app-0.0.0.1/rest/requestPrice?callback=" + jHandler + "&json=" + encodeURIComponent(val)+"&jsoncallback=?", null, null, "json");
}

function doMap(obj){
alert(obj);
}

Service接口中的声明

@POST
@Path("requestPrice")
@Produces("application/json")
@Consumes("application/json")
PriceResponse requestPrice(PriceRequest request) throws ServiceException;

过滤器类：

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.*;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class JSONPRequestFilter implements Filter {
    private String callbackParameter;

    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        if (!(request instanceof HttpServletRequest)) {
            throw new ServletException("This filter can " +
                    " only process HttpServletRequest requests");
        }

        final HttpServletRequest httpRequest = (HttpServletRequest) request;
        final HttpServletResponse httpResponse = (HttpServletResponse) response;

        if (isJSONPRequest(httpRequest)) {
            RequestWrapper requestWrapper = new RequestWrapper(httpRequest);
            requestWrapper.setContentType("application/json; charset=UTF-8");
            requestWrapper.setHeader("cache-control", "no-cache");
            requestWrapper.setHeader("accept", "application/json");
            requestWrapper.setCharacterEncoding("UTF-8");
            requestWrapper.setBody(httpRequest.getParameter("json"));
            final ByteArrayOutputStream baos = new ByteArrayOutputStream();
            HttpServletResponseWrapper responseWrapper = new HttpServletResponseWrapper(httpResponse) {

                @Override
                public ServletOutputStream getOutputStream() throws IOException {
                    return new ServletOutputStream() {
                        @Override
                        public void write(int b) throws IOException {
                            baos.write(b);
                        }
                    };
                }

                @Override
                public PrintWriter getWriter() throws IOException {
                    return new PrintWriter(baos);
                }

                public String getData() {
                    return baos.toString();
                }
            };

            chain.doFilter(requestWrapper, responseWrapper);
            response.getOutputStream().write((getCallbackParameter(httpRequest) + "(").getBytes());
            response.getOutputStream().write(baos.toByteArray());
            response.getOutputStream().write(");".getBytes());

            response.setContentType("text/javascript");
        } else {
            chain.doFilter(request, response);
        }
    }

    private String getCallbackMethod(HttpServletRequest httpRequest) {
        return httpRequest.getParameter(callbackParameter);
    }

    private boolean isJSONPRequest(HttpServletRequest httpRequest) {
        String callbackMethod = getCallbackMethod(httpRequest);
        return (callbackMethod != null && callbackMethod.length() > 0);
    }

    private String getCallbackParameter(HttpServletRequest request) {
        return request.getParameter(callbackParameter);
    }

    public void init(FilterConfig filterConfig) throws ServletException {
        callbackParameter = filterConfig.getInitParameter("callbackParameter");
    }

    public void destroy() {
    }

    void printRequest(HttpServletRequest request) throws IOException {
        {
            System.out.println("--------------Headers---------------");
            Enumeration en = request.getHeaderNames();
            while (en.hasMoreElements()) {
                String val = en.nextElement().toString();
                System.out.println(val + " :");
                Enumeration en1 = request.getHeaders(val);
                while (en1.hasMoreElements()) {
                    System.out.println("\t" + en1.nextElement());
                }
            }
        }
        {
            System.out.println("------------Parameters--------------");
            Enumeration en = request.getParameterNames();
            while (en.hasMoreElements()) {
                String val = en.nextElement().toString();
                System.out.println(val + " :");
                String[] en1 = request.getParameterValues(val);
                for (String val1 : en1) {
                    System.out.println("\t" + val1);
                }
            }
        }
        System.out.println("---------------BODY--------------");
        BufferedReader is = request.getReader();
        String line;
        while ((line = is.readLine()) != null) {
            System.out.println(line);
        }
        System.out.println("---------------------------------");

        System.out.println("ContentType: " + request.getContentType());
        System.out.println("ContentLength: " + request.getContentLength());
        System.out.println("characterEncodings: " + request.getCharacterEncoding());
        System.out.println("AuthType: " + request.getAuthType());

        System.out.println("ContextPath: " + request.getContextPath());
        System.out.println("Method: " + request.getMethod());

    }

    public static class RequestWrapper extends HttpServletRequestWrapper {
        Map<String, String> headers = new HashMap<String, String>();

        int contentLength;
        BufferedReader reader;

        public RequestWrapper(HttpServletRequest request) {
            super(request);
        }

        public void setHeader(String key, String value) {
            headers.put(key, value);
        }

        ByteArrayInputStream bais;
        public void setBody(String body) {
            bais = new ByteArrayInputStream(body.getBytes());
            contentLength = body.length();
            headers.put("content-length", Integer.toString(contentLength));
        }

        @Override
        public BufferedReader getReader() throws IOException {
            reader = new BufferedReader(new InputStreamReader(bais));
            return reader;
        }

        @Override
        public ServletInputStream getInputStream() throws IOException {
            return new ServletInputStream() {
                @Override
                public int read() throws IOException {
                    return bais.read();
                }
            };
        }

        @Override
        public String getMethod() {
            return "POST";
        }

        private String contentType;

        public void setContentType(String contentType) {
            this.contentType = contentType;
            headers.put("content-type", contentType);
        }

        @Override
        public String getContentType() {
            return contentType;
        }

        @Override
        public int getContentLength() {
            return contentLength;
        }

        @Override
        public String getHeader(String name) {
            String val = headers.get(name);
            if (val != null) {
                return val;
            }
            return super.getHeader(name);    //To change body of overridden methods use File | Settings | File Templates.
        }

        @Override
        public Enumeration getHeaders(final String name) {
            return super.getHeaders(name);
        }

        @Override
        public Enumeration getHeaderNames() {
            final Enumeration en1 = super.getHeaderNames();
            final Iterator it = headers.keySet().iterator();
            return new Enumeration() {
                public boolean hasMoreElements() {
                    return en1.hasMoreElements() || it.hasNext();
                }

                public Object nextElement() {
                    return en1.hasMoreElements() ? en1.nextElement() : (it.hasNext() ? it.next() : null);
                }
            };
        }

        @Override
        public int getIntHeader(String name) {
            String val = headers.get(name);
            if (val == null) {
                return super.getIntHeader(name);
            } else {
                return Integer.parseInt(val);
            }
        }
    }
}

web.xml

<filter>
    <filter-name>JSONPRequestFilter</filter-name>
    <filter-class>xxxxx.JSONPRequestFilter</filter-class>
    <init-param>
        <param-name>callbackParameter</param-name>
        <param-value>callback</param-value>
    </init-param>
</filter>

<filter-mapping>
  <filter-name>JSONPRequestFilter</filter-name>
  <url-pattern>/rest/*</url-pattern>
</filter-mapping>

score 2 · Accepted Answer

支持 JSONP 的增强功能计划在 RESTEasy 2.3.6 Final/3.0-beta-4 ( https://issues.jboss.org/browse/RESTEASY-342 ) 中发布。我能够通过简单地从 GitHub复制他们的代码来“反向移植”我使用 RESTEasy 2.3.5 的项目。

RESTEasy 会根据注释自动选择新的提供者。一旦在 url 中看到名为“callback”的查询参数，它就会通过将结果包装在 js 回调中自动工作。这与 JQuery 向服务器发送的 JSONP 请求兼容。

score 1 · Accepted Answer

从@talawahdotnet 开始，我使用的是 RestEasy 3.0.9.Final 并且支持 JSONP，一旦启用，任何带有“回调”查询参数的请求都将被包装为 JSONP。我正在使用 JBoss，所以其他容器的完整文档在这里。这是我必须做的步骤：

在你的 web.xml 添加：

<context-param>
    <param-name>resteasy.providers</param-name>
    <param-value>org.jboss.resteasy.plugins.providers.jackson.JacksonJsonpInterceptor</param-value>
</context-param>

确保您有一个 WEB-INF/jboss-deployment-structure.xml，其中包含：

<jboss-deployment-structure>
    <deployment>
        <dependencies>
            <module name="org.jboss.resteasy.resteasy-jackson-provider" services="import" annotations="true"/>
        </dependencies>
    </deployment>
</jboss-deployment-structure>

确保您的 pom.xml 中有一个 resteasy-jackson-provider 依赖项，例如：

<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-jackson-provider</artifactId>
    <scope>provided</scope>
</dependency>

score 1 · Accepted Answer

Resteasy声称在 3.x 版本中支持开箱即用的 JSONP：

如果您使用的是 Jackson，Resteasy 有 JSONP，您可以通过将提供程序 org.jboss.resteasy.plugins.providers.jackson.JacksonJsonpInterceptor（如果您使用的是 Jackson2 提供程序，则为 Jackson2JsonpInterceptor）添加到您的部署中来打开它。如果响应的媒体类型是 json 并且给出了回调查询参数，则响应将是一个 JavaScript 片段，其中包含回调参数定义的方法的方法调用。例如：

GET /resources/stuff?callback=processStuffResponse 将产生这个响应：

processStuffResponse() 这支持 jQuery 的默认行为。

您可以通过设置 callbackQueryParameter 属性来更改回调参数的名称。

但是，由于RESTEASY-1168: Jackson2JsonpInterceptor does not render closing bracket，它似乎被破坏了

所以 foo({"foo":"bar"} 被渲染而不是 foo({"foo":"bar"})

这会导致“Uncaught SyntaxError：Unexpected Identifier”错误

我已经提交了一个带有修复的拉取请求，希望它应该进入下一个版本 3.0.12

我知道这个问题很老了，但是当你搜索resteasy jsonp问题时它显示在谷歌的第一页，所以我决定更新它

java - 如何在 RESTEasy 中启用 JSONP？

5 回答 5

Related

Reference