Question

在使用套接字通过网络传输图像时，我遇到了一个奇怪的问题：
当我使用OutputStream将图像写入一个套接字的ImageIO.write()并使用InputStream从另一个套接字的ImageIO.read()读取相同的图像时，我注意到，每个图像16个字节被发送超过阅读。为了能够连续发送多个图像，我必须在每次调用ImageIO.read()之后读取这些字节，以便不接收null，因为无法解析输入。

有谁知道，为什么会这样，这些字节是什么？

在这段代码中，我解决了这个问题：

public class Test implements Runnable
{
    public static final int COUNT = 5;

    public void run()
    {
        try(ServerSocket server = new ServerSocket(3040))
        {
            Socket client = server.accept();
            for(int i = 0; i < COUNT; i++)
            {
                final BufferedImage image = readImage(client.getInputStream());
                System.out.println(image);
            }
        } 
        catch(IOException e)
        {
            e.printStackTrace();
        }
    }

    private BufferedImage readImage(InputStream stream) throws IOException
    {
        BufferedImage image = ImageIO.read(stream);

        dontKnowWhy(stream);

        return image;
    }

    private void dontKnowWhy(InputStream stream) throws IOException
    {
        stream.read(new byte[16]);
    }

    public static void main(String... args)
    {
        new Thread(new Test()).start();

        try(Socket server = new Socket("localhost", 3040))
        {
            for(int i = 0; i < COUNT; i++)
            {
                BufferedImage image = new BufferedImage(300, 300, BufferedImage.TYPE_INT_ARGB); //
                int[] vals = new int[image.getWidth() * image.getHeight()];                     //
                Arrays.fill(vals, new Random().nextInt());                                      // Create random image
                image.setRGB(0, 0, image.getWidth(), image.getHeight(), vals, 0, 1);            //

                ImageIO.write(image, "png", server.getOutputStream());  //send image to server

                long time = System.currentTimeMillis();             //
                while(time + 1000 > System.currentTimeMillis());    //wait a second
            }
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }

    }
}

我很高兴有任何答案，已经感谢你了！

Answer 1

您看到的“额外”字节不会被读取，因为它们不需要正确解码图像（但是，它们很可能需要以所选的文件格式形成完全兼容的文件，因此它们是不只是随机的“垃圾”字节。）

对于任何给定的ImageIO插件，读取后流中剩余的字节数可以是0，16或任何其他数字。它可能取决于格式，编写它的编写者，读者，输入中的图像数量，文件中的元数据等。换句话说，依赖此行为将是一个错误。

解决此问题的简便方法是在每个图像前加上一个包含输出图像长度的字节数。这通常意味着您需要在客户端上缓冲响应，ByteArrayOutputStream（内存中）或FileOutputStream（磁盘）。

然后客户端需要读取图像的字节数，并确保在读取后跳过任何剩余的字节。这可以通过包装输入（参见FilterInputStream）并在内部跟踪字节数来完成。

（在将数据传递给ByteArrayInputStream之前，您还可以预先读取所有字节，并将它们包装在ImageIO.read()中，这样更简单，但内存缓冲更多。）

在此之后，客户端准备好通过读取新的字节数和新图像来重新开始。

如果你想在服务器上减少缓冲，另一种方法可能是实现像HTTP chunked transfer encoding之类的东西，你可以为每个图像发送到客户端的多个较小的块（块），每个块都有自己的前缀字节数。您需要特别处理每个图像的最后一个块，或者插入特殊的分隔符块来标记流的结尾或新流的开始。

下面的代码在服务器上实现缓冲方法，同时在客户端上使用直接读取。

服务器：

DataOutputStream stream = new DataOutputStream(server.getOutputStream());

ByteArrayOutputStream buffer = new ByteArrayOutputStream();
for (...) {
    buffer.reset();
    ImageIO.write(image, "png", buffer);

    stream.writeInt(buffer.size());
    buffer.writeTo(stream); // Send image to server
}

客户端：

DataInputStream stream = new DataInputStream(client.getInputStream());

for (...) {
    int size = stream.readInt();

    try (InputStream imageData = new SubStream(stream, size)) {
        return ImageIO.read(imageData);
    }
    // Note: imageData implicitly closed using try-with-resources
}

...

// Util class
private static final class SubStream extends FilterInputStream {
    private final long length;
    private long pos;

    public SubStream(final InputStream stream, final long length) {
        super(stream);

        this.length = length;
    }

    @Override
    public boolean markSupported() {
        return false;
    }

    @Override
    public int available() throws IOException {
        return (int) Math.min(super.available(), length - pos);
    }

    @Override
    public int read() throws IOException {
        if (pos++ >= length) {
            return -1;
        }

        return super.read();
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        if (pos >= length) {
            return -1;
        }

        int count = super.read(b, off, (int) Math.min(len, length - pos));

        if (count < 0) {
            return -1;
        }

        pos += count;

        return count;
    }

    @Override
    public long skip(long n) throws IOException {
        if (pos >= length) {
            return -1;
        }

        long skipped = super.skip(Math.min(n, length - pos));

        if (skipped < 0) {
            return -1;
        }

        pos += skipped;

        return skipped;
    }

    @Override
    public void close() throws IOException {
        // Don't close wrapped stream, just consume any bytes left
        while (pos < length) {
            skip(length - pos);
        }
    }
}

使用ImageIO发送图像后，从ImageIO读取图像时出现未知字节

1 个答案: