Question

几天前，我在不破坏NettyServer的情况下如何访问NettyClient发送的文件感到困扰。我在StackOverFlow上获得了解决方案，问题的详细信息是here。解决方案是，客户端在发送文件后关闭通道，而服务器通过channelInactive方法关闭文件输出流。主要代码如下。

ClientHandler

public class FileClientHandler extends ChannelInboundHandlerAdapter {

private int readLength = 128;

@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    sendFile(ctx.channel());
}

private void sendFile(Channel channel) throws IOException {
    File file = new File("C:\\Users\\xxx\\Desktop\\1.png");
    FileInputStream fis = new FileInputStream(file);
    BufferedInputStream bis = new BufferedInputStream(fis);

    ChannelFuture lastFuture = null;
    for (;;) {
        byte[] bytes = new byte[readLength];
        int readNum = bis.read(bytes, 0, readLength);
        if (readNum == -1) { // The end of the stream has been reached
            bis.close();
            fis.close();
            lastFuture = sendToServer(bytes, channel, 0);
            if(lastFuture == null) { // When our file is 0 bytes long, this is true
                channel.close();
            } else {
                lastFuture.addListener(ChannelFutureListener.CLOSE);
            }
            return;
        }
        lastFuture = sendToServer(bytes, channel, readNum);
    }
}

private ChannelFuture sendToServer(byte[] bytes, Channel channel, int length)
        throws IOException {
    return channel.writeAndFlush(Unpooled.copiedBuffer(bytes, 0, length));
}

}

ServerHandler

public class FileServerHandler extends ChannelInboundHandlerAdapter {

private File file = new File("C:\\Users\\xxx\\Desktop\\2.png");
private FileOutputStream fos;

public FileServerHandler() {
    try {
        if (!file.exists()) {
            file.createNewFile();
        } else {
            file.delete();
            file.createNewFile();
        }
        fos = new FileOutputStream(file);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Override
public void channelInactive(ChannelHandlerContext ctx) {
    System.out.println("I want to close fileoutputstream!");
    try {
        fos.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg)
        throws Exception {
    ByteBuf buf = (ByteBuf) msg;
    try {
        buf.readBytes(fos, buf.readableBytes());
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        buf.release(); // Should always be done, even if writing to the file fails
    }
}

}

如果现在我需要发送1万张图片，但是每张图片很小，例如1KB。我必须经常关闭然后建立频道。这是浪费很多资源的事情。如何仅关闭fileoutputstream但通道仍处于活动状态？

Answer 1

这只是一个想法，我尚未对其进行测试，但是您可以在发送文件的地方启动流，而不是通过自己的连接发送每个文件：

要发送的文件数（一次）
文件信息和内容（针对每个文件）
1. 文件大小
2. 文件名大小
3. 文件名
4. 文件内容（字节）

客户端看起来像这样：

public void sendFiles(Channel channel, File...files) {
    ByteBufAllocator allocator = PooledByteBufAllocator.DEFAULT;
    int fileCount = files.length;
    // Send the file count
    channel.write(allocator.buffer(4).writeInt(fileCount));
    // For each file
    Arrays.stream(files).forEach(f -> {         
        try {
            // Get the file content
            byte[] content = Files.readAllBytes(f.toPath());
            byte[] fileName = f.getAbsolutePath().getBytes(UTF8);
            // Write the content size, filename and the content
            channel.write(allocator.buffer(4 + content.length + fileName.length)
                    .writeInt(content.length)
                    .writeInt(fileName.length)
                    .writeBytes(fileName)
                    .writeBytes(content)
            );
        } catch (IOException e) {
            throw new RuntimeException(e); // perhaps do something better here.
        }           
    });
    // Flush the channel
    channel.flush();
}

在服务器端，您将需要稍微复杂一些的通道处理程序。我当时在想重播解码器。（Example here）

在该示例中，解码器将读取所有文件，然后转发到将接收 Upload 实例列表的下一个处理程序，但是您可以在每个接收到的文件之后将每个上载发送到管道中因此您不会分配太多内存。但目的是将所有文件发送到一个流中，而不必为每个文件进行连接/断开连接。

通过Netty发送文件后，是否只能关闭fileoutputstream但通道仍处于活动状态？

1 个答案: