我创建了一个Undertow服务器和一个Handler来记录请求。我在检索HttpServerExchange的请求正文时遇到问题。
在LoggingHandler课上，我的身体没有问题。但是在TestEndpoint处，身体空了。
如果我删除在LoggingHandler处检索请求正文的行，则该正文将填充在TestEndpoint处。
有人知道这样做的方法吗？
我的服务器类：
package com.undertow.server;
import com.undertow.server.endpoints.TestEndpoint;
import org.jboss.resteasy.plugins.server.undertow.UndertowJaxrsServer;
import org.jboss.resteasy.spi.ResteasyDeployment;
import io.undertow.Undertow;
import io.undertow.Undertow.Builder;
import io.undertow.server.HandlerWrapper;
import io.undertow.server.HttpHandler;
import io.undertow.server.handlers.BlockingHandler;
import io.undertow.servlet.api.DeploymentInfo;
public class UndertowServer {
private UndertowJaxrsServer server;
public UndertowServer() {
this.server = new UndertowJaxrsServer();
}
public void start() {
Builder builder = Undertow.builder().addHttpListener(8000, "0.0.0.0");
this.server.start(builder);
this.configureEndpoints();
}
private void configureEndpoints() {
ResteasyDeployment deployment = new ResteasyDeployment();
deployment.getActualResourceClasses().add(TestEndpoint.class);
DeploymentInfo deploymentInfo = this.server.undertowDeployment(deployment) //
.setClassLoader(ClassLoader.getSystemClassLoader()).setContextPath("/gateway/") //
.setDeploymentName("gateway.war");
deploymentInfo.addInitialHandlerChainWrapper(new HandlerWrapper() {
@Override
public HttpHandler wrap(HttpHandler handler) {
return new BlockingHandler(new LoggingHandler(handler));
}
});
this.server.deploy(deploymentInfo);
}
public static void main(String[] args) {
new UndertowServer().start();
}
}
我的LoggingHandler类：
package com.undertow.server;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.stream.Collectors;
import org.apache.log4j.Logger;
import io.undertow.server.HttpHandler;
import io.undertow.server.HttpServerExchange;
public class LoggingHandler implements HttpHandler {
private static Logger LOGGER = Logger.getLogger(LoggingHandler.class);
private final HttpHandler next;
public LoggingHandler(final HttpHandler next) {
this.next = next;
}
@Override
public void handleRequest(HttpServerExchange exchange) throws Exception {
LOGGER.info(toString(exchange.getInputStream()).trim());
this.next.handleRequest(exchange);
}
private String toString(InputStream is) throws IOException {
try (BufferedReader br = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {
return br.lines().collect(Collectors.joining(System.lineSeparator()));
}
}
}
我的TestEndpoint类：
package com.undertow.server.endpoints;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.container.AsyncResponse;
import javax.ws.rs.container.Suspended;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import org.apache.log4j.Logger;
@Path("/person")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public class TestEndpoint {
private static Logger LOGGER = Logger.getLogger(TestEndpoint.class);
@POST
@Path("/add")
public void listar(@Suspended AsyncResponse response, String body) {
LOGGER.info(body.trim());
response.resume(Response.ok().build());
}
}
非常感谢！
正如我在下面的评论中所说，看来您的实现问题在于将inputStream转换为String的方法。关闭BufferedReader后，它会关闭位于交换机内部的inputStream。看一下这个问题：Should BufferedReader and InputStreamReader be closed explicitly?
一个简单的解决方案应该是不明确关闭BufferedStream（或避免尝试使用resource块）：
private String toString(InputStream is) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8));
return br.lines().collect(Collectors.joining(System.lineSeparator()));
}
预期将关闭流的那个是创建它的元素，因此在这种情况下，您可以利用它来安全关闭并拖曳。
首先，您应该知道在Java中inputStream应该不可重复读取。例如，ByteArrayInputStream不可重复读取。我们都知道实现可重复的inputStream很容易，但是jdk无法实现。遵循InputStream的统一标准。
/**
* Reads the next byte of data from the input stream. The value byte is
* returned as an <code>int</code> in the range <code>0</code> to
* <code>255</code>. If no byte is available because the end of the stream
* has been reached, the value <code>-1</code> is returned. This method
* blocks until input data is available, the end of the stream is detected,
* or an exception is thrown.
*
* <p> A subclass must provide an implementation of this method.
*
* @return the next byte of data, or <code>-1</code> if the end of the
* stream is reached.
* @exception IOException if an I/O error occurs.
*/
public abstract int read() throws IOException;
解决问题的方法是先读取流并缓存数据，然后在执行handleRequest方法后将输入流写入HttpServerExchange。但是HttpServerExchange没有setInputStream方法，因此必须通过反射来实现。
InputStream存储在交换中，由处理程序共享。读入一个处理程序后，您将无法在下一个处理程序中重新读取它。相反，您可以将阅读的内容作为附件存储在交易所中。因此，您可以直接获取它，而无需再次阅读它，这效率很低。
public static final AttachmentKey<Object> REQUEST_BODY = AttachmentKey.create(Object.class);
exchange.putAttachment(REQUEST_BODY, toString(exchange.getInputStream()).trim());