因此，在尝试实现此功能时需要考虑几件事

1. 对于请求实体，你会想序列化是由框架处理，这意味着你 不 希望这样做

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

在这里，您可以自己序列化它，也许使用Jackson ObjectMapper或其他方法。您 可以
通过这种方式进行操作，但是它可以处理的类型受到限制。如果让对象按照框架已处理的方式进行序列化，则该框架将能够支持更多类型，而不仅仅是JSON。

为了让框架处理序列化并仍然能够获取序列化的数据，我们需要使用WriterInterceptor。什么我们能做的就是设置实体输出流的ByteArrayOutputStream，然后让框架连载请求对象到
我们 ByteArrayOutputStream，那么后记记录这些字节。球衣就是这样LoggingFilter处理的。

1. 对于响应，在我们的过滤器中，我们需要从响应流中提取数据，但是我们 还 需要确保流中仍然有数据，因为尚未为客户端反序列化它。要做到这一点mark()并reset()流，支持假设标记。如果不是，请将其包装在中BufferedOutputStream。同样，泽西岛就是这样LoggingFilter处理的。

下面是一个完整的简单实现。大部分都是直接从Jersey获得的LoggingFilter，尽管只是为您的用例而精简。LoggingFilter除了实体之外，Jersey还记录了许多其他信息。我遗漏的一件事是检查字符集。我只使用了硬编码的UTF-8，因为MessageUtilJersey使用的类是特定于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);
            }
        }
    }

也可以看看：

• 泽西岛的源代码 LoggingFilter