Java - 通过套接字发送指向 BufferedImage 的对象

Question

我和一群朋友正在开发一个 Java 项目，我们需要一些有关通过套接字发送对象的帮助。

到目前为止，我们已经使用 ObjectOutputStream 和 ObjectInputStream 实现了通过套接字发送简单对象（整数、字符串等）。然而，我们今天遇到了一个巨大的问题（无论如何对我们来说都是巨大的^^）

我们有一个树结构，我们需要将其从一台PC发送到另一台PC。问题是，在该树的每个节点中，我们都有一个对 BufferedImage 的引用，并且它不可序列化。

今天研究了很多，发现可以使用ImageIO.write()通过socket的OutputStream发送one BufferedImage，但是这样不行因为我们不需要单独发送 BufferedImage 本身，而是发送它所在的整个树。

我们需要的是一种方法（如果存在）来序列化每个 BufferedImage，必要时将其转换为另一个类，同时创建树，并使树的每个节点引用新的可序列化类，以便可以将树发送为整个对象...

我们真的不关心性能，因为我们发送的树没有那么大（顶部有 10-15 个节点）。预先感谢您的帮助，对于糟糕的英语表示歉意。哦，这是为了……好吧，一种家庭作业，以防你想记住这一点:-)

谢谢！

Answer 1

在每个节点上，您可以使用 writeObject() 和 readObject() 检查 http://java.lang. sun.com/developer/technicalArticles/Programming/serialization/ 了解更多信息，

本质上它将成为

public Node implements Serializable{

    transient BufferedImage buff;//transient make it so it won't be written with defaultWriteObject (which would error)

    private void writeObject(ObjectOutputStream out)throws IOException{
        out.defaultWriteObject();
        //write buff with imageIO to out
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException{
        in.defaultReadObject();
        //read buff with imageIO from in
    }
}

Answer 2

您可以在客户端将 BufferedImage 转换为字节数组，然后作为普通字节数组发送，然后在服务器端从该字节数组创建 BufferedImage。下面是将 BufferedImage 转换为字节数组的代码，反之亦然。

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import javax.imageio.ImageIO;

public class ImageTest {

public static void main(String[] args) {

    try {

        byte[] imageInByte;
        BufferedImage originalImage = ImageIO.read(new File(
                "c:/darksouls.jpg"));

        // convert BufferedImage to byte array
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ImageIO.write(originalImage, "jpg", baos);
        baos.flush();
        imageInByte = baos.toByteArray();
        baos.close();

        // convert byte array back to BufferedImage
        InputStream in = new ByteArrayInputStream(imageInByte);
        BufferedImage bImageFromConvert = ImageIO.read(in);

        ImageIO.write(bImageFromConvert, "jpg", new File(
                "c:/new-darksouls.jpg"));

    } catch (IOException e) {
        System.out.println(e.getMessage());
    }
}
}

Answer 3

如果要使用对象流，可以将缓冲图像包装在实现 Serialized 的类中，并且具有字节数组属性（图像数据为字节数组）。您必须修改代码，将 BufferedImage 引用更改为 SerializedImage（类名示例）。

如果您这样做，您的类将被序列化并传输。

Answer 4

我对此进行了很多搜索，因为我需要通过套接字发送 bufferedImage 而不是文件，并发现您可以将 BufferedImage 转换为 ImageIcon，因此您可以使用 ObjectOutputStream 发送该对象，因为它是可序列化的，有其他方式但不适用于我的代码，希望这对某人有用。

Answer 5

这是一个扩展 BufferedImage 的简单类，将其图像数据序列化为 PNG。

因此，在代码中的任何地方都类似于：
BufferedImage bi = xyz();

您可以转换为：
SerializedBufferedImage bi = new SerializedBufferedImage(xyz());

SerializedBufferedImage 仍然是 BufferedImage，因此您仍然可以像以前一样绘制它并与其交互。而且该构造函数不会重新创建新的栅格，因此据我所知，它不会对性能/内存产生影响。

package com.pump.image;

import javax.imageio.ImageIO;
import java.awt.image.*;
import java.io.*;
import java.util.Hashtable;

/**
 * This is a <code>BufferedImage</code> that serializes its data as a PNG file.
 * There may be very slight lossiness after deserialization if this image
 * is translucent and the image type is TYPE_4BYTE_ABGR_PRE or TYPE_INT_ARGB_PRE.
 */
public class SerializableBufferedImage extends BufferedImage implements Externalizable {
    private static final long serialVersionUID = 1L;

    /**
     * Return a Hashtable of all known properties of a BufferedImage.
     * <p>
     * This returns a `Hashtable` instead of a `Map` to help accommodate
     * {@link BufferedImage#BufferedImage(ColorModel, WritableRaster, boolean, Hashtable)}
     */
    public static Hashtable<String, Object> getProperties(BufferedImage bi) {
        Hashtable<String, Object> returnValue = new Hashtable<>();
        if (bi != null) {
            String[] propNames = bi.getPropertyNames();
            if (propNames != null) {
                for (String key : propNames) {
                    returnValue.put(key, bi.getProperty(key));
                }
            }
        }
        return returnValue;
    }

    /**
     * Create a SerializableBufferedImage that stores data in the same raster as the
     * argument. If you paint to this SerializableBufferedImage, then you are also
     * altering the BufferedImage it is based on (and vice versa).
     */
    public SerializableBufferedImage(BufferedImage bi) {
        super(bi.getColorModel(), bi.getRaster(),
                    bi.isAlphaPremultiplied(), getProperties(bi));
        setAccelerationPriority(bi.getAccelerationPriority());
    }

    /**
     * This creates a 1x1 TYPE_BYTE_GRAY image This constructor only exists for serialization technicalities;
     * you do not need to call it.
     */
    public SerializableBufferedImage() {
        super(1, 1, BufferedImage.TYPE_BYTE_GRAY);
    }

    public SerializableBufferedImage(ColorModel cm, WritableRaster r,
                                boolean premultiplied, Hashtable<String, Object> properties) {
        super(cm, r, premultiplied, properties);
    }

    public SerializableBufferedImage(int width, int height, int imageType) {
        super(width, height, imageType);
    }

    private transient SerializableBufferedImage replacementImage;

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeInt(0);
        out.writeFloat(getAccelerationPriority());
        try (ByteArrayOutputStream byteOut = new ByteArrayOutputStream()) {
            ImageIO.write(this, "png", byteOut);
            out.writeObject(byteOut.toByteArray());
        }
    }

    @Override
    public void readExternal(ObjectInput in)
            throws IOException, ClassNotFoundException {
        int internalVersion = in.readInt();
        if (internalVersion == 0) {
            float accelerationPriority = in.readFloat();
            byte[] pngData = (byte[]) in.readObject();

            try (ByteArrayInputStream byteIn = new ByteArrayInputStream(pngData)) {
                BufferedImage bi = ImageIO.read(byteIn);
                replacementImage = new SerializableBufferedImage(bi);
                replacementImage.setAccelerationPriority(accelerationPriority);
            }
        } else {
            throw new UnsupportedEncodingException("This SerializableBufferedImage was encoded using a newer version.");
        }
    }

    @Serial
    private Object readResolve() {
        if (replacementImage != null) {
            return replacementImage;
        }
        return this;
    }
}