1. Serialisatie
2. Serialiseerbare interface
3. Voorbeeld van serialisatie
4. Voorbeeld van deserialisatie
5. Serialisatie met overerving
6. Externaliseerbare interface
7. Serialisatie en statisch gegevenslid

Serialisatie in Java is een mechanisme van het schrijven van de toestand van een object in een bytestroom . Het wordt voornamelijk gebruikt in Hibernate-, RMI-, JPA-, EJB- en JMS-technologieën.

De omgekeerde werking van serialisatie wordt genoemd deserialisatie waar bytestream wordt omgezet in een object. Het serialisatie- en deserialisatieproces is platformonafhankelijk. Dit betekent dat u een object op het ene platform kunt serialiseren en op een ander platform kunt deserialiseren.

Voor het serialiseren van het object noemen we de schrijfObject() methode van ObjectOutputStream klasse, en voor deserialisatie noemen we de leesObject() methode van ObjectInputStream klas.

Wij moeten de uitvoering ervan uitvoeren Serialiseerbaar interface voor het serialiseren van het object.

Voordelen van Java-serialisatie

Het wordt voornamelijk gebruikt om de status van objecten op het netwerk te volgen (dit staat bekend als marshalling).

java.io.Serializeerbare interface

Serialiseerbaar is een markeringsinterface (heeft geen gegevenslid en methode). Het wordt gebruikt om Java-klassen te 'markeren', zodat de objecten van deze klassen een bepaalde mogelijkheid kunnen krijgen. De Kloonbaar En Op afstand zijn ook markerinterfaces.

De Serialiseerbaar interface moet worden geïmplementeerd door de klasse waarvan het object moet worden gehandhaafd.

De klasse String en alle wrapper-klassen implementeren de java.io.Serializeerbaar standaardinterface.

Laten we het onderstaande voorbeeld bekijken:

Student.java

 import java.io.Serializable; public class Student implements Serializable{ int id; String name; public Student(int id, String name) { this.id = id; this.name = name; } } 

In het bovenstaande voorbeeld Student klasse implementeert een serialiseerbare interface. Nu kunnen de objecten ervan in stream worden omgezet. De hoofdklasse-implementatie van wordt getoond in de volgende code.

ObjectOutputStream-klasse

De klasse ObjectOutputStream wordt gebruikt om primitieve gegevenstypen en Java-objecten naar een OutputStream te schrijven. Alleen objecten die de java.io.Serializable-interface ondersteunen, kunnen naar streams worden geschreven.

Constructeur

Belangrijke methoden

tekenreeks vergelijken

ObjectInputStream-klasse

Een ObjectInputStream deserialiseert objecten en primitieve gegevens die zijn geschreven met behulp van een ObjectOutputStream.

Constructeur

Belangrijke methoden

Voorbeeld van Java-serialisatie

In dit voorbeeld gaan we het object serialiseren Student klasse uit bovenstaande code. De methode writeObject() van de klasse ObjectOutputStream biedt de functionaliteit om het object te serialiseren. We slaan de status van het object op in het bestand met de naam f.txt.

Persist.java

 import java.io.*; class Persist{ public static void main(String args[]){ try{ //Creating the object Student s1 =new Student(211,'ravi'); //Creating stream and writing the object FileOutputStream fout=new FileOutputStream('f.txt'); ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(s1); out.flush(); //closing the stream out.close(); System.out.println('success'); }catch(Exception e){System.out.println(e);} } } 

Uitgang:

 success 

Voorbeeld van Java-deserialisatie

Deserialisatie is het proces waarbij het object wordt gereconstrueerd vanuit de geserialiseerde staat. Het is de omgekeerde werking van serialisatie. Laten we een voorbeeld bekijken waarin we de gegevens van een gedeserialiseerd object lezen.

Deserialisatie is het proces waarbij het object wordt gereconstrueerd vanuit de geserialiseerde staat. Het is de omgekeerde werking van serialisatie. Laten we een voorbeeld bekijken waarin we de gegevens van een gedeserialiseerd object lezen.

Depersist.java

 import java.io.*; class Depersist{ public static void main(String args[]){ try{ //Creating stream to read the object ObjectInputStream in=new ObjectInputStream(new FileInputStream('f.txt')); Student s=(Student)in.readObject(); //printing the data of the serialized object System.out.println(s.id+' '+s.name); //closing the stream in.close(); }catch(Exception e){System.out.println(e);} } } 

Uitgang:

verschil tussen ijs en sneeuw

211 ravi 

Java-serialisatie met overerving (IS-A-relatie)

Als een klasse implementeert Serialiseerbare interface dan zullen al zijn subklassen ook serialiseerbaar zijn. Laten we het onderstaande voorbeeld bekijken:

SerializeISA.java

 import java.io.Serializable; class Person implements Serializable{ int id; String name; Person(int id, String name) { this.id = id; this.name = name; } } class Student extends Person{ String course; int fee; public Student(int id, String name, String course, int fee) { super(id,name); this.course=course; this.fee=fee; } } public class SerializeISA { public static void main(String args[]) { try{ //Creating the object Student s1 =new Student(211,'ravi','Engineering',50000); //Creating stream and writing the object FileOutputStream fout=new FileOutputStream('f.txt'); ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(s1); out.flush(); //closing the stream out.close(); System.out.println('success'); }catch(Exception e){System.out.println(e);} try{ //Creating stream to read the object ObjectInputStream in=new ObjectInputStream(new FileInputStream('f.txt')); Student s=(Student)in.readObject(); //printing the data of the serialized object System.out.println(s.id+' '+s.name+' '+s.course+' '+s.fee); //closing the stream in.close(); }catch(Exception e){System.out.println(e);} } } 

Uitgang:

 success 211 ravi Engineering 50000 

De klasse SerializeISA heeft het klasseobject Student geserialiseerd dat een uitbreiding is van de klasse Person die serialiseerbaar is. Eigenschappen van bovenliggende klassen worden overgenomen naar subklassen, dus als de bovenliggende klasse serialiseerbaar is, zou de subklasse dat ook zijn.

Java-serialisatie met aggregatie (HAS-A-relatie)

Als een klasse een verwijzing naar een andere klasse heeft, moeten alle verwijzingen serialiseerbaar zijn, anders wordt het serialisatieproces niet uitgevoerd. In dat geval, NotSerializableException wordt tijdens runtime gegooid.

Adres.java

 class Address{ String addressLine,city,state; public Address(String addressLine, String city, String state) { this.addressLine=addressLine; this.city=city; this.state=state; } } 

Student.java

 import java.io.Serializable; public class Student implements Serializable{ int id; String name; Address address;//HAS-A public Student(int id, String name) { this.id = id; this.name = name; } } 

Omdat Adres niet serialiseerbaar is, kunt u het exemplaar van de klasse Student niet serialiseren.

Opmerking: Alle objecten binnen een object moeten serialiseerbaar zijn.

Java-serialisatie met het statische gegevenslid

Als er een statisch gegevenslid in een klasse aanwezig is, wordt dit niet geserialiseerd omdat statisch het deel van de klasse is dat geen object is.

Werknemer.java

 class Employee implements Serializable{ int id; String name; static String company='SSS IT Pvt Ltd';//it won't be serialized public Student(int id, String name) { this.id = id; this.name = name; } } 

Java-serialisatie met array of verzameling

Regel: In het geval van een array of een verzameling moeten alle objecten van een array of een verzameling serialiseerbaar zijn. Als een object niet serialiseerbaar is, mislukt de serialisatie.

Externaliseerbaar in Java

De Externalizable-interface biedt de mogelijkheid om de status van een object in een gecomprimeerde bytestroom naar een bytestroom te schrijven. Het is geen markerinterface.

De Externalizable-interface biedt twee methoden:

public void writeExternal(ObjectOutput out) genereert IOException public void readExternal(ObjectInput in) genereert IOException

Tijdelijk Java-trefwoord

Als u geen gegevenslid van een klasse wilt serialiseren, kunt u deze als tijdelijk markeren.

Werknemer.java

 class Employee implements Serializable{ transient int id; String name; public Student(int id, String name) { this.id = id; this.name = name; } } 

Nu wordt id niet geserialiseerd, dus als u het object deserialiseert na serialisatie, krijgt u niet de waarde van id. Het retourneert altijd de standaardwaarde. In dat geval zal het 0 retourneren omdat het gegevenstype van id een geheel getal is.

Bezoek de volgende pagina voor meer details.

Seriële versieUID

Het serialisatieproces tijdens runtime koppelt een id aan elke serialiseerbare klasse die bekend staat als SerialVersionUID. Het wordt gebruikt om de afzender en ontvanger van het geserialiseerde object te verifiëren. De afzender en ontvanger moeten hetzelfde zijn. Om dit te verifiëren wordt SerialVersionUID gebruikt. De afzender en ontvanger moeten dezelfde SerialVersionUID hebben, anders OngeldigeKlasseException wordt gegenereerd wanneer u het object deserialiseert. We kunnen ook onze eigen SerialVersionUID declareren in de Serializable-klasse. Om dit te doen, moet u een veld SerialVersionUID maken en hieraan een waarde toekennen. Het moet van het lange type zijn, statisch en definitief. Er wordt voorgesteld om het veld serialVersionUID expliciet in de klasse te declareren en dit ook privé te maken. Bijvoorbeeld:

 private static final long serialVersionUID=1L; 

Nu ziet de Serializable-klasse er als volgt uit:

Werknemer.java

 import java.io.Serializable; class Employee implements Serializable{ private static final long serialVersionUID=1L; int id; String name; public Student(int id, String name) { this.id = id; this.name = name; } }