JAX-RS 2 打印 JSON 请求 [英] JAX-RS 2 print JSON request
问题描述
我希望能够从请求中打印 JAX-RS 2 JSON 有效负载，而不管我的应用服务器上的实际实现如何.
I'd like to be able to print JAX-RS 2 JSON payload from request, regardless of actual implementation on my application server.
我已经尝试过关于 SO 的建议解决方案，但都包含来自实际实现的二进制文件(如 Jersey 和类似的)，并且我只能在我的应用程序中使用 javaee-api v 7.0.
I've tried suggested solutions on SO but all include binaries from actual implementation (like Jersey and similar), and I'm allowed only to use javaee-api v 7.0 in my application.
我尝试在我的客户端上实现 ClientRequestFilter 和 ClientResponseFilter，但它们不包含序列化实体.
I've tried implementing ClientRequestFilter and ClientResponseFilter on my Client but they don't contain serialized entities.
以下是客户端示例:
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 的实现:
And here's the implementation of 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());
}
}
推荐答案
因此，在尝试实施此方案时需要考虑一些事项
So there are a couple things to consider when trying to implement this
对于请求实体，您将希望序列化由框架处理，这意味着您不想想做类似
@Override
public void filter(ClientRequestContext requestContext) {
Object entity = requestContext.getEntity();
String serialized = serializeEntity(entity);
log(serialized);
在这里你自己序列化它，也许使用 Jackson ObjectMapper 或其他东西.你可以这样做，但它可以处理的类型有限.如果您让对象按照框架已经处理的方式进行序列化，那么框架将能够支持更多类型，而不仅仅是 JSON.
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.
为了让框架处理序列化，并且仍然能够获取序列化数据，我们需要使用一个WriterInterceptor.我们能做的就是将实体输出流设置为一个ByteArrayOutputStream，然后让框架将请求对象序列化为我们的ByteArrayOutputStream，然后记录这些字节.这就是 Jersey LoggingFilter 处理这个的方式.
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 a ByteArrayOutputStream, and then let the framework serialize the request object to our ByteArrayOutputStream, then afterwords log those bytes. This is how the Jersey LoggingFilter handles this.
对于响应，在我们的过滤器中，我们需要从响应流中提取数据，但还我们需要确保流仍然有数据，因为它没有被尚未为客户端反序列化.要做到这一点 mark() 和 reset() 流，假设支持标记.如果没有，请将其包装在 BufferedOutputStream 中.同样，这就是 Jersey LoggingFilter 处理这个的方式.
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() and reset() the stream, assuming marking is supported. If not, wrap it in a BufferedOutputStream. Again, this is how the Jersey LoggingFilter handles this.
下面是一个完整的简单实现.大部分内容直接取自 Jersey LoggingFilter，尽管它只是针对您的用例进行了剥离.Jersey LoggingFilter 记录了许多其他信息，除了实体之外.我遗漏的一件事是检查字符集.我只是使用了硬编码的 UTF-8，因为 Jersey 使用的 MessageUtil 类是 Jersey 特定的.如果您想让过滤器对其他字符集更通用，您可能需要考虑修复该问题.
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('
');
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('
');
return sb;
}
@Override
public void write(final int i) throws IOException {
if (baos.size() <= maxEntitySize) {
baos.write(i);
}
out.write(i);
}
}
}
另见:
这篇关于JAX-RS 2 打印 JSON 请求的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
