Serialisasyon sa ay isang mahalagang konsepto na tumatalakay sa pag-convert ng mga bagay sa isang byte stream upang maihatid ang mga bagay na java mula sa isang Java Virtual Machine patungo sa isa pa at muling likhain ang mga ito sa orihinal na form. Ipapila ko ang docket para sa artikulong ito sa ibaba:
- Ano ang Serialization sa Java?
- Bakit kailangan natin ng Serialization sa Java?
- Paano namin Serialize ang isang Bagay?
- Mga Kalamangan at Kalamangan ng Serialisasyon sa Java
- Praktikal na mga halimbawa ng Serialization sa Java
- Panlabas na Interface
- Pansamantalang Keyword
- Serial na Bersyon UID
- Mga Kontrobersiya ng Serialisasyon sa Java
- Pinakamahusay na Kasanayan habang ginagamit ang Serialization sa Java
Ano ang Serialization sa Java?
Serialisasyon sa Java ay ang proseso ng pag-convert ng Java code Bagay sa isang Byte Stream , upang ilipat ang Object Code mula sa isang Java Virtual machine sa isa pa at muling likhain ito gamit ang proseso ng Deserialization.
Bakit kailangan natin ng Serialization sa Java ?
Kailangan namin ng Serialisasyon para sa mga sumusunod na kadahilanan:
Komunikasyon : Ang Serialization ay nagsasangkot ng pamamaraan ng object serialization at paghahatid Nagbibigay-daan ito sa maraming mga system ng computer upang mag-disenyo, magbahagi at magpatupad ng mga bagay nang sabay-sabay.
Pag-cache : Ang ginugol na oras sa pagbuo ng isang bagay ay higit na inihambing sa oras na kinakailangan para sa de-serializing na ito. Ang serialisasyon ay nagpapaliit sa pagkonsumo ng oras ng pag-cache ang mga higanteng bagay.
Malalim na Kopya : Pag-clone ang proseso ay ginawang simple sa pamamagitan ng paggamit ng Serialization. Isang eksaktong replika ng isang bagay ay nakuha ngserializing ang object sa a byte array , at pagkatapos ay i-de-serializing ito.
Krus Pagsasabay sa JVM: Ang pangunahing bentahe ng Serialization ay itogumagana sa iba't ibang mga JVM na maaaring tumatakbo sa iba arkitektura o Mga Sistema ng Pagpapatakbo
Pagpupumilit: Ang Estado ng anumang bagay ay maaaring direktang nakaimbak sa pamamagitan ng paglalapat ng Serialization dito at nakaimbak sa a database upang ito ay maaaring kinuha sa paglaon.
Paano namin Serialize ang isang Bagay?
SA Object ng Java ay serializable kung at lamang kung ang klase nito o alinman sa mga magulang na klase nito ay nagpatupad ng alinman sa java . Ako . Serializable interface o subinterface nito, java.io.Externalizable.
Sa proseso ng Serialization, binago namin ang estado ng isang bagay sa isang byte stream upang mailipat ito mula sa isang JVM papunta sa isa pa at ibalik ang byte stream pabalik sa orihinal na object.
// Interface
package Serial1 import java.io.Serializable public class Ang empleyado ay nagpapatupad ng Serializable {private static final long serialVersionUID = 1L // Serial Version UID int id String name public Empleyado (int id, String name) {this.id = id this.name = pangalan }}// Serialize
package Serial1 import java.io. * class Persist {public static void main (String args []) {try {Empleyo emp1 = bagong empleyado (20110, 'John') Empleyado ng emp2 = bagong Empleyado (22110, 'Jerry') Empleyado ng emp3 = bagong Empleyado (20120, 'Sam') FileOutputStream fout = bagong FileOutputStream ('output.txt') ObjectOutputStream out = bagong ObjectOutputStream (fout) out.writeObject (emp1) out.writeObject (emp2) out.writeObject (emp3) out. flush () out.close () System.out.println ('Ang Serialization at Deserialization ay matagumpay na naisagawa')} catch (Exception e) {System.out.println (e)}}}Output:
Ang Serialization at Deserialization ay matagumpay na naisagawa
Deserialization : Ito ay ang pabalik na proseso ng Serialization kung saan ang Serialized Byte Stream ng isang bagay mula sa nagpadala ay muling nilikha sa pagtanggap ng pagtatapos.
// Deserialise
package Serial1 import java.io. * class Depersist {public static void main (String args []) {try {ObjectInputStream in = new ObjectInputStream (bagong FileInputStream ('output.txt')) Empleyado e1 = (Empleyado) sa.readObject ( ) Empleyado e2 = (empleyado) sa.readObject () empleyado e3 = (empleyado) sa.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)}}}Output:
20110 John
22110 Jerry
20120 Sam
Mga Kalamangan at Kalamangan ng Serialisasyon sa Java
Mga kalamangan:
kung paano baligtarin ang isang numero sa java
- Ang proseso ng serialisasyon ay a built-in tampok na hindi nangangailangan ng software ng third-party upang maisagawa ang Serialization
Ang pamamaraang Serialization ay napatunayan na simple at madali maintindihan
Ang pamamaraang serialisasyon ay unibersal at pamilyar dito ang mga developer mula sa iba't ibang background
Madaling gamitin ito at simpleng ipasadya
Serialized na mga stream ng data suportahan ang Pag-encrypt, Pag-compress, Pagpapatotoo at ligtas ang Java computing
Maraming kritikal na mga teknolohiya umaasa sa serialization.
Mga disadvantages:
Mga Bagay habang nagiging DeSerialization malutong at hindi sila sigurado na mabisa nang epektibo.
Ang mga Lumilipas na variable ay idineklara habang ang Serialization ay lumilikha ng memorya ng puwang, ngunit ang tagatayo ay hindi tinawag na nagreresulta sa pagkabigo sa pagsisimula ng mga pansamantalang variable na nagreresulta sa pagkakaiba-iba sa Karaniwang Daloy ng Java.
nagko-convert ng doble sa int java
Ang proseso ng serialization ay hindi mahusay sa mga tuntunin ng paggamit ng memorya.
Ang serialization ay hindi ginustong gamitin sa mga application na kinakailangan kasabay na pag-access nang hindi kinakailangan ng mga third-party na API , tulad ng Serialization ay hindi nag-aalok ng anumang mekanismo ng kontrol sa paglipat bawat bawat SE.
Nabigo na mag-alok ng pamamaraang serialization maayos na kontrol upang ma-access ang Mga Bagay.
Praktikal na mga halimbawa ng Serialization sa Java
Serialisasyon Gamit ang Pamana
Kaso - 1: Kung ang Superclass ay Serializable, kung gayon, bilang default, ang Subclass nito ay serializable din.
Sa kasong ito, ang subclass ay serializable bilang default kung ang superclass ay nagpapatupad ng Serializable Interface
package SerializationInheritance import java.io.FileInputStream import java.io.FileOutputStream import java.io.ObjectInputStream import java.io.ObjectOutputStream import java.io.Serializable class A ay nagpapatupad ng Serializable {int i public A (int i) {this.i = i}} pinalawak ng klase B A {int j public B (int i, int j) {super (i) this.j = j}} pampublikong klase Pagsubok {public static void main (String [] args) throws Exception {B b1 = bagong B (200,400) System.out.println ('i =' + b1.i) System.out.println ('j =' + b1.j) FileOutputStream fos = bagong FileOutputStream ('abc.ser') ObjectOutputStream oos = bagong ObjectOutputStream (fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('Ang bagay ay na-serialize') FileInputStream fis = bagong FileInputStream ('abc.ser') ObjectInputStream ois = bagong ObjectInputStream (fis) B b2 = (B) ois.readObject () ois.close () fis.close () System.out.println ('The object has been deserialized') System.out.println ('i = '+ b2.i) System.out.println (' j = '+ b2.j)}}Output:
j = 20
Ang bagay ay na-serialize
Ang bagay ay naging deserialized
i = 200
j = 400
Kaso - 2: Ang isang Subclass ay maaaring ma-serialize kung ipinapatupad nito ang Serializable Interface kahit na hindi ipatupad ng isang Superclass ang Serializable Interface.
Sa kasong ito, kung ang superclass ay hindi pagpapatupad ng Serializable Interface , kung gayon, ang mga bagay ng subclass maaaring manu-manong nai-serialize sa pamamagitan ng pagpapatupad ng Serializable Interface sa subclass.
package 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} public superclass () {i = 50 System.out.println ('Superclass konstruktor na tinatawag na')}} klase ng subclass ay nagpapalawak ng superclass ay nagpapatupad ng Serializable {int j public subclass (int i, int j) {super (i) this.j = j }} pagsubok sa pampublikong klase2 {pampublikong static void main (String [] args) ay nagtatapon ng Exception {subclass b1 = bagong subclass (10, 20) System.out.println ('i =' + b1.i) System.out.println ( 'j =' + b1.j) FileOutputStream fos = bagong FileOutputStream ('output.ser') ObjectOutputStream oos = bagong ObjectOutputStream (fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('Ang bagay ay na-serialize') FileInputStream fis = bagong FileInputStream ('output.ser') ObjectInputStream ois = bagong ObjectInputStream (fis) subclass b2 = (subclass) ois.readObject ( ) ois.close () fis.close () System.out.println ('Ang bagay ay na-deserialize') System.out.println ('i =' + b2.i) System.out.println ('j =' + b2.j)}}Ang bagay ay na-serialize
Tinawag ang taga-buo ng superclass
Ang bagay ay naging deserialized
i = 50
j = 20
Kaso - 3: Kung ang superclass ay serializable, ngunit hindi namin kailangan ang subclass upang ma-serialize.
Sa kasong ito, maiiwasan ang Serialization ng subclasssa pamamagitan ng pagpapatupad ng isulatObject () at readObject () mga pamamaraan sa subclass at kailangan itong magtapon NotSerializableException mula sa mga pamamaraang ito.
package 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.Serializable class Parent implements i Public Parent (int i) {this.i = i}} pinahaba ng klase ng magulang ang Magulang {int j public child (int i, int j) {super (i) this.j = j} pribadong walang bisa na magsulatObject (ObjectOutputStream out) nagtatapon Ang IOException {magtapon ng bagong NotSerializableException ()} pribadong void readObject (ObjectInputStream in) ay nagtatapon ng IOException {magtapon ng bagong NotSerializableException ()}} pagsubok sa klase sa publiko3 {public static void main (String [] args) throws Exception {bata b1 = bagong anak (100, 200) System.out.println ('i =' + b1.i) System.out.println ('j =' + b1.j) FileOutputStream fos = bagong FileOutputStream ('abc.ser') ObjectOutputStream oos = bagong ObjectOutputStream ( fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('Bagay ay nai-serialize ') FileInputStream fis = bagong FileInputStream (' abc.ser ') ObjectInputStream ois = bagong ObjectInputStream (fis) bata b2 = (bata) ois.readObject () ois.close () fis.close () System.out. println ('Object has been deserialized') System.out.println ('i =' + b2.i) System.out.println ('j =' + b2.j)}}Output:
i = 100
j = 200
Exception sa thread na 'pangunahing' java.io.NotSerializableException
sa SerializationInheritance.child.writeObject (test3.java:48)
sa sun.reflect.NativeMethodAccessorImpl.invoke0 (Katutubong Pamamaraan)
Serialisasyon Gamit ang isang Static Member
Ang Serialization ng static member field ay hindi pinapansin sa proseso ng serialization. Serialisasyon ayna nauugnay sa pinakabagong estado ng bagay. Samakatuwid, ang data lamang na nauugnay sa isang tukoy na halimbawa ng isang klase aynaka-serialize ngunit hindi ang patlang ng miyembro ng Static.
package stati import java.io. * class StaticSerial nagpapatupad Serializable {static int i = 100 public static void main (String ... ar) {StaticSerial ob = new StaticSerial () System.out.println ('Sa oras ng Serialization, may halaga ang static member: '+ i) subukan ang {FileOutputStream fos = bagong FileOutputStream (' F: File.ser ') ObjectOutputStream oos = bagong ObjectOutputStream (fos) oos.writeObject (ob) oos.close () i = 99 FileInputStream fis = bagong FileInputStream ('F: File.ser') ObjectInputStream ois = bagong ObjectInputStream (fis) ob = (StaticSerial) ois.readObject () ois.close () System.out.println ('Pagkatapos ng Deserialization, ang static member ay may halaga:' + i)} saluhin (Exception e) {System.out.println (e)}}}Output:
Sa oras ng Serialisasyon, ang static na miyembro ay may halaga: 100
Pagkatapos ng Deserialization, ang static member ay may halaga: 99
Panlabas na Interface
Ang Panlabas na Interface sa Java ay katulad ng Serialization ngunit ang pagkakaiba lamang ay may kakayahang mag-alok na-customize na serialization kung saan makakapagpasya sa mga bagay na mahihirapan sa stream.
Ang Externalizable interface ay magagamit sa java.io at nagbibigay ito ng dalawang pamamaraan:
- publikong walang bisa ang magsulat ng External (ObjectOutput out) nagtatapon ng IOException
- pampublikong walang bisa na readExternal (ObjectInput sa) ay nagtatapon ng IOException
Ang Mga pangunahing pagkakaiba sa pagitan ng Serialization at Externalizeable ay ang mga sumusunod:
Pagpapatupad : Externalizable Interface ay naglalabas ng gumagamit sa tahasang banggitin ang mga bagay na ma-serialize. Habang nasa Serialization Interface, ang lahat ng mga object at variable ay naka-serialize sa run-time.
Paraan : Ang panlabas na interface ay binubuo ng dalawang pamamaraan, katulad ng:
isulat ang Panlabas ()
readExternal ()
Samakatuwid, ang Serializable Interface ay hindi nagsasama ng anumang mga pamamaraan.
Proseso: Ang proseso ng Serialization sa Externalizable Interface ay nagbibigay pagpapasadya sa proseso ng serialization. Ngunit, ang Serialization Interface ay magbibigay ng default proseso ng serialization.
Pagpapaatras at Pagkontrol sa Paatras: Sinusuportahan ng Externalizable Interface ang Serialization anuman ang kontrol sa bersyon at ang problema lang ay dapat maging responsable ang gumagamit habang serializing ang Super Class. Sa kabilang banda, kinakailangan ng Serialization Interface ang parehong bersyon ng JVMs sa magkabilang dulo ngunit isinasama nito ang awtomatikong pagsasama ng lahat ng mga bagay at klase kabilang ang superclass.
Pampubliko na Walang-Arg Tagabuo: Mga pangangailangan ng Externalization Interface Pampubliko na Walang-Arg na Tagatayo upang maitaguyod muli ang naka-serialize na bagay. Habang ang Serialization Interface ay hindi nangangailangan ng No-Arg Cons konstruktor, sa halip ay gumagamit ito repleksyon upang maitaguyod muli ang naka-serial na bagay o klase.
package ext import java.io. * class Ang Demo ay nagpapatupad ng 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' subukan ang {FileOutputStream file = bagong FileOutputStream (filename) ObjectOutputStream out = bagong ObjectOutputStream (file) out .writeObject (object) out.close () file.close () System.out.println ('Na-serialize ang object')} catch (IOException ex) {System.out.println ('Ang IOException ay nahuli')} Demo object1 = null subukan ang {FileInputStream file = bagong FileInputStream (filename) ObjectInputStream in = bagong ObjectInputStream (file) object1 = (Demo) in.readObject () in.close () file.close () System.out.println ('Object has been deserialized ') System.out.println (' a = '+ object1.a) System.out.println (' b = '+ object1.b)} catch (IOException ex) {System.out.println (' Ang IOException ay nahuli ')} catch (ClassNotFoundException hal) {System.out .println ('Ang ClassNotFoundException ay nahuli')}}}Pansamantalang Keyword
Transient Keyword ay isang nakalaan na keyword sa Java. Ginagamit ito bilang a variable baguhin sa oras ng proseso ng Serialisasyon. Ang pagdedeklara ng variable na may Transient keyword ay iniiwasan ang variable mula sa pagiging Serialized.
kung paano gawin ang pagsubok sa database
Serial na Bersyon UID
Bago magsimula ang proseso ng serialization, ang bawat serializable na klase / bagay ay naiugnay sa a natatanging numero ng pagkakakilanlan na ibinigay ng JVM ng host machine. Ang Natatanging ID na ito ay tinawag Serial na Bersyon UID . Ang UID na ito ay ginagamit bilang isang pagkakakilanlan ng JVM ng pagtanggap ng pagtatapos upang kumpirmahing ang parehong bagay ay DeSerialized sa pagtanggap ng pagtatapos.
Mga Kontrobersiya ng Serialisasyon sa Java
Oracle's Nilalayon ng mga arkitekto na alisin ang Serialization mula sa Java dahil isinasaalang-alang nila ito bilang a Kakila-kilabot na Pagkakamali ng 1997 . Matapos ang masiksik na pagsasaliksik, nalaman ng mga developer sa Oracle ang ilang mga bahid sa disenyo ng pamamaraan ng Serialization na maaaring magbanta sa data.
Sa taong 1997,Sinabi ni Mark Reinhold - ' Nais naming tawagan ang serialization na 'ang regalong patuloy na nagbibigay,' at ang uri ng regalong patuloy nitong ibinibigay ay mga kahinaan sa seguridad. Marahil isang third ng lahat ng mga kahinaan ng Java ay may kasamang serialization na maaaring higit sa kalahati. Ito ay isang nakakagulat na mapagkukunan ng mga kahinaan, hindi pa mailakip ang mga kawalang-tatag. '.
May mga pagkakataong ang Serialization ay aalisin o papalitan sa paparating na mga pag-update ng Java at sa kabilang banda, para sa isang nagsisimula sa Java, Serialization ay hindi maaaring maging isang ideyalistiko na pagpipilian sa kanilang mga proyekto
Pinakamahusay na Kasanayan habang ginagamit ang Serialization sa Java
Ang mga sumusunod ay ilang pinakamahusay na kasanayan na kailangang sundin
- Inirerekumenda ang paggamit javadoc @ serial tag para sa denoting Serializable na mga patlang.
- Ang .maging ginustong extension na magamit para sa mga file na kumakatawan sa mga naka-serialize na bagay.
- Hindi inirerekumenda para sa anumang mga static o pansamantalang mga patlang na sumailalim default na serialization.
- Napahabang klase hindi dapat Serialized maliban kung ito ay sapilitan
- Mga Klase sa Loob dapat iwasan upang masangkot sa Serialization.
Sa pamamagitan nito, nakarating kami sa katapusan ng artikulong ito. Inaasahan kong naiintindihan mo ang mga pangunahing kaalaman ng Serialization sa Java, mga uri nito at pag-andar nito.
Suriin ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online na may isang network na higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo para sa mga mag-aaral at propesyonal na nais na maging isang Java Developer. Ang kurso ay dinisenyo upang bigyan ka ng isang panimula sa pag-program ng Java at sanayin ka para sa parehong core at advanced na mga konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring .
May tanong ba sa amin? Nabanggit ito sa seksyon ng mga komento ng artikulong 'Serialization in Java' na ito at babalikan ka namin sa lalong madaling panahon.