代码之家 › 专栏 › 技术社区 › xtratic Rob

如何使用documentbuilder在不关闭流的情况下通过套接字inputstream解析xml文档?

domparser domdocument sockets xml java

-1

xtratic Rob · 技术社区 · 6 年前

有没有一种方法可以在不关闭客户端流的情况下从套接字inputstream解析xml文档?我只控制接收XML的服务器端,套接字将保持打开状态,因为服务器将向客户端发送响应。

我能告诉它在找到根元素结束标记时停止并返回文档吗?我需要修改解析器,不是吗? ~~既然文档中有多个根元素会使文档格式不好,那么为什么还要费心进一步解析呢?~~ 它在结束元素之后继续解析,因为它检查的是后面的注释或处理指令,在我的例子中,我不关心这些,并且会忽略它们。

我发送的XML 是格式良好,并且从fileinputstream正确解析,因为它有一个清晰的eof,但是在从未关闭的套接字inputstream解析时挂起。

客户端在发送XML后不会关闭流,因为它们希望通过套接字得到响应。

这是我的代码:

try (
    ServerSocket server = new ServerSocket(port);
    Socket sock = server.accept();
    InputStream in = sock.getInputStream(); ) {

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    DocumentBuilder db = dbf.newDocumentBuilder();
    db.setErrorHandler(MyErrorHandler);
    db.setEntityResolver(MyEntityResolver);
    // below hangs, waiting for stream to close I think
    Document doc = db.parse(in);

    // .. process document
    // .. send response
}

这是它挂在哪里的堆栈跟踪:

SocketInputStream.socketRead0(FileDescriptor, byte[], int, int, int) line: not available [native method]    
SocketInputStream.socketRead(FileDescriptor, byte[], int, int, int) line: 116   
SocketInputStream.read(byte[], int, int, int) line: 171 
SocketInputStream.read(byte[], int, int) line: 141  
XMLEntityManager$RewindableInputStream.read(byte[], int, int) line: 2919    
UTF8Reader.read(char[], int, int) line: 302 
XMLEntityScanner.load(int, boolean, boolean) line: 1895 
XMLEntityScanner.skipSpaces() line: 1685    
XMLDocumentScannerImpl$TrailingMiscDriver.next() line: 1371 
XMLDocumentScannerImpl.next() line: 602 
XMLDocumentScannerImpl(XMLDocumentFragmentScannerImpl).scanDocument(boolean) line: 505  
XIncludeAwareParserConfiguration(XML11Configuration).parse(boolean) line: 841   
XIncludeAwareParserConfiguration(XML11Configuration).parse(XMLInputSource) line: 770    
DOMParser(XMLParser).parse(XMLInputSource) line: 141    
DOMParser.parse(InputSource) line: 243  
DocumentBuilderImpl.parse(InputSource) line: 339    
DocumentBuilderImpl(DocumentBuilder).parse(InputStream) line: 121

谢谢你的建议。

1 回复 | 直到 6 年前

Ioannis Baourdos 6 年前

如果流足够小,可以放在内存中,那么不妨读取字节数组中的字节。如果它很大,你想和溪流一起工作,看看 Apache Commons IOUtils 这有效地为您提供了将inputstream复制到outputstream并在以后处理它的方法。这样,套接字流应该保持打开状态。

xtratic Rob 5 年前

我想我已经意识到一个很好的解决方案,我想我会和其他同舟共济的人分享。

与其使用原始套接字,不如使用netty构建套接字协议使用一个 XmlFrameDecoder 将消息帧化并将该帧的字节解析为文档。

public class Main {
    private static class MyXmlHandler extends ChannelInboundHandlerAdapter {

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            try (InputStream in = new ByteBufInputStream((ByteBuf) msg, true)) {
                Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(in);

                // prove that we got the document
                Transformer transformer = TransformerFactory.newInstance().newTransformer();
                transformer.setOutputProperty(OutputKeys.INDENT, "yes");
                StringWriter writer = new StringWriter();
                transformer.transform(new DOMSource(doc), new StreamResult(writer));
            }
        }
    }


    public static void main(String[] args) throws InterruptedException {
        final int PORT = 8080;

        EventLoopGroup parentGroup = new NioEventLoopGroup();
        EventLoopGroup childGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap server = new ServerBootstrap();
            server.group(parentGroup, childGroup).channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {

                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new XmlFrameDecoder(Integer.MAX_VALUE),
                                    new MyXmlHandler());
                        }
                    }).childOption(ChannelOption.SO_KEEPALIVE, true);

            ChannelFuture channel = server.bind(PORT).sync();
            channel.channel().closeFuture().sync();
        } finally {
            childGroup.shutdownGracefully();
            parentGroup.shutdownGracefully();
        }
    }
}