ObjectOutputStream in Java – schrijf Object naar Bestand

ObjectOutputStream in Java kan worden gebruikt om een object naar OutputStream te converteren. Het proces van het omzetten van een object naar een stream wordt serialisatie in Java genoemd. Zodra een object is omgezet naar Output Stream, kan het worden opgeslagen in een bestand of database, verzonden via het netwerk of gebruikt in socketverbindingen. Dus we kunnen FileOutputStream gebruiken om een Object naar een bestand te schrijven.

ObjectOutputStream

ObjectOutputStream maakt deel uit van Java IO-klassen en het doel ervan is ons een manier te bieden om een Java-object naar een stream te converteren. Wanneer we een instantie van ObjectOutputStream maken, moeten we de OutputStream opgeven die moet worden gebruikt. Deze OutputStream wordt vervolgens door ObjectOutputStream gebruikt om de objectstroom naar de onderliggende outputstream te leiden, bijvoorbeeld FileOutputStream.

Vereiste voor ObjectOutputStream

Het object dat we willen serialiseren, moet het java.io.Serializable-interface implementeren. Serializable is slechts een markeringsinterface en heeft geen abstracte methode die we moeten implementeren. We krijgen een java.io.NotSerializableException als de klasse het Serializable-interface niet implementeert. Iets zoals de onderstaande uitzonderings-stacktrace.

java.io.NotSerializableException: com.journaldev.files.EmployeeObject
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
	at com.journaldev.files.ObjectOutputStreamExample.main(ObjectOutputStreamExample.java:21)

Java ObjectOutputStream Voorbeeld om object naar bestand te schrijven

Laten we eens kijken naar een voorbeeld van java ObjectOutputStream om een object naar een bestand te schrijven. Daarvoor moeten we eerst een klasse hebben met enkele eigenschappen. Laten we een object maken dat we in het bestand zullen opslaan.

package com.journaldev.files;

import java.io.Serializable;

public class Employee implements Serializable {

	private static final long serialVersionUID = -299482035708790407L;

	private String name;
	private String gender;
	private int age;

	private String role;
	

// private transient String role;



	public Employee(String n) {
		this.name = n;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getRole() {
		return role;
	}

	public void setRole(String role) {
		this.role = role;
	}

	@Override
	public String toString() {
		return "Employee:: Name=" + this.name + " Age=" + this.age + " Gender=" + this.gender + " Role=" + this.role;
	}

}

Let op dat het niet verplicht is om getter/setter te hebben voor alle eigenschappen. Of om een no-argument constructor te hebben. Zoals je kunt zien, heeft het bovenstaande Employee-object geen getter/setter-methoden voor de “name”-eigenschap. Het heeft ook geen no-argument constructor. Hier is het programma dat laat zien hoe je een object naar een bestand schrijft in java met behulp van ObjectOutputStream.

package com.journaldev.files;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamExample {

	public static void main(String[] args) {
		Employee emp = new Employee("Pankaj");

		emp.setAge(35);
		emp.setGender("Male");
		emp.setRole("CEO");
		System.out.println(emp);
		
		try {
			FileOutputStream fos = new FileOutputStream("EmployeeObject.ser");
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			

// object naar bestand schrijven


			oos.writeObject(emp);
			System.out.println("Done");
			

// resources sluiten
			oos.close();
			fos.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

Hieronder wordt de uitvoer van het bovenstaande programma weergegeven. Als je je afvraagt wat de inhoud is van het bestand EmployeeObject.ser, dan is het een beetje onleesbaar en zoiets als hieronder.

��srcom.journaldev.files.Employee�����yyIageLgendertLjava/lang/String;Lnameq~
Lroleq~
xp#tMaletPankajtCEO

ObjectOutputStream met een transient

Als we niet willen dat een eigenschap van een object wordt omgezet naar de stream, moeten we het tijdelijke sleutelwoord gebruiken. Bijvoorbeeld, verander de rol eigenschap gewoon zoals hieronder en het zal niet worden opgeslagen.

private transient String role;

ObjectOutputStream en serialVersionUID

Heb je gemerkt dat de serialVersionUID gedefinieerd is in het Employee-object? Het wordt gebruikt door de klassen ObjectOutputStream en ObjectInputStream voor het schrijven en lezen van objectbewerkingen. Hoewel het niet verplicht is om dit veld te hebben, zou je het moeten behouden. Anders, als je je klasse wijzigt en dat heeft geen invloed op eerder geserialiseerde objecten, zal het beginnen te falen. Voor een gedetailleerde analyse, ga naar Serialisatie in Java. Als je je afvraagt of ons programma goed heeft gewerkt of niet, gebruik dan de onderstaande code om een object uit het opgeslagen bestand te lezen.

FileInputStream is = new FileInputStream("EmployeeObject.ser");
ObjectInputStream ois = new ObjectInputStream(is);
Employee emp = (Employee) ois.readObject();

ois.close();
is.close();
System.out.println(emp.toString());
//Output wordt "Werknemer:: Naam=Pankaj Leeftijd=35 Geslacht=Man Rol=CEO"

Dat is alles over java ObjectOutputStream en hoe het te gebruiken om het object naar het bestand te schrijven.

U kunt meer Java IO-voorbeelden bekijken vanuit onze GitHub Repository.

Referentie: API Doc