Serialisering i är ett viktigt koncept som handlar om konvertering av objekt till en byteflöde för att transportera java-objekten från en Java Virtual Machine till den andra och återskapa dem till den ursprungliga formen. Jag kommer att rada upp docket för den här artikeln enligt nedan:
- Vad är serialisering i Java?
- Varför behöver vi serialisering i Java?
- Hur serialiserar vi ett objekt?
- Fördelar och nackdelar med serialisering i Java
- Praktiska exempel på serialisering i Java
- Externiserbart gränssnitt
- Övergående nyckelord
- Seriell version UID
- Kontroverser om serialisering i Java
- Bästa praxis när du använder serialisering i Java
Vad är serialisering i Java?
Serialisering i Java är processen att konvertera Java-koden Objekt in i en Byte Stream , för att överföra objektkoden från en Java Virtual-maskin till en annan och återskapa den med hjälp av Deserialisering.
Varför behöver vi serialisering i Java ?
Vi behöver serialisering av följande skäl:
Kommunikation : Serialisering involverar proceduren för objekt serialisering och överföring. Detta gör det möjligt för flera datorsystem att designa, dela och köra objekt samtidigt.
Cachning : Tiden som krävs för att bygga ett objekt är mer jämfört med den tid som krävs för att avserialisera det. Serialisering minimerar tidsförbrukningen med cachning jätteobjekten.
Djup kopia : Kloning processen görs enkelt med hjälp av Serialization. En exakt kopia av ett objekt erhålls avserialiserar objektet till en byte-array och sedan avserialisera den.
Korsa JVM-synkronisering: Den största fördelen med Serialization är att denfungerar på olika JVM: er som kan köras på olika arkitekturer eller Operativsystem
Uthållighet: Vilket objekt som helst kan lagras direkt genom att applicera Serialization på det och lagras i en databas så att det kan vara hämtas senare.
Hur serialiserar vi ett objekt?
TILL Java-objekt är serierbart om och endast om dess klass eller någon av dess överordnade klasser implementerar antingen java . Jag . Serialiserbar gränssnitt eller dess undergränssnitt, java.io.Externaliserbar.
I Serialiseringsprocessen konverterar vi ett objekts tillstånd till en byte-ström så att det kan överföras från en JVM till den andra och återställa byte-strömmen till det ursprungliga objektet.
//Gränssnitt
paket Serial1 import java.io.Serialiserbar offentlig klass Anställd implementerar Serialiserbar {privat statisk slutlig lång serialVersionUID = 1L // Seriell version UID int id Strängnamn offentlig anställd (int id, Strängnamn) {this.id = id this.name = namn }}// Serialisera
paket Serial1 import java.io. * klass Persist {public static void main (String args []) {try {Employee emp1 = new Employee (20110, 'John') Employee emp2 = new Employee (22110, 'Jerry') Anställd emp3 = ny anställd (20120, 'Sam') FileOutputStream fout = ny FileOutputStream ('output.txt') ObjectOutputStream ut = ny ObjectOutputStream (fout) out.writeObject (emp1) out.writeObject (emp2) out.writeObject (emp3) ut. flush () out.close () System.out.println ('Serialisering och deserialisering har genomförts framgångsrikt')} fångst (Undantag e) {System.out.println (e)}}}Produktion:
Serialisering och deserialisering har genomförts
Deserialisering : Det är den omvända processen för Serialization där Serialized Byte Stream av ett objekt från avsändaren återskapas i den mottagande änden.
// Deserialisera
paket Serial1 import java.io. * klass Depersist {public static void main (String args []) {try {ObjectInputStream in = new ObjectInputStream (new FileInputStream ('output.txt')) Anställd e1 = (Anställd) in.readObject ( ) Anställd e2 = (Anställd) in.readObject () Anställd e3 = (Anställd) in.readObject () System.out.println (e1.id + '' + e1.name) System.out.println (e2.id + '' + e2.name) System.out.println (e3.id + '' + e3.name) in.close ()} catch (Exception e) {System.out.println (e)}}}Produktion:
20110 John
22110 Jerry
20120 Sam
Fördelar och nackdelar med serialisering i Java
Fördelar:
- Serialiseringsprocessen är en inbyggt funktion som inte kräver programvara från tredje part för att utföra serialisering
Serialiseringsförfarandet har visat sig vara enkel och lätt att förstå
Serialiseringsförfarandet är universell och utvecklare med olika bakgrund är bekanta med det
Det är lätt att använda och enkel att anpassa
Serialiserade dataströmmar stöd för kryptering, komprimering, autentisering och säker Java-databehandling
Det är många kritisk teknik förlitar sig på serialisering.
Nackdelar:
Objekt medan DeSerialization blir spröd och de är inte säker på att deSerialiseras effektivt.
De transienta variablerna som deklareras medan Serialization skapar minnesutrymme, men konstruktorn anropas inte vilket resulterar i felet i initialiseringen av transienta variabler vilket resulterar i en variation till Standard Java Flow.
Processen för serialisering är ineffektiv när det gäller minneutnyttjande.
Serialisering är inte att föredra för att användas i de applikationer som behöver samtidig åtkomst utan kravet på tredjeparts-API: er , eftersom Serialization inte erbjuder någon övergångskontrollmekanism per varje SE.
Serialiseringsförfarandet kan inte erbjudas finkornig kontroll för att komma åt objekt.
Praktiska exempel på serialisering i Java
Serialisering med arv
Fall - 1: Om Superclass är Serializable kan dess underklasser som standard också serialiseras.
I detta fall är underklass kan serieras som standard om superklass implementerar Serialiserbart gränssnitt
paket SerializationInheritance import java.io.FileInputStream import java.io.FileOutputStream import java.io.ObjectInputStream import java.io.ObjectOutputStream import java.io.Serialiserbar klass A implementerar Serialiserbar {int i public A (int i) {this.i = i}} klass B sträcker sig A {int j public B (int i, int j) {super (i) this.j = j}} public class Test {public static void main (String [] args) throw Exception {B b1 = ny B (200 400) System.out.println ('i =' + b1.i) System.out.println ('j =' + b1.j) FileOutputStream fos = ny FileOutputStream ('abc.ser') ObjectOutputStream oos = ny ObjectOutputStream (fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('Objektet har serialiserats') FileInputStream fis = new FileInputStream ('abc.ser') ObjectInputStream ois = ny ObjectInputStream (fis) B b2 = (B) ois.readObject () ois.close () fis.close () System.out.println ('Objektet har deserialiserats') System.out.println ('i = '+ b2.i) System.out.println (' j = '+ b2.j)}}Produktion:
j = 20
Objektet har serienummerats
Objektet har deserialiserats
jag = 200
j = 400
Fall - 2: En underklass kan serieseras om den implementerar Serializable Interface även om en Superclass inte implementerar Serializable Interface.
I det här fallet, om superklass genomför inte programmet Serialiserbart gränssnitt , sedan, föremålen för underklass kan manuellt serialiseras genom att implementera Serializable Interface i underklassen.
paket SerializationInheritance import java.io.FileInputStream import java.io.FileOutputStream import java.io.ObjectInputStream import java.io.ObjectOutputStream import java.io.Serialiserbar klass superklass {int i offentlig superklass (int i) {this.i = i} offentlig superklass () {i = 50 System.out.println ('Superclass-konstruktör kallas')}} klassunderklass utökar superklassimplement Serialiserbar {int j offentlig underklass (int i, int j) {super (i) this.j = j }} public class test2 {public static void main (String [] args) kastar undantag {subclass b1 = new subclass (10, 20) System.out.println ('i =' + b1.i) System.out.println ( 'j =' + b1.j) FileOutputStream fos = ny FileOutputStream ('output.ser') ObjectOutputStream oos = ny ObjectOutputStream (fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('Objektet har serialiserats') FileInputStream fis = new FileInputStream ('output.ser') ObjectInputStream ois = new ObjectInputStream (fis) subclass b2 = (subclass) ois.readObject ( ) ois.close () fis.close () System.out.println ('Objektet har deserialiserats') System.out.println ('i =' + b2.i) System.out.println ('j =' + b2.j)}}Objektet har serienummerats
Superklasskonstruktör ringde
Objektet har deserialiserats
i = 50
j = 20
Fall - 3: Om superklassen kan serienummeras, men vi behöver inte underklassen för att serienummeras.
I det här fallet kan serialisering av underklassen förhindrasgenom att genomföra writeObject () och readObject () metoder i underklassen och den måste kasta NotSerializableException från dessa metoder.
paket SerializationInheritance import java.io.FileInputStream import java.io.FileOutputStream import java.io.IOException import java.io.NotSerializableException import java.io.ObjectInputStream importerar java.io.ObjectOutputStream importerar java.io.Serializable klass i offentligt förälder (int i) {detta.i = i}} klassbarn utökar Förälder {int j offentligt barn (int i, int j) {super (i) this.j = j} privat ogiltigt skrivObject (ObjectOutputStream ut) kastar IOException {kasta nytt NotSerializableException ()} privat ogiltigt readObject (ObjectInputStream in) kastar IOException {kasta nytt NotSerializableException ()}} public class test3 {public static void main (String [] args) throw Exception {child b1 = new child (100, 200) System.out.println ('i =' + b1.i) System.out.println ('j =' + b1.j) FileOutputStream fos = new FileOutputStream ('abc.ser') ObjectOutputStream oos = new ObjectOutputStream ( fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('Object har serierats ') FileInputStream fis = new FileInputStream (' abc.ser ') ObjectInputStream ois = new ObjectInputStream (fis) child b2 = (child) ois.readObject () ois.close () fis.close () System.out. println ('Objekt har deserialiserats') System.out.println ('i =' + b2.i) System.out.println ('j =' + b2.j)}}Produktion:
jag = 100
j = 200
Undantag i tråden 'main' java.io.NotSerializableException
vid SerializationInheritance.child.writeObject (test3.java:48)
vid sun.reflect.NativeMethodAccessorImpl.invoke0 (Native Method)
Serialisering med hjälp av en statisk medlem
Serialisering av det statiska medlemsfältet ignoreras i serieprocessen. Serialisering ärrelaterat till objektets senaste tillstånd. Därför är endast data associerade med en specifik instans av en klassseriell men inte fältet Statisk medlem.
paket stati import java.io. * klass StaticSerial implementerar Serializable {static int i = 100 public static void main (String ... ar) {StaticSerial ob = new StaticSerial () System.out.println ('Vid tidpunkten för serialisering, statisk medlem har värde: '+ i) prova {FileOutputStream fos = new FileOutputStream (' F: File.ser ') ObjectOutputStream oos = new ObjectOutputStream (fos) oos.writeObject (ob) oos.close () i = 99 FileInputStream fis = new FileInputStream ('F: File.ser') ObjectInputStream ois = new ObjectInputStream (fis) ob = (StaticSerial) ois.readObject () ois.close () System.out.println ('Efter deserialisering har statisk medlem värde:' + i)} fånga (Undantag e) {System.out.println (e)}}}Produktion:
Vid tidpunkten för serialisering har statisk medlem ett värde: 100
Efter deserialisering har statisk medlem värde: 99
Externiserbart gränssnitt
De Externiserbart gränssnitt i Java liknar Serialization men den enda skillnaden är att den kan erbjuda anpassad serialisering där du får bestämma objekten som ska sores i strömmen.
Externiserbart gränssnitt finns i java.io och det ger två metoder:
- public void writeExternal (ObjectOutput out) kastar IOException
- public void readExternal (ObjectInput in) kastar IOException
De viktigaste skillnaderna mellan Serialization och Externalizeable är som följer:
vad är en substring i java
Genomförande : Externiserbart gränssnitt undantar användaren från uttryckligen nämna objekten som ska serieseras. I Serialization Interface serieras alla objekt och variabler i körning.
Metoder : Externiserbart gränssnitt består av två metoder, nämligen:
writeExternal ()
readExternal ()
Serialiserbart gränssnitt innehåller inga metoder.
Bearbeta: Serialiseringsprocessen i Externiserbart gränssnitt ger anpassning till serialiseringsprocessen. Men Serialization Interface kommer att ge standard serialiseringsprocessen.
Bakåtkompatibilitet och kontroll: Externiserbart gränssnitt stöder serialisering oavsett versionskontroll och det enda problemet är att användaren måste vara ansvarig när han klassificerar Super Class. Å andra sidan kräver Serialization Interface samma version av JVM: er i båda ändarna men den innehåller automatisk serialisering av alla objekt och klasser inklusive superklassen.
Offentliga konstruktörer utan arg: Externiseringsgränssnittsbehov Offentlig No-Arg Constructor för att rekonstruera det seriella objektet. Medan Serialization Interface inte kräver No-Arg Constructor, använder den istället reflexion för att rekonstruera det serieiserade objektet eller klassen.
paket extimport java.io. * klass Demo implementerar java.io.Serializable {public int a public String b public Demo (int a, String b) {this.a = a this.b = b}} class Test {public static void main (String [] args) {Demo object = new Demo (1, 'Welcome to Edureka') String filename = 'file.ser' try {FileOutputStream file = new FileOutputStream (filename) ObjectOutputStream out = new ObjectOutputStream (file) out .writeObject (object) out.close () file.close () System.out.println ('Object has been serialised')} catch (IOException ex) {System.out.println ('IOException is fångad')} Demo-objekt1 = null försök {FileInputStream-fil = ny FileInputStream (filnamn) ObjectInputStream i = ny ObjectInputStream (fil) object1 = (Demo) i.readObject () in.close () file.close () System.out.println ('Object has been deserialiserad ') System.out.println (' a = '+ object1.a) System.out.println (' b = '+ object1.b)} fångst (IOException ex) {System.out.println (' IOException fångas ')} fångst (ClassNotFoundException ex) {System.out .println ('ClassNotFoundException fångas')}}}Övergående nyckelord
Transient Keyword är ett reserverat nyckelord i Java. Det används som en variabel modifiera vid tidpunkten för serialiseringsprocessen. Att deklarera en variabel med Transient-nyckelord undviker att variabeln serialiseras.
Seriell version UID
Innan serialiseringsprocessen börjar kopplas varje serieiserbart klass / objekt till ett unikt identifieringsnummer tillhandahålls av värdmaskinens JVM. Detta unika ID kallas Seriell version UID . Detta UID används som en identifiering av den mottagande änden av JVM för att bekräfta att samma objekt deSerialiseras i den mottagande änden.
Kontroverser om serialisering i Java
Oracle's Arkitekter avser att ta bort Serialization från Java eftersom de anser det som ett Hemskt misstag 1997 . Efter hektisk forskning upptäckte utvecklarna på Oracle några brister i utformningen av Serialization-förfarandet som utgör ett hot mot data.
År 1997,Mark Reinhold säger - “ Vi kallar serialisering för ”gåvan som fortsätter att ge”, och den typ av gåva den fortsätter att ge är säkerhetsproblem. Förmodligen har en tredjedel av alla Java-sårbarheter involverat serialisering, det kan vara över hälften. Det är en förvånansvärt fecund källa till sårbarheter, för att inte tala om instabiliteter. ”.
Det finns chanser att Serialization skulle tas bort eller ersättas i kommande uppdateringar av Java och å andra sidan för en nybörjare i Java, Serialization kunde inte vara ett idealistiskt alternativ i sina projekt
Bästa praxis när du använder serialisering i Java
Följande är några bästa metoder som måste följas
- Det rekommenderas att användas javadoc @ seriell tagg för att beteckna Serializable-fält.
- De .att vara förlängning föredras för att användas för filer som representerar serieobjekt.
- Det rekommenderas inte att några statiska eller övergående fält genomgår standardserialisering.
- Utökbara klasser bör inte Serialiseras såvida det inte är det obligatorisk.
- Inre klasser bör undvikas för att vara delaktig i serialisering.
Med detta har vi kommit till slutet av den här artikeln. Jag hoppas att du har förstått grunderna för serialisering i Java, dess typer och dess funktioner.
Kolla in av Edureka, ett pålitligt online-lärande företag med ett nätverk av mer än 250 000 nöjda elever spridda över hela världen. Edurekas Java J2EE- och SOA-utbildning och certifieringskurs är utformad för studenter och yrkesverksamma som vill bli Java-utvecklare. Kursen är utformad för att ge dig ett försprång till Java-programmering och träna dig för både kärn- och avancerade Java-koncept tillsammans med olika Java-ramverk som Hibernate & Vår .
Har du en fråga till oss? Nämn det i kommentarsektionen i denna artikel 'Serialization in Java' så återkommer vi till dig så snart som möjligt.