JAX-RS 2 print JSON request
So there are a couple things to consider when trying to implement this
For the request entity, you will want the serialization to be handle by the framework, meaning you don't want to do something like
@Overridepublic void filter(ClientRequestContext requestContext) { Object entity = requestContext.getEntity(); String serialized = serializeEntity(entity); log(serialized);
Here you are serializing it yourself, maybe using Jackson
ObjectMapper
or something. You could do it this way, but it's kind of limited in the types it can handle. If you let the object be serialized the way it is already handled by the framework, the framework will be able to support many more types than just JSON.To let the framework handle the serialization, and still be able to get serialized data, we need to use a
WriterInterceptor
. What we can do is set the entity output stream to aByteArrayOutputStream
, and then let the framework serialize the request object to ourByteArrayOutputStream
, then afterwords log those bytes. This is how the JerseyLoggingFilter
handles this.For the response, in our filter, we need to extract the data from the response stream, but also we need to make sure the stream still has data, as it has not been deserialized yet for the client. To do this
mark()
andreset()
the stream, assuming marking is supported. If not, wrap it in aBufferedOutputStream
. Again, this is how the JerseyLoggingFilter
handles this.
Below is a complete simple implementation. Most of it is taken straight from the Jersey LoggingFilter
, though it is stripped down just for your use case. The Jersey LoggingFilter
logs a lot of other information, aside from the just the entity. One thing I left out is the checking for the charset. I just used a hard coded UTF-8, as the MessageUtil
class used by Jersey, is Jersey specific. If you want to make the filter more universal for other charsets, you may want to look into fixing that.
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); } }}
See Also: