Java可序列化对象到字节数组

299

假设我有一个可序列化的类AppMessage。

我想byte[]通过套接字将其传输到另一台计算机，从接收的字节重建该计算机。

我怎样才能做到这一点？

java  object  serialization 
— iTEgg
source
5
为什么那样byte[]？为什么不直接使用来直接将其写入套接字ObjectOutputStream并使用来进行读取呢ObjectInputStream？
— 罗恩侯爵
使用apache骆驼
— NOD的手
1
new ObjectMapper().writeValueAsBytes(JAVA_OBJECT_HERE)
— Asad Shakeel

Answers:

420

准备要发送的字节数组：

ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream out = null;
try {
  out = new ObjectOutputStream(bos);   
  out.writeObject(yourObject);
  out.flush();
  byte[] yourBytes = bos.toByteArray();
  ...
} finally {
  try {
    bos.close();
  } catch (IOException ex) {
    // ignore close exception
  }
}

从字节数组创建对象：

ByteArrayInputStream bis = new ByteArrayInputStream(yourBytes);
ObjectInput in = null;
try {
  in = new ObjectInputStream(bis);
  Object o = in.readObject(); 
  ...
} finally {
  try {
    if (in != null) {
      in.close();
    }
  } catch (IOException ex) {
    // ignore close exception
  }
}
— 泰勒·里斯
source
50
那不是我读的问题。在我看来，他的问题是如何将对象转换为byte []而不是如何发送它。
— 泰勒·莱斯
1
泰勒：是的，你说对了。我想将对象转换为byte []并进行传输。您还可以提供有关如何将此byte []转换为对象的代码吗？
— iTEgg
请始终关闭任何流以释放系统资源。（用代码编辑）
— LuckyMalaka 2011年
可以与无法实现可序列化的对象一起使用吗？
— 2011年
2
ObjectInput，ObjectOuput，ByteArrayOutputStream并且ByteArrayInputStream都实现了AutoCloseable接口，岂不是很好的做法，用它来避免遗漏错误关闭它们？（我不确定这是否是最佳实践，这就是我想知道的原因。）示例：try(ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutput out = new ObjectOutputStream(bos)){ /*Do stuff*/ }catch(IOException e){/*suppress exception*/}。它还消除了对该final子句及其附加内容的需要try-catch。
— 路德维格·赖达尔2015年
317

最好的方法是SerializationUtils从Apache Commons Lang中使用。

序列化：

byte[] data = SerializationUtils.serialize(yourObject);

反序列化： 

YourObject yourObject = SerializationUtils.deserialize(data)

如前所述，这需要Commons Lang库。可以使用Gradle导入：

compile 'org.apache.commons:commons-lang3:3.5'

Maven：

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.5</version>
</dependency>

Jar文件

这里提到的更多方法

或者，可以导入整个集合。引用此链接

— 乌里斯
source
56
增加了开销？此时也可以重新组装车轮。认真地讲，理解这种单一代码并减少可能的错误（例如不在正确的时间关闭流等）要容易得多。
— ALOToverflow
2
最好的方式，因为您使用提供给您的公共图书馆：1）健壮性：人们正在使用它，因此经过验证可以运行。2）它仅用1行就能完成上述操作（最受欢迎的答案），因此您的代码保持整洁。3）因为丹这么说。4）我只是在跟3 :-)开玩笑
— 劳伦斯（Lawrence）
2
不幸的是，该方法将输出大小限制为1024。如果需要将文件转换为字节流，最好不要使用它。
— Abilash
对于微服务，我不希望使用它。该库可能使它们的大小比直接方法大。
— Zon
要使用SerializationUtils.serialize(o)，您的对象需要这个implements Serializable
— TuGordoBello
90

如果您使用Java> = 7，则可以通过尝试使用资源来改善可接受的解决方案：

private byte[] convertToBytes(Object object) throws IOException {
    try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
         ObjectOutput out = new ObjectOutputStream(bos)) {
        out.writeObject(object);
        return bos.toByteArray();
    } 
}

反过来：

private Object convertFromBytes(byte[] bytes) throws IOException, ClassNotFoundException {
    try (ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
         ObjectInput in = new ObjectInputStream(bis)) {
        return in.readObject();
    } 
}
— 维克多·罗梅罗（VíctorRomero）
source
7

可以通过SerializationUtils完成，通过ApacheUtils的序列化和反序列化方法将对象转换为byte []，反之亦然，如@uris回答中所述。

通过序列化将对象转换为byte []：

byte[] data = SerializationUtils.serialize(object);

通过反序列化将byte []转换为对象：

Object object = (Object) SerializationUtils.deserialize(byte[] data)

单击链接下载org-apache-commons-lang.jar

通过单击以下命令来集成.jar文件：

FileName- > Open Medule Settings- >选择您的模块-> Dependencies- > Add Jar文件，您完成了。

希望这会有所帮助。

— 潘卡莉兰
source
4
永远不要添加这样的依赖关系，使用maven / gradle下载依赖关系并将其添加到构建路径中
— Daniel Bo
4

我还建议使用SerializationUtils工具。我想对@Abilash的错误评论提出公正的看法。该SerializationUtils.serialize()方法不局限于1024个字节，违背了这里的另一个答案。 

public static byte[] serialize(Object object) {
    if (object == null) {
        return null;
    }
    ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
    try {
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(object);
        oos.flush();
    }
    catch (IOException ex) {
        throw new IllegalArgumentException("Failed to serialize object of type: " + object.getClass(), ex);
    }
    return baos.toByteArray();
}

乍一看，您可能会认为这new ByteArrayOutputStream(1024)只会允许固定大小。但是，如果您仔细查看ByteArrayOutputStream，则会发现流在必要时会增长：

此类实现输出流，在该流中，数据被写入字节数组。缓冲区随着数据写入而自动增长。可以使用toByteArray()和 检索数据toString()。

— gzg_55
source
您可以添加相反的方法吗？所以byte []反对？我知道其他人也有这个功能，但是我非常喜欢您的回答，因此无法进行反序列化。我想避免在任何情况下都返回null。
— Tobias Kolb
2

另一个有趣的方法是 com.fasterxml.jackson.databind.ObjectMapper

byte[] data = new ObjectMapper().writeValueAsBytes(JAVA_OBJECT_HERE)

Maven依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>
— 阿萨德·沙基尔（Asad Shakeel）
source
2

如果您正在使用spring，spring-core中有一个util类。你可以做

import org.springframework.util.SerializationUtils;

byte[] bytes = SerializationUtils.serialize(anyObject);
Object object = SerializationUtils.deserialize(bytes);
— Supun Wijerathne
source
1

我想通过套接字将其作为byte []传输到另一台机器 

// When you connect
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
// When you want to send it
oos.writeObject(appMessage);

从接收到的字节重建它。

// When you connect
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
// When you want to receive it
AppMessage appMessage = (AppMessage)ois.readObject();
— 洛恩侯爵
source
1

春季框架 org.springframework.util.SerializationUtils

byte[] data = SerializationUtils.serialize(obj);
— xxg
source
0

Java 8+的代码示例：

public class Person implements Serializable {

private String lastName;
private String firstName;

public Person() {
}

public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
}

public void setFirstName(String firstName) {
    this.firstName = firstName;
}

public String getFirstName() {
    return firstName;
}

public String getLastName() {
    return lastName;
}

public void setLastName(String lastName) {
    this.lastName = lastName;
}

@Override
public String toString() {
    return "firstName: " + firstName + ", lastName: " + lastName;
}
}


public interface PersonMarshaller {
default Person fromStream(InputStream inputStream) {
    try (ObjectInputStream objectInputStream = new ObjectInputStream(inputStream)) {
        Person person= (Person) objectInputStream.readObject();
        return person;
    } catch (IOException | ClassNotFoundException e) {
        System.err.println(e.getMessage());
        return null;
    }
}

default OutputStream toStream(Person person) {
    try (OutputStream outputStream = new ByteArrayOutputStream()) {
        ObjectOutput objectOutput = new ObjectOutputStream(outputStream);
        objectOutput.writeObject(person);
        objectOutput.flush();
        return outputStream;
    } catch (IOException e) {
        System.err.println(e.getMessage());
        return null;
    }

}

}
— 穆罕默德·阿卜杜
source
0

如果您想要一个不错的无依赖项复制粘贴解决方案。抓取下面的代码。

例

MyObject myObject = ...

byte[] bytes = SerializeUtils.serialize(myObject);
myObject = SerializeUtils.deserialize(bytes);

资源

import java.io.*;

public class SerializeUtils {

    public static byte[] serialize(Serializable value) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();

        try(ObjectOutputStream outputStream = new ObjectOutputStream(out)) {
            outputStream.writeObject(value);
        }

        return out.toByteArray();
    }

    public static <T extends Serializable> T deserialize(byte[] data) throws IOException, ClassNotFoundException {
        try(ByteArrayInputStream bis = new ByteArrayInputStream(data)) {
            //noinspection unchecked
            return (T) new ObjectInputStream(bis).readObject();
        }
    }
}
— 伊利亚·加兹曼（Ilya Gazman）
source
0

如果任何人想在生产中使用此代码，这只是可接受答案的优化代码形式：

    public static void byteArrayOps() throws IOException, ClassNotFoundException{

    String str="123";
     byte[] yourBytes = null;

    // Convert to byte[]

    try(ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream out =  new ObjectOutputStream(bos);) {


      out.writeObject(str);
      out.flush();
      yourBytes = bos.toByteArray();

    } finally {

    }

    // convert back to Object

    try(ByteArrayInputStream bis = new ByteArrayInputStream(yourBytes);
            ObjectInput in = new ObjectInputStream(bis);) {

      Object o = in.readObject(); 

    } finally {

    }




}
— Nishant_Singh
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.