JAX-RS 2打印JSON请求

时间:2016-04-17 11:40:54

标签: java json java-ee logging jax-rs

我希望能够从请求中打印JAX-RS 2 JSON有效负载,无论我的应用服务器上是否有实际实现。

我在SO上尝试了建议的解决方案,但都包含了实际实现的二进制文件(比如Jersey等),我只允许在我的应用程序中使用javaee-api v 7.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());
    }        
}

1 个答案:

答案 0 :(得分:24)

因此,在尝试实现此

时需要考虑几件事
  1. 对于请求实体,您需要框架处理序列化,这意味着您不要想要执行类似

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

    在这里,您自己序列化,也许使用杰克逊ObjectMapper或其他东西。你可以这样做,但它可以处理的类型有限。如果让对象按照框架已经处理的方式进行序列化,那么框架将能够支持比JSON更多的类型。

    要让框架处理序列化,并且仍然能够获取序列化数据,我们需要使用WriterInterceptor。我们可以做的是将实体输出流设置为ByteArrayOutputStream,然后让框架将请求对象序列化为我们的 ByteArrayOutputStream,然后记录这些字节。这就是泽西岛LoggingFilter处理这个问题的方法。

  2. 对于响应,在我们的过滤器中,我们需要从响应流中提取数据,但是我们需要确保流仍然有数据,因为它还没有对客户进行反序列化。要执行此操作mark()reset(),请假设支持标记。如果没有,请将其包裹在BufferedOutputStream中。同样,这就是泽西岛LoggingFilter处理这个问题的方式。

  3. 以下是一个完整的简单实现。其中大部分是直接从泽西岛LoggingFilter获取的,尽管它只是为了你的用例而被剥离。除了实体之外,泽西岛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);
            }
        }
    }
    

    另见: