Mi a Serialization fogalma a Java-ban?

Ez a cikk átfogó megközelítésben segít a Java Serialization koncepciójának áttekintésében, valamint valós idejű példákkal a jobb megértés érdekében.

Serializálás egy fontos koncepció, amely az objektumok bájtfolyammá alakításával foglalkozik, hogy a java objektumokat az egyik Java virtuális gépről a másikra szállítsa, és újrateremtse őket az eredeti formára. Az alábbiakban sorba állítom a cikk dockját:



Mi a sorosítás a Java-ban?

Serializálás A Java a Java kód konvertálásának folyamata Tárgy ba be Bájtfolyam , az Objektumkód egyik Java virtuális gépről a másikra való átvitelére és a Deserializáció.



Serialization-in-Java-Edureka-Picture-1

Miért van szükségünk a sorosításra Java-ban ?

A sorosításra a következő okok miatt van szükségünk:



  • Kommunikáció : A szerializálás magában foglalja az objektum eljárását sorosítás és terjedés. Ez lehetővé teszi több számítógépes rendszer számára az objektumok egyidejű tervezését, megosztását és végrehajtását.

  • Gyorsítótár : Az objektum felépítéséhez felhasznált idő több, mint az objektum sorozatlanságának eltávolításához szükséges idő. A sorosítás minimalizálja az időfelhasználást gyorsítótár az óriási tárgyak.

  • Mély másolat : Klónozás a folyamat a Serialization használatával egyszerű. Pontos másolat egy tárgyat megszerezaz objektum sorosítása a bájt tömb , majd törli a sorosítást.



  • Kereszt JVM szinkronizálás: A szerializálás legfőbb előnye, hogykülönböző JVM-eken működik, amelyek különbözőeken futhatnak architektúrák vagy Operációs rendszer

  • Kitartás: Bármely objektum állapota közvetlenül tárolható a Serialization alkalmazással, és a adatbázis hogy legyen később visszakereshető.

Hogyan sorosítunk egy objektumot?

NAK NEK Java objektum van sorosítható csak akkor, ha osztálya vagy bármelyik szülőosztálya végrehajtja a Jáva . én . Sorosítható interfész vagy annak alfelülete, java.io.Externalizálható.

A sorosítási folyamat során egy objektum állapotát bájtfolyammá alakítjuk át, hogy az egyik JVM-ből a másikba átvihető legyen, és a bájtfolyamot visszaállítsuk az eredeti objektummá.

//Felület

Serial1 csomag importálása java.io.Serializable public class Employee implementals Serializable {private static final long serialVersionUID = 1L // Serial Version UID int id String name public Employee (int id, String name) {this.id = id this.name = name }}

// Serialize

javascript get tömb mérete
csomag Serial1 import java.io. * class Persist {public static void main (String args []) {try {Employee emp1 = new Employee (20110, 'John') Employee emp2 = new Employee (22110, 'Jerry') Employee emp3 = new Employee (20120, 'Sam') FileOutputStream fout = new FileOutputStream ('output.txt') ObjectOutputStream out = new ObjectOutputStream (fout) out.writeObject (emp1) out.writeObject (emp2) out.writeObject (emp3) out. flush () out.close () System.out.println ('A szerializálás és a deserializálás sikeresen végrehajtva')} catch (e kivétel) {System.out.println (e)}}}

Kimenet:

A sorozatosítás és a deszerializálás sikeresen végrehajtásra került

Deserializáció : A szerializálás fordított folyamata ez, amikor a küldő objektumának sorosított bájtos adatfolyamát a vevő végén újrateremtik.

// Deserialise

Serial1 csomag java.io. * osztály Depersist {public static void main (String args []) {próbálkozzon {ObjectInputStream in = új ObjectInputStream (új FileInputStream ('output.txt')) Employee e1 = (Employee) in.readObject ( ) Alkalmazott e2 = (Alkalmazott) in.readObject () Alkalmazott e3 = (Alkalmazott) in.readObject () System.out.println (e1.id + '' + e1.name) System.out.println (e2.id + '' + e2.név) System.out.println (e3.id + '' + e3.name) in.close ()} catch (e kivétel) {System.out.println (e)}}}

Kimenet:

20110 János
22110 Jerry

20120 Sam

A Java-sorozatosítás előnyei és hátrányai

Előnyök:

  • A sorosítási folyamat a beépített olyan szolgáltatás, amelyhez nem szükséges harmadik féltől származó szoftver a Serialization végrehajtásához
  • A sorosítási eljárás bebizonyosodott egyszerű és könnyen megérteni

  • A sorosítási eljárás az egyetemes és a különböző háttérrel rendelkező fejlesztők ismerik

  • Könnyen használható és egyszerűen testreszabható

  • Sorosított adatfolyamok támogatja a titkosítást, a tömörítést, a hitelesítést és biztonságos Java számítástechnika

  • Sokan vannak kritikus technológiák a szerializációra támaszkodva.

Hátrányok:

  • Tárgyak, miközben a DeSerialization válik törékeny és nem biztos, hogy hatékonyan lesznek DeSerializáltak.

  • A Serializálás során deklarált tranziens változók memóriaterületet hoznak létre, de a konstruktort nem hívják meg, ami a tranziens változók inicializálásának sikertelenségét eredményezi. a Standard Java Flow változata.

  • A sorosítás folyamata az hatástalan a memória kihasználtsága szempontjából.

  • A szerializálást nem előnyösebb használni azokban az alkalmazásokban, amelyekre szükség van egyidejű hozzáférés követelménye nélkül harmadik féltől származó API-k , mivel a szerializálás nem kínál átmeneti vezérlő mechanizmust minden SE-nként.

  • A sorosítási eljárást nem lehet felajánlani finomszemcsés kontroll az Objektumok eléréséhez.

Gyakorlati példák a Java-sorozatosításra

Serializálás öröklődéssel

1. eset: Ha a Szuperosztály osztályozható, akkor alapértelmezés szerint az Alosztályai is sorosíthatók.

Ebben az esetben a alosztály alapértelmezés szerint sorosítható, ha a szuperosztály végrehajtja a Serializálható felület

csomag SerializationInheritance import java.io.FileInputStream import java.io.FileOutputStream import java.io.ObjectInputStream import java.io.ObjectOutputStream import java.io.Serializable A osztály Serializable {int i public A (int i) {this.i = i}} B osztály kiterjeszti A {int j public B (int i, int j) {super (i) this.j = j}} public class Test {public static void main (String [] argumentum) dobja a {B b1 kivétel = new B (200,400) System.out.println ('i =' + b1.i) System.out.println ('j =' + b1.j) FileOutputStream fos = új FileOutputStream ('abc.ser') ObjectOutputStream oos = new ObjectOutputStream (fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('Az objektum sorosítva lett') FileInputStream fis = új FileInputStream ('abc.ser') ObjectInputStream ois = new ObjectInputStream (fis) B b2 = (B) ois.readObject () ois.close () fis.close () System.out.println ('Az objektum deserializálták') System.out.println ('i = '+ b2.i) System.out.println (' j = '+ b2.j)}}

Kimenet:

j = 20
Az objektum sorosítva lett
Az objektum deserializált
i = 200
j = 400

2. eset: Az alosztály akkor sorosítható, ha megvalósítja a Serializálható interfészt, még akkor is, ha egy Superclass nem valósítja meg a Serializálható Interfészt.

Ebben az esetben, ha a szuperosztály nem hajtja végre a Serializálható felület , akkor a alosztály manuálisan sorosítható a Serializable Interface alosztályba történő implementálásával.

csomag SerializationInheritance import java.io.FileInputStream import java.io.FileOutputStream import java.io.ObjectInputStream import java.io.ObjectOutputStream import java.io.Serializable class superclass {int i public superclass (int i) {this.i = i} nyilvános szuperosztály () {i = 50 System.out.println ('Superclass konstruktort hívnak')}} osztályú alosztály kiterjeszti a szuperosztály eszközeit Serializálható {int j nyilvános alosztály (int i, int j) {szuper (i) ezt.j = j }} public class test2 {public static void main (String [] args) dobja a Kivételt {alosztály b1 = új alosztály (10, 20) System.out.println ('i =' + b1.i) System.out.println ( 'j =' + b1.j) FileOutputStream fos = new FileOutputStream ('output.ser') ObjectOutputStream oos = új ObjectOutputStream (fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('Az objektum sorosított') FileInputStream fis = new FileInputStream ('output.ser') ObjectInputStream ois = new ObjectInputStream (fis) alosztály b2 = (alosztály) ois.readObject ( ) ois.close () fis.close () System.out.println ('Az objektum deserializált') System.out.println ('i =' + b2.i) System.out.println ('j =' + b2.j)}}

Az objektum sorosítva lett
Szuperklasszis konstruktőri hívott
Az objektum deserializált
i = 50
j = 20

3. eset: Ha a szuperosztály sorosítható, de nincs szükségünk az alosztály sorosítására.

Ebben az esetben az alosztály Serializálása megakadályozhatóvégrehajtásával writeObject () és readObject () módszereket az alosztályba, és dobnia kell NotSerializableException ezekből a módszerekből.

csomag SerializationInheritance import java.io.FileInputStream import java.io.FileOutputStream import java.io.IOException import java.io.NotSerializableException import java.io.ObjectInputStream import java.io.ObjectOutputStream import java.io.ObjectOutputStream import java.io.ObjectOutputStream import java.io.io.io Parancs i nyilvános Szülő (int i) {this.i = i}} osztályos gyermek meghosszabbítja Szülő {int j nyilvános gyermek (int i, int j) {szuper (i) ezt.j = j} private void writeObject (ObjectOutputStream out) dob IOException {dobja új NotSerializableException ()} private void readObject (ObjectInputStream be) dobja az IOException {dobja új NotSerializableException ()}} nyilvános osztály teszt3 {public static void main (karakterlánc [] args) dobja a kivétel {gyermek b1 = új gyermek (100 200) System.out.println ('i =' + b1.i) System.out.println ('j =' + b1.j) FileOutputStream fos = új FileOutputStream ('abc.ser') ObjectOutputStream oos = new ObjectOutputStream ( fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('Objektum sorosítva lett ') FileInputStream fis = new FileInputStream (' abc.ser ') ObjectInputStream ois = new ObjectInputStream (fis) child b2 = (gyermek) ois.readObject () ois.close () fis.close () System.out. println ('Az objektum deserializált') System.out.println ('i =' + b2.i) System.out.println ('j =' + b2.j)}}

Kimenet:

i = 100
j = 200
Kivétel a 'main' szálban java.io.NotSerializableException
itt: SerializationInheritance.child.writeObject (test3.java:48)
at sun.reflect.NativeMethodAccessorImpl.invoke0 (natív módszer)

Szerializálás statikus tag felhasználásával

A statikus tagmező serializálását a sorosítás során figyelmen kívül hagyják. A szerializálás azaz objektum legújabb állapotához kapcsolódik. Ennélfogva csak egy osztály adott példányához társított adatok vannaksorosított, de nem a Statikus tag mező.

csomag stati import java.io. * class StaticSerial megvalósítja a Serializable {static int i = 100 public static void main (String ... ar) {StaticSerial ob = new StaticSerial () System.out.println ('A sorozatosítás idején, statikus tag értéke: '+ i) próbálkozzon {FileOutputStream fos = new FileOutputStream (' F: File.ser ') ObjectOutputStream oos = new ObjectOutputStream (fos) oos.writeObject (ob) oos.close () i = 99 FileInputStream fis = új FileInputStream ('F: File.ser') ObjectInputStream ois = új ObjectInputStream (fis) ob = (StaticSerial) ois.readObject () ois.close () System.out.println ('A deserializálás után a statikus tagnak értéke van:' + i)} catch (e kivétel) {System.out.println (e)}}}

Kimenet:

A sorozatosítás idején a statikus tag értéke: 100
A deserializáció után a statikus tag értéke: 99

Külső felület

Az Külső felület a Java-ban hasonló a Serialization-hez, de az egyetlen különbség az, hogy képes kínálni testreszabott sorosítás ahol el kell döntenie a patakban felvetendő tárgyakat.

Az Externalizable felület a java.io fájlban érhető el, és két módszert kínál:

  • public void writeExternal (ObjectOutput out) dobja az IOException-t
  • public void readExternal (ObjectInput in) dobja az IOException-t

A legfontosabb különbségek a sorozatosítás és az externalizálhatóság között a következők:

  • Végrehajtás : Az externálható interfész kizárja a felhasználót kifejezetten említsd meg a sorozandó objektumokat. A Serialization Interface alatt az összes objektum és változó sorosítva van a futási idő.

  • Mód : A külsőleges felület két módszerből áll, nevezetesen:

    • writeExternal ()

    • readExternal ()

A Serializálható interfész nem tartalmaz semmilyen módszert.

  • Folyamat: A szerializációs folyamat a külsõ felületen biztosítja testreszabás a sorosítási folyamathoz. De a Serialization Interface biztosítja a alapértelmezett sorosítási folyamat.

  • Kompatibilitás és vezérlés visszafelé: A külsőleg használható interfész a sorosítást támogatja, függetlenül a verzióvezérlés és az egyetlen probléma az, hogy a felhasználónak kell felelnie a Super Class sorosítása közben. Másrészt a Serialization Interface megköveteli a ugyanaz a változat JVM-ek mindkét végén, de magában foglalja az összes objektum és osztály automatikus sorosítását, beleértve a szuperosztályt is.

  • Nyilvános No-Arg konstruktor: Külső interfész igényei Nyilvános No-Arg Konstruktor rekonstruálni a sorosított objektumot. Míg a Serialization Interface nem igényel No-Arg Constructor-t, ehelyett használja visszaverődés a sorosított objektum vagy osztály rekonstruálására.

package ext import java.io. * class Demo a 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 (objektum) out.close () file.close () System.out.println ('Az objektum sorosítva lett')} catch (IOException ex) {System.out.println ('IOException is catch')} Demo object1 = null try {FileInputStream fájl = új FileInputStream (fájlnév) ObjectInputStream in = új ObjectInputStream (fájl) object1 = (Demo) in.readObject () in.close () file.close () System.out.println ('Az objektum már deserializált ') System.out.println (' a = '+ object1.a) System.out.println (' b = '+ object1.b)} catch (IOException ex) {System.out.println (' IOException elkapva ')} catch (ClassNotFoundException ex) {System.out .println ('A ClassNotFoundException elfogva')}}}

Átmeneti kulcsszó

Átmeneti kulcsszó a fenntartott kulcsszó Java-ban. A-ként használják változó módosít a sorosítási folyamat idején. Ha egy változót átmeneti kulcsszóval deklarálunk, elkerülhető, hogy a változó Serialized legyen.

c ++ egyesítés rendezési algoritmus

Soros verzió UID

A sorosítási folyamat megkezdése előtt minden szerializálható osztály / objektum társul a egyedi azonosító szám a gazdagép JVM-je biztosítja. Ezt az egyedi azonosítót hívják Soros verzió UID . Ezt az UID-t a JVM a vevő vég azonosításaként használja annak megerősítésére, hogy ugyanazt az objektumot a DeSerialized a vevő végén végzi.

A szerializáció ellentmondásai a Java-ban

Az Oracle-é Az építészek el akarják távolítani a Serializációt a Java-ból, mivel azt a Borzalmas tévedés 1997-ből . Mozgalmas kutatás után az Oracle fejlesztői kiderítettek néhány hibát a Serialization eljárás tervezésében, amelyek veszélyt jelentenek az adatokra.

1997-benMark Reinhold kijelenti - Szeretjük a szerializációt „az ajándékozás, amelyet folyamatosan adunk”, és az ajándékozás típusa biztonsági rések. Valószínűleg az összes Java sebezhetőség egyharmada tartalmazott sorosítást, ez meghaladhatja a felét. Elképesztően termékeny forrása a sebezhetőségeknek, nem beszélve az instabilitásokról. ”

Vannak esélyek arra, hogy a sorosítást eltávolítsák vagy kicseréljék a Java közelgő frissítései során, másrészt a Java kezdőinek a Serialization nem tudta legyen idealista lehetőség projektjeikben

Legjobb gyakorlatok a Serialization Java használatakor

Az alábbiakban bemutatunk néhány követendő gyakorlatot

  • Használata ajánlott javadoc @ soros tag a Serializálható mezők jelölésére.
  • Az .lenni A kiterjesztést előnyben részesítik a sorosított objektumokat reprezentáló fájloknál.
  • Statikus vagy átmeneti mezőknek nem ajánlott átmenni alapértelmezett sorosítás.
  • Bővíthető osztályok nem szabad sorosítani, hacsak nem az kötelező.
  • Belső osztályok kerülni kell, hogy részt vegyen a sorosításban.

Ezzel a cikk végére értünk. Remélem, megértette a Java Serialization alapjait, típusait és funkcióit.

Nézze meg a az Edureka, egy megbízható online tanulási vállalat, amelynek több mint 250 000 elégedett tanulóval rendelkező hálózata elterjedt az egész világon. Az Edureka Java J2EE és SOA képzési és tanúsítási tanfolyamát olyan hallgatók és szakemberek számára tervezték, akik Java fejlesztők szeretnének lenni. A tanfolyamot úgy tervezték, hogy előrelépést nyújtson a Java programozásban, és betanítson mind az alapvető, mind a fejlett Java koncepciókra, különféle Java keretrendszerekkel együtt, mint például a Hibernate & Tavaszi .

Van egy kérdésünk? Említse meg a „Serialization in Java” cikk megjegyzés szakaszában, és a lehető leghamarabb kapcsolatba lépünk Önnel.