Java JAX-RS 2打印JSON请求

我希望能够从请求中打印JAX-RS2JSON负载，而不考虑在我的应用服务器上的实际实现

我已经在SO上尝试过建议的解决方案，但都包括来自实际实现的二进制文件（如Jersey和类似的），并且我只允许在我的应用程序中使用JavaEEAPIV7.0

我尝试在我的客户端上实现ClientRequestFilter和ClientResponseFilter，但它们不包含序列化实体

以下是一个客户端示例：

WebTarget target = ClientBuilder.newClient().register(MyLoggingFilter.class).target("http://localhost:8080/loggingtest/resources/accounts");
Account acc = target.request().accept(MediaType.APPLICATION_JSON).get(account.Account.class);

下面是MyLoggingFilter的实现：

@Provider
public class MyLoggingFilter implements ClientRequestFilter, ClientResponseFilter {

    private static final Logger LOGGER = Logger.getLogger(MyLoggingFilter.class.getName());

    @Override
    public void filter(ClientRequestContext requestContext) throws IOException {

        LOGGER.log(Level.SEVERE, "Request method: {0}", requestContext.getMethod());

    }

    @Override
    public void filter(ClientRequestContext requestContext, ClientResponseContext responseContext) throws IOException {
        LOGGER.log(Level.SEVERE, "Response status: {0}", responseContext.getStatus());
    }        
}

---

因此，当试图实现这个

时，有两件事需要考虑。

对于请求实体，您希望序列化由框架处理，这意味着您不希望执行类似的操作

@Override
public void filter(ClientRequestContext requestContext) {
    Object entity = requestContext.getEntity();
    String serialized = serializeEntity(entity);
    log(serialized);

在这里，您可以使用Jackson

ObjectMapper

或其他方法对其进行序列化。你可以这样做，但它能处理的类型有限。如果让对象按照框架已经处理过的方式进行序列化，那么框架将能够支持比JSON更多的类型

为了让框架处理序列化，并且仍然能够获得序列化数据，我们需要使用。我们可以做的是将实体输出流设置为

ByteArrayOutputStream

，然后让框架将请求对象序列化为我们的

ByteArrayOutputStream

，然后在事后记录这些字节。这就是Jersey

LoggingFilter

处理此问题的方式

对于响应，在我们的过滤器中，我们需要从响应流中提取数据，但是我们还需要确保流仍然有数据，因为它还没有被客户机反序列化。要执行此操作，请将流

mark（）

和

reset（）

标记，前提是支持标记。如果不是，则将其包装在

缓冲输出流中

。同样，这也是Jersey

LoggingFilter

处理此问题的方式

下面是一个完整的简单实现。大部分内容直接取自Jersey

LoggingFilter

，尽管它只是为了您的用例而精简的。Jersey

LoggingFilter

记录了很多其他信息，除了实体之外。我遗漏的一件事是检查字符集。我刚刚使用了一个硬编码的UTF-8，因为Jersey使用的

MessageUtil

类是Jersey特有的。如果您想使过滤器对其他字符集更通用，您可能需要考虑修复它

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.logging.Logger;
import javax.annotation.Priority;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.client.ClientRequestContext;
import javax.ws.rs.client.ClientRequestFilter;
import javax.ws.rs.client.ClientResponseContext;
import javax.ws.rs.client.ClientResponseFilter;
import javax.ws.rs.ext.WriterInterceptor;
import javax.ws.rs.ext.WriterInterceptorContext;

@Priority(Integer.MIN_VALUE)
public class EntityLoggingFilter implements ClientRequestFilter, ClientResponseFilter, WriterInterceptor {

    private static final Logger logger = Logger.getLogger(EntityLoggingFilter.class.getName());
    private static final String ENTITY_STREAM_PROPERTY = "EntityLoggingFilter.entityStream";
    private static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
    private final int maxEntitySize = 1024 * 8;

    private void log(StringBuilder sb) {
        logger.info(sb.toString());
    }

    private InputStream logInboundEntity(final StringBuilder b, InputStream stream, final Charset charset) throws IOException {
        if (!stream.markSupported()) {
            stream = new BufferedInputStream(stream);
        }
        stream.mark(maxEntitySize + 1);
        final byte[] entity = new byte[maxEntitySize + 1];
        final int entitySize = stream.read(entity);
        b.append(new String(entity, 0, Math.min(entitySize, maxEntitySize), charset));
        if (entitySize > maxEntitySize) {
            b.append("...more...");
        }
        b.append('\n');
        stream.reset();
        return stream;
    }

    @Override
    public void filter(ClientRequestContext requestContext) throws IOException {
        if (requestContext.hasEntity()) {
            final OutputStream stream = new LoggingStream(requestContext.getEntityStream());
            requestContext.setEntityStream(stream);
            requestContext.setProperty(ENTITY_STREAM_PROPERTY, stream);
        }
    }

    @Override
    public void filter(ClientRequestContext requestContext,
            ClientResponseContext responseContext) throws IOException {
        final StringBuilder sb = new StringBuilder();
        if (responseContext.hasEntity()) {
            responseContext.setEntityStream(logInboundEntity(sb, responseContext.getEntityStream(),
                    DEFAULT_CHARSET));
            log(sb);
        }

    }

    @Override
    public void aroundWriteTo(WriterInterceptorContext context)
            throws IOException, WebApplicationException {
        final LoggingStream stream = (LoggingStream) context.getProperty(ENTITY_STREAM_PROPERTY);
        context.proceed();
        if (stream != null) {
            log(stream.getStringBuilder(DEFAULT_CHARSET));
        }
    }

    private class LoggingStream extends FilterOutputStream {

        private final StringBuilder sb = new StringBuilder();
        private final ByteArrayOutputStream baos = new ByteArrayOutputStream();

        LoggingStream(OutputStream out) {
            super(out);
        }

        StringBuilder getStringBuilder(Charset charset) {
            // write entity to the builder
            final byte[] entity = baos.toByteArray();

            sb.append(new String(entity, 0, entity.length, charset));
            if (entity.length > maxEntitySize) {
                sb.append("...more...");
            }
            sb.append('\n');

            return sb;
        }

        @Override
        public void write(final int i) throws IOException {
            if (baos.size() <= maxEntitySize) {
                baos.write(i);
            }
            out.write(i);
        }
    }
}

import java.io.BufferedInputStream；
导入java.io.ByteArrayOutputStream；
导入java.io.FilterOutputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.OutputStream；
导入java.nio.charset.charset；
导入java.nio.charset.StandardCharset；
导入java.util.logging.Logger；
导入javax.annotation.Priority；
导入javax.ws.rs.WebApplicationException；
导入javax.ws.rs.client.ClientRequestContext；
导入javax.ws.rs.client.ClientRequestFilter；
导入javax.ws.rs.client.ClientResponseContext；
导入javax.ws.rs.client.ClientResponseFilter；
导入javax.ws.rs.ext.WriterInterceptor；
导入javax.ws.rs.ext.WriterInterceptorContext；
@优先级（整数。最小值）
公共类EntityLoggingFilter实现ClientRequestFilter、ClientResponseFilter、WriterInterceptor{
私有静态最终记录器Logger=Logger.getLogger（EntityLoggingFilter.class.getName（））；
私有静态最终字符串实体\u流\u属性=“EntityLoggingFilter.entityStream”；
私有静态最终字符集DEFAULT_Charset=StandardCharsets.UTF_8；
私有最终整数maxEntitySize=1024*8；
私人作废日志（StringBuilder sb）{
logger.info（sb.toString（））；
}
私有InputStream logInboundEntity（最终StringBuilder b、InputStream流、最终字符集字符集）引发IOException{
如果（！stream.markSupported（））{
流=新的BufferedInputStream（流）；
}
流标记（maxEntitySize+1）；
最终字节[]实体=新字节[maxEntitySize+1]；
final int entitySize=stream.read（实体）；
b、 追加（新字符串（实体，0，Math.min（entitySize，maxEntitySize），字符集））；
如果（entitySize>maxEntitySize）{
b、 附加（“…更多…”）；
}
b、 追加（'\n'）；
stream.reset（）；
回流；
}
@凌驾
公共无效筛选器（ClientRequestContext requestContext）引发IOException{
if（requestContext.hasEntity（））{
final OutputStream=new LoggingStream（requestContext.getEntityStream（））；
requestContext.setEntityStream（流）；
setProperty（实体\流\属性，流）；
}
}
@凌驾
公共无效筛选器（ClientRequestContext requestContext，
ClientResponseContext responseContext）引发IOException{
最终StringBuilder sb=新StringBuilder（）；
if（responseContext.hasEntity（））{
responseContext.setEntityStream（logInboundEntity（sb，responseContext.getEntityStream（），
默认字符集）；
日志（sb）；
}
}
@凌驾
WriteTo周围的公共无效（WriterInterceptorContext上下文）
抛出IOException、WebApplicationException{
final LoggingStream=（LoggingStream）context.getProperty（ENTITY\u stream\u PROPERTY）；
context.procedure（）；
if（流！=null）{
日志（stream.getStringBuilder（默认字符集））；
}
}
私有类LoggingStream扩展FilterOutputStream{
私有最终StringBuilder sb=新StringBuilder（）；
私有最终ByteArrayOutputStream bas=新ByteArrayOutputStream（）；
记录流（输出流输出）{
超级（出局）；
}
StringBuilder getStringBuilder（字符集字符集）{
//将实体写入生成器
最终字节[]实体=bas.toByteArray（）；
sb.追加（新字符串（实体，0，实体长度，c