జావాలో సీరియలైజేషన్ భావన ఏమిటి?

లో సీరియలైజేషన్ జావా వస్తువులను ఒక జావా వర్చువల్ మెషిన్ నుండి మరొకదానికి రవాణా చేయడానికి మరియు వాటిని అసలు రూపానికి పున ate సృష్టి చేయడానికి వస్తువులను బైట్ స్ట్రీమ్‌గా మార్చడం గురించి వ్యవహరించే ముఖ్యమైన భావన. నేను ఈ వ్యాసం కోసం డాకెట్‌ను ఈ క్రింది విధంగా వరుసలో ఉంచుతాను:

• జావాలో సీరియలైజేషన్ అంటే ఏమిటి?
• జావాలో మనకు సీరియలైజేషన్ ఎందుకు అవసరం?
• మేము ఒక వస్తువును ఎలా సీరియలైజ్ చేస్తాము?
• జావాలో సీరియలైజేషన్ యొక్క ప్రయోజనాలు మరియు అప్రయోజనాలు
• జావాలో సీరియలైజేషన్ యొక్క ప్రాక్టికల్ ఉదాహరణలు
• బాహ్య ఇంటర్ఫేస్
• తాత్కాలిక కీవర్డ్
• సీరియల్ వెర్షన్ UID
• జావాలో సీరియలైజేషన్ యొక్క వివాదాలు
• జావాలో సీరియలైజేషన్ ఉపయోగిస్తున్నప్పుడు ఉత్తమ పద్ధతులు

జావాలో సీరియలైజేషన్ అంటే ఏమిటి?

సీరియలైజేషన్ జావాలో జావా కోడ్‌ను మార్చే ప్రక్రియ వస్తువు ఒక లోకి బైట్ స్ట్రీమ్ , ఆబ్జెక్ట్ కోడ్‌ను ఒక జావా వర్చువల్ మెషీన్ నుండి మరొకదానికి బదిలీ చేయడానికి మరియు ప్రాసెస్‌ను ఉపయోగించి దాన్ని పున ate సృష్టి చేయడానికి దేశీకరణ.

మనకు సీరియలైజేషన్ ఎందుకు అవసరం జావాలో ?

కింది కారణాల వల్ల మాకు సీరియలైజేషన్ అవసరం:

• కమ్యూనికేషన్ : సీరియలైజేషన్ వస్తువు యొక్క విధానాన్ని కలిగి ఉంటుంది సీరియలైజేషన్ మరియు ఒకరి నుండి ఒకరికి వ్యాధి ప్రబలడం. ఇది ఒకేసారి వస్తువులను రూపొందించడానికి, భాగస్వామ్యం చేయడానికి మరియు అమలు చేయడానికి బహుళ కంప్యూటర్ సిస్టమ్‌లను అనుమతిస్తుంది.

• కాషింగ్ : ఒక వస్తువును నిర్మించటానికి తీసుకునే సమయం డి-సీరియలైజ్ చేయడానికి అవసరమైన సమయంతో పోలిస్తే ఎక్కువ. సీరియలైజేషన్ ద్వారా సమయం వినియోగాన్ని తగ్గిస్తుంది కాషింగ్ పెద్ద వస్తువులు.

• డీప్ కాపీ : క్లోనింగ్ సీరియలైజేషన్ ఉపయోగించి ప్రక్రియ సులభం అవుతుంది. ఒక ఖచ్చితమైన ప్రతిరూపం ఒక వస్తువు ద్వారా పొందబడుతుందివస్తువును సీరియలైజ్ చేయడం a బైట్ శ్రేణి , ఆపై దానిని డి-సీరియలైజ్ చేస్తుంది.

  
  
  

• క్రాస్ JVM సమకాలీకరణ: సీరియలైజేషన్ యొక్క ప్రధాన ప్రయోజనం ఏమిటంటేవేర్వేరు JVM లలో పనిచేస్తుంది, అవి భిన్నంగా నడుస్తాయి నిర్మాణాలు లేదా ఆపరేటింగ్ సిస్టమ్స్

• పట్టుదల: ఏదైనా వస్తువు యొక్క స్థితిని దానిపై సీరియలైజేషన్ వర్తింపజేయడం ద్వారా నేరుగా నిల్వ చేయవచ్చు మరియు a డేటాబేస్ తద్వారా అది ఉంటుంది తరువాత పొందబడింది.

మేము ఒక వస్తువును ఎలా సీరియలైజ్ చేస్తాము?

TO జావా వస్తువు ఉంది సీరియలైజబుల్ ఒకవేళ మరియు దాని తరగతి లేదా దాని మాతృ తరగతులు ఏదైనా అమలు చేస్తే మాత్రమే జావా . నేను . సీరియలైజబుల్ ఇంటర్ఫేస్ లేదా దాని ఉప ఇంటర్‌ఫేస్, java.io.Externalizable.

సీరియలైజేషన్ ప్రక్రియలో, మేము ఒక వస్తువు యొక్క స్థితిని బైట్ స్ట్రీమ్‌గా మారుస్తాము, తద్వారా ఇది ఒక JVM నుండి మరొకదానికి బదిలీ చేయబడుతుంది మరియు బైట్ స్ట్రీమ్‌ను అసలు వస్తువుగా మార్చవచ్చు.

//ఇంటర్ఫేస్

ప్యాకేజీ సీరియల్ 1 దిగుమతి java.io.Serializable పబ్లిక్ క్లాస్ ఉద్యోగి సీరియలైజబుల్ {ప్రైవేట్ స్టాటిక్ ఫైనల్ లాంగ్ సీరియల్ వర్షన్ UID = 1L // సీరియల్ వెర్షన్ UID int id స్ట్రింగ్ పేరు పబ్లిక్ ఎంప్లాయీ (int id, స్ట్రింగ్ పేరు) {this.id = id this.name = name }}

// సీరియలైజ్ చేయండి

ప్యాకేజీ సీరియల్ 1 దిగుమతి java.io. * క్లాస్ పెర్సిస్ట్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {ప్రయత్నించండి {ఉద్యోగి emp1 = కొత్త ఉద్యోగి (20110, 'జాన్') ఉద్యోగి emp2 = కొత్త ఉద్యోగి (22110, 'జెర్రీ') ఉద్యోగి emp3 = క్రొత్త ఉద్యోగి (20120, 'సామ్') FileOutputStream fout = new FileOutputStream ('output.txt') ObjectOutputStream out = new ObjectOutputStream (fout) out.writeObject (emp1) out.writeObject (emp2) out.writeObject (emp3). ఫ్లష్ () out.close () System.out.println ('సీరియలైజేషన్ మరియు దేశీకరణ విజయవంతంగా అమలు చేయబడింది')} క్యాచ్ (మినహాయింపు ఇ) {System.out.println (ఇ)}}}

అవుట్పుట్:

సీరియలైజేషన్ మరియు దేశీకరణ విజయవంతంగా అమలు చేయబడుతుంది

దేశీకరణ : ఇది సీరియలైజేషన్ యొక్క రివర్స్ ప్రాసెస్, ఇక్కడ పంపినవారి నుండి ఒక వస్తువు యొక్క సీరియలైజ్డ్ బైట్ స్ట్రీమ్ స్వీకరించే చివరలో పున reat సృష్టిస్తుంది.

// దేశీయీకరణ

ప్యాకేజీ సీరియల్ 1 దిగుమతి java.io. * క్లాస్ డిపెర్సిస్ట్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {ప్రయత్నించండి {ఆబ్జెక్ట్ఇన్‌పుట్ స్ట్రీమ్ ఇన్ = న్యూ ఆబ్జెక్ట్ఇన్‌పుట్ స్ట్రీమ్ (కొత్త ఫైల్ఇన్‌పుట్ స్ట్రీమ్ ('output.txt')) ) ఉద్యోగి e2 = (ఉద్యోగి) in.readObject () ఉద్యోగి e3 = (ఉద్యోగి) 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 ()} క్యాచ్ (మినహాయింపు ఇ) {System.out.println (e)}}}

అవుట్పుట్:

20110 జాన్
22110 జెర్రీ

20120 సామ్

పూర్ణాంకానికి డబుల్ ఎలా వేయాలి

జావాలో సీరియలైజేషన్ యొక్క ప్రయోజనాలు మరియు అప్రయోజనాలు

ప్రయోజనాలు:

• సీరియలైజేషన్ ప్రక్రియ a అంతర్నిర్మిత సీరియలైజేషన్‌ను అమలు చేయడానికి మూడవ పార్టీ సాఫ్ట్‌వేర్ అవసరం లేని లక్షణం

• సీరియలైజేషన్ విధానం నిరూపించబడింది సరళమైనది మరియు సులభం అర్థం చేసుకోవడానికి

• సీరియలైజేషన్ విధానం సార్వత్రిక మరియు విభిన్న నేపథ్యం నుండి డెవలపర్లు దీనికి సుపరిచితులు

• ఇది ఉపయోగించడానికి సులభం మరియు అనుకూలీకరించడానికి సులభం

• సీరియలైజ్డ్ డేటా స్ట్రీమ్స్ మద్దతు ఎన్క్రిప్షన్, కంప్రెషన్, ప్రామాణీకరణ మరియు సురక్షిత జావా కంప్యూటింగ్

• అక్కడ చాలా ఉన్నాయి క్లిష్టమైన సాంకేతికతలు సీరియలైజేషన్ మీద ఆధారపడటం.

ప్రతికూలతలు:

• డీసెరియలైజేషన్ అయితే వస్తువులు పెళుసు మరియు అవి సమర్థవంతంగా డీసెరియలైజ్ చేయబడతాయని ఖచ్చితంగా తెలియదు.

• సీరియలైజేషన్ మెమరీ స్థలాన్ని సృష్టిస్తున్నప్పుడు ప్రకటించిన ట్రాన్సియెంట్ వేరియబుల్స్, కాని కన్స్ట్రక్టర్ అని పిలువబడదు, దీని ఫలితంగా అస్థిరమైన వేరియబుల్స్ ప్రారంభించడంలో వైఫల్యం ఏర్పడుతుంది. ప్రామాణిక జావా ప్రవాహానికి వైవిధ్యం.

• సీరియలైజేషన్ ప్రక్రియ అసమర్థ మెమరీ వినియోగం పరంగా.

• అవసరమైన అనువర్తనాల్లో సీరియలైజేషన్ ఉపయోగించడం మంచిది కాదు ఏకకాలిక ప్రాప్యత అవసరం లేకుండా మూడవ పార్టీ API లు , సీరియలైజేషన్ ప్రతి SE కి ఎటువంటి పరివర్తన నియంత్రణ యంత్రాంగాన్ని అందించదు.

• సీరియలైజేషన్ విధానం అందించడంలో విఫలమైంది చక్కటి-కణిత నియంత్రణ వస్తువులను యాక్సెస్ చేయడానికి.

జావాలో సీరియలైజేషన్ యొక్క ప్రాక్టికల్ ఉదాహరణలు

• వారసత్వాన్ని ఉపయోగించి సీరియలైజేషన్
• స్టాటిక్ సభ్యుడిని ఉపయోగించి సీరియలైజేషన్

వారసత్వాన్ని ఉపయోగించి సీరియలైజేషన్

కేసు - 1: సూపర్ క్లాస్ సీరియలైజబుల్ అయితే, అప్రమేయంగా, దాని సబ్‌క్లాసెస్ కూడా సీరియలైజబుల్.

ఈ సందర్భంలో, ది ఉపవర్గం ఉంటే డిఫాల్ట్‌గా సీరియలైజబుల్ సూపర్ క్లాస్ అమలు చేస్తోంది సీరియలైజబుల్ ఇంటర్ఫేస్

ప్యాకేజీ సీరియలైజేషన్ఇన్హెరిటెన్స్ దిగుమతి java.io.FileInputStream దిగుమతి java.io.FileOutputStream దిగుమతి java.io.ObjectInputStream దిగుమతి java.io.ObjectOutputStream దిగుమతి java.io.Serializable class A Serializable {int i public A (int i) i}} తరగతి B A {int j పబ్లిక్ B (int i, int j) {super (i) this.j = j}} పబ్లిక్ క్లాస్ టెస్ట్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) విసిరివేత మినహాయింపు {B b1 = క్రొత్త B (200,400) 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 ('ఆబ్జెక్ట్ సీరియలైజ్ చేయబడింది') FileInputStream fis = new FileInputStream ('abc.ser') ObjectInputStream = క్రొత్త ఆబ్జెక్ట్ఇన్‌పుట్ స్ట్రీమ్ (ఫిస్) బి బి 2 = (బి) ois.readObject () ois.close () fis.close () System.out.println ('ఆబ్జెక్ట్ దేశీయీకరించబడింది') System.out.println ('i = '+ b2.i) System.out.println (' j = '+ b2.j)}}

అవుట్పుట్:

j = 20
వస్తువు సీరియలైజ్ చేయబడింది
వస్తువు దేశీయీకరించబడింది
i = 200
j = 400

కేసు - 2: ఒక సూపర్ క్లాస్ సీరియలైజబుల్ ఇంటర్ఫేస్ను అమలు చేయకపోయినా, సీరియలైజబుల్ ఇంటర్ఫేస్ను అమలు చేస్తే సబ్ క్లాస్ సీరియలైజ్ చేయవచ్చు.

ఈ సందర్భంలో, ఉంటే సూపర్ క్లాస్ అమలు చేయడం లేదు సీరియలైజబుల్ ఇంటర్ఫేస్ , అప్పుడు, యొక్క వస్తువులు ఉపవర్గం సబ్‌క్లాస్‌లో సీరియలైజబుల్ ఇంటర్‌ఫేస్‌ను అమలు చేయడం ద్వారా మాన్యువల్‌గా సీరియలైజ్ చేయవచ్చు.

ప్యాకేజీ సీరియలైజేషన్ఇన్హెరిటెన్స్ దిగుమతి java.io.FileInputStream దిగుమతి java.io.FileOutputStream దిగుమతి java.io.ObjectInputStream దిగుమతి java.io.ObjectOutputStream దిగుమతి java.io.Serializable class superclass {int i public superclass (int i) {this.i = పబ్లిక్ సూపర్ క్లాస్ () {i = 50 System.out.println ('సూపర్ క్లాస్ కన్స్ట్రక్టర్' అని పిలుస్తారు)}} క్లాస్ సబ్ క్లాస్ సూపర్ క్లాస్ పనిముట్లను విస్తరిస్తుంది సీరియలైజబుల్ {int j పబ్లిక్ సబ్ క్లాస్ (int i, int j) {super (i) this.j = j class} పబ్లిక్ క్లాస్ టెస్ట్ 2 {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) విసిరిన మినహాయింపు {సబ్‌క్లాస్ బి 1 = కొత్త సబ్‌క్లాస్ (10, 20) System.out.println ('i =' + b1.i) System.out.println ( . . ) ois.close () fis.close () System.out.println ('ఆబ్జెక్ట్ దేశీయీకరించబడింది') System.out.println ('i =' + b2.i) System.out.println ('j =' + b2.j)}}

వస్తువు సీరియలైజ్ చేయబడింది
సూపర్ క్లాస్ కన్స్ట్రక్టర్ అని
వస్తువు దేశీయీకరించబడింది
i = 50
j = 20

కేసు - 3: సూపర్ క్లాస్ సీరియలైజ్ చేయగలిగితే, కానీ మనకు సబ్ క్లాస్ సీరియలైజ్ చేయవలసిన అవసరం లేదు.

ఈ సందర్భంలో, సబ్ క్లాస్ యొక్క సీరియలైజేషన్ నివారించవచ్చుఅమలు చేయడం ద్వారా writeObject () మరియు readObject () ఉపవర్గంలో పద్ధతులు మరియు అది విసిరేయాలి NotSerializableException ఈ పద్ధతుల నుండి.

ప్యాకేజీ సీరియలైజేషన్ఇన్హెరిటెన్స్ దిగుమతి java.io.FileInputStream దిగుమతి java.io.FileOutputStream దిగుమతి java.io.IOException దిగుమతి java.io.NotSerializableException దిగుమతి java.io.ObjectInputStream దిగుమతి java.io.ObjectOutputStream దిగుమతి java.io.ObjectOutputStream దిగుమతి i పబ్లిక్ పేరెంట్ (int i) {this.i = i}} క్లాస్ చైల్డ్ పేరెంట్ {int j పబ్లిక్ చైల్డ్ (int i, int j) {super (i) this.j = j} private void writeObject (ObjectOutputStream out) విసురుతాడు IOException {త్రో కొత్త NotSerializableException ()} ప్రైవేట్ శూన్యమైన రీడ్ ఆబ్జెక్ట్ (ఆబ్జెక్ట్ఇన్‌పుట్ స్ట్రీమ్ ఇన్) IOException విసిరివేస్తుంది new కొత్త NotSerializableException ()}} పబ్లిక్ క్లాస్ టెస్ట్ 3 {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) విసిరివేత మినహాయింపు {పిల్లల b1 = కొత్త పిల్లవాడు (100, 200. fos) oos.writeObject (b1) oos.close () fos.close () System.out.println ('ఆబ్జెక్ట్ సీరియలైజ్ చేయబడింది ') FileInputStream fis = new FileInputStream (' abc.ser ') ObjectInputStream ois = new ObjectInputStream (fis) child b2 = (child) ois.readObject () ois.close () fis.close () System.out. println ('ఆబ్జెక్ట్ దేశీయీకరించబడింది') System.out.println ('i =' + b2.i) System.out.println ('j =' + b2.j)}}

అవుట్పుట్:

i = 100
j = 200
థ్రెడ్ 'మెయిన్' లో మినహాయింపు java.io.NotSerializableException
SerializationInheritance.child.writeObject (test3.java:48) వద్ద
sun.reflect.NativeMethodAccessorImpl.invoke0 (స్థానిక పద్ధతి) వద్ద

స్టాటిక్ సభ్యుడిని ఉపయోగించి సీరియలైజేషన్

సీరియలైజేషన్ ప్రక్రియలో స్టాటిక్ మెంబర్ ఫీల్డ్ యొక్క సీరియలైజేషన్ విస్మరించబడుతుంది. సీరియలైజేషన్వస్తువు యొక్క తాజా స్థితికి సంబంధించినది. అందువల్ల, తరగతి యొక్క నిర్దిష్ట ఉదాహరణతో అనుబంధించబడిన డేటా మాత్రమేసీరియలైజ్ చేయబడింది కాని స్టాటిక్ మెంబర్ ఫీల్డ్ కాదు.

ప్యాకేజీ స్టాటి దిగుమతి java.io. * క్లాస్ స్టాటిక్ సీరియల్ సీరియలైజబుల్ {స్టాటిక్ ఇంటెంట్ i = 100 పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ ... ఆర్) {స్టాటిక్ సీరియల్ ఓబ్ = కొత్త స్టాటిక్ సీరియల్ () System.out.println ('సీరియలైజేషన్ సమయంలో, స్టాటిక్ సభ్యునికి విలువ ఉంది: '+ i) ప్రయత్నించండి {FileOutputStream fos = new FileOutputStream (' F: File.ser ') ObjectOutputStream oos = new ObjectOutputStream (fos) oos.writeObject (ob) oos.close () i = 99 FileInputStream new FileInputStream ('F: File.ser') ObjectInputStream ois = new ObjectInputStream (fis) ob = (StaticSerial) ois.readObject () ois.close () System.out.println ('దేశీకరణ తరువాత, స్థిర సభ్యుడికి విలువ ఉంది:' + i)} క్యాచ్ (మినహాయింపు ఇ) {System.out.println (ఇ)}}}

అవుట్పుట్:

సీరియలైజేషన్ సమయంలో, స్టాటిక్ సభ్యునికి విలువ: 100
దేశీకరణ తరువాత, స్టాటిక్ సభ్యునికి విలువ: 99

బాహ్య ఇంటర్ఫేస్

ది బాహ్య ఇంటర్ఫేస్ జావాలో సీరియలైజేషన్ మాదిరిగానే ఉంటుంది, కానీ ఒకే తేడా ఏమిటంటే అది అందించే సామర్థ్యం ఉంది అనుకూలీకరించిన సీరియలైజేషన్ స్ట్రీమ్‌లో గొంతు కోసే వస్తువులను మీరు నిర్ణయించుకోవాలి.

లినక్స్ సిస్టమ్ అడ్మినిస్ట్రేటర్ పాత్రలు మరియు బాధ్యతలు

బాహ్య ఇంటర్ఫేస్ java.io లో అందుబాటులో ఉంది మరియు ఇది రెండు పద్ధతులను అందిస్తుంది:

• public void writeExternal (ObjectOutput out) IOException విసురుతుంది
• పబ్లిక్ శూన్యమైన రీడ్ఎక్స్టెర్నల్ (ఆబ్జెక్ట్ఇన్పుట్ ఇన్) IOException విసురుతుంది

సీరియలైజేషన్ మరియు బాహ్యీకరణ మధ్య కీలక తేడాలు క్రింది విధంగా ఉన్నాయి:

• అమలు : బాహ్య ఇంటర్ఫేస్ వినియోగదారుని మినహాయించింది స్పష్టంగా సీరియలైజ్ చేయవలసిన వస్తువులను పేర్కొనండి. సీరియలైజేషన్ ఇంటర్ఫేస్లో ఉన్నప్పుడు, అన్ని వస్తువులు మరియు వేరియబుల్స్ సీరియలైజ్ చేయబడతాయి రన్-టైమ్.

• పద్ధతులు : బాహ్యపరచదగిన ఇంటర్ఫేస్ రెండు పద్ధతులను కలిగి ఉంటుంది, అవి:

  • writeExternal ()

  • readExternal ()

అయితే, సీరియలైజబుల్ ఇంటర్ఫేస్ ఏ పద్ధతులను కలిగి లేదు.

• ప్రక్రియ: బాహ్య ఇంటర్ఫేస్లో సీరియలైజేషన్ ప్రక్రియ అందిస్తుంది అనుకూలీకరణ సీరియలైజేషన్ ప్రక్రియకు. కానీ, సీరియలైజేషన్ ఇంటర్ఫేస్ అందిస్తుంది డిఫాల్ట్ సీరియలైజేషన్ ప్రక్రియ.

• వెనుకకు అనుకూలత మరియు నియంత్రణ: బాహ్య ఇంటర్ఫేస్ సంబంధం లేకుండా సీరియలైజేషన్కు మద్దతు ఇస్తుంది సంస్కరణ నియంత్రణ మరియు సూపర్ క్లాస్‌ను సీరియలైజ్ చేసేటప్పుడు వినియోగదారు బాధ్యత వహించాలి. మరోవైపు, సీరియలైజేషన్ ఇంటర్ఫేస్ అవసరం అదే వెర్షన్ రెండు చివర్లలోని JVM ల యొక్క కానీ ఇది సూపర్ క్లాస్‌తో సహా అన్ని వస్తువులు మరియు తరగతుల ఆటోమేటిక్ సీరియలైజేషన్‌ను కలిగి ఉంటుంది.

• పబ్లిక్ నో-ఆర్గ్ కన్స్ట్రక్టర్: బాహ్యీకరణ ఇంటర్ఫేస్ అవసరం పబ్లిక్ నో-ఆర్గ్ కన్స్ట్రక్టర్ సీరియలైజ్డ్ వస్తువును పునర్నిర్మించడానికి. సీరియలైజేషన్ ఇంటర్‌ఫేస్‌కు నో-ఆర్గ్ కన్స్ట్రక్టర్ అవసరం లేదు, బదులుగా అది ఉపయోగిస్తుంది ప్రతిబింబం సీరియలైజ్డ్ వస్తువు లేదా తరగతిని పునర్నిర్మించడానికి.

ప్యాకేజీ అదనపు దిగుమతి java.io. * క్లాస్ డెమో java.io.Serializable {public int a public string b public Demo (int a, string b) {this.a = a this.b = b}} క్లాస్ టెస్ట్ {పబ్లిక్ స్టాటిక్ void main (స్ట్రింగ్ [] అర్గ్స్) {డెమో ఆబ్జెక్ట్ = కొత్త డెమో (1, 'ఎడురేకాకు స్వాగతం') స్ట్రింగ్ ఫైల్ పేరు = 'file.ser' ప్రయత్నించండి {FileOutputStream file = new FileOutputStream (filename) ObjectOutputStream out = new ObjectOutputStream (file) .writeObject (ఆబ్జెక్ట్) out.close () file.close () System.out.println ('ఆబ్జెక్ట్ సీరియలైజ్ చేయబడింది')} క్యాచ్ (IOException ex) {System.out.println ('IOException పట్టుబడింది')} డెమో ఆబ్జెక్ట్ 1 = శూన్య ప్రయత్నం {FileInputStream file = new FileInputStream (filename) ObjectInputStream in = new ObjectInputStream (file) object1 = (Demo) in.readObject () in.close () file.close () System.out.println ('ఆబ్జెక్ట్ deserialized ') System.out.println (' a = '+ object1.a) System.out.println (' b = '+ object1.b)} క్యాచ్ (IOException ex) {System.out.println (' IOException పట్టుబడింది ')} క్యాచ్ (క్లాస్‌నోట్‌ఫౌండ్ఎక్సెప్షన్ ఉదా) {System.out .println ('క్లాస్‌నోట్‌ఫౌండ్ఎక్సెప్షన్ పట్టుబడింది')}}}

తాత్కాలిక కీవర్డ్

తాత్కాలిక కీవర్డ్ a రిజర్వు చేసిన కీవర్డ్ జావాలో. ఇది a గా ఉపయోగించబడుతుంది వేరియబుల్ సవరించండి సీరియలైజేషన్ ప్రక్రియ సమయంలో. తాత్కాలిక కీవర్డ్‌తో వేరియబుల్‌ను ప్రకటించడం వేరియబుల్‌ను సీరియలైజ్ చేయకుండా నివారిస్తుంది.

సీరియల్ వెర్షన్ UID

సీరియలైజేషన్ ప్రక్రియ ప్రారంభమయ్యే ముందు, ప్రతి సీరియలైజబుల్ క్లాస్ / ఆబ్జెక్ట్ a తో అనుబంధించబడుతుంది ప్రత్యేక గుర్తింపు సంఖ్య హోస్ట్ మెషిన్ యొక్క JVM చే అందించబడింది. ఈ ప్రత్యేక ID అంటారు సీరియల్ వెర్షన్ UID . ఈ UID స్వీకరించే ముగింపు యొక్క JVM చేత గుర్తింపుగా ఉపయోగించబడుతుంది, అదే వస్తువు స్వీకరించే చివరలో డీసెరియలైజ్ చేయబడిందని నిర్ధారించడానికి.

అనకొండ పైథాన్ ఎలా ఉపయోగించాలి

జావాలో సీరియలైజేషన్ యొక్క వివాదాలు

ఒరాకిల్ వాస్తుశిల్పులు జావా నుండి సీరియలైజేషన్‌ను తొలగించాలని భావిస్తున్నారు 1997 యొక్క భయంకరమైన తప్పు . తీవ్రమైన పరిశోధన తరువాత, ఒరాకిల్ వద్ద ఉన్న డెవలపర్లు సీరియలైజేషన్ విధానం రూపకల్పనలో కొన్ని లోపాలను కనుగొన్నారు, ఇది డేటాకు ముప్పుగా ఉంది.

1997 సంవత్సరంలో,మార్క్ రీన్హోల్డ్ ఇలా పేర్కొన్నాడు - “ మేము సీరియలైజేషన్‌ను ‘ఇవ్వడం కొనసాగించే బహుమతి’ అని పిలవాలనుకుంటున్నాము మరియు అది ఇచ్చే బహుమతి రకం భద్రతా లోపాలు. అన్ని జావా దుర్బలత్వాలలో మూడవ వంతు సీరియలైజేషన్ కలిగి ఉండవచ్చు, అది సగానికి పైగా ఉండవచ్చు. ఇది అస్థిరతలను చెప్పనవసరం లేదు, ఆశ్చర్యకరంగా బలహీనతలకు మూలం. ”.

జావా యొక్క రాబోయే నవీకరణలలో సీరియలైజేషన్ తొలగించబడుతుంది లేదా భర్తీ చేయబడే అవకాశాలు ఉన్నాయి మరియు మరోవైపు, జావాలో ఒక అనుభవశూన్యుడు, సీరియలైజేషన్ చేయలేని ఆదర్శవాద ఎంపిక వారి ప్రాజెక్టులలో

జావాలో సీరియలైజేషన్ ఉపయోగిస్తున్నప్పుడు ఉత్తమ పద్ధతులు

ఈ క్రిందివి అనుసరించాల్సిన కొన్ని ఉత్తమ పద్ధతులు

• ఇది సిఫార్సు చేయబడిన ఉపయోగం javadoc @ సీరియలైజబుల్ ఫీల్డ్‌లను సూచించడానికి సీరియల్ ట్యాగ్.
• ది .ఉండాలి సీరియలైజ్ చేసిన వస్తువులను సూచించే ఫైల్‌ల కోసం పొడిగింపు ఉపయోగించబడుతుంది.
• ఏదైనా స్థిరమైన లేదా అస్థిరమైన క్షేత్రాలకు లోనవ్వడం సిఫారసు చేయబడలేదు డిఫాల్ట్ సీరియలైజేషన్.
• విస్తరించదగిన తరగతులు అది తప్ప సీరియలైజ్ చేయకూడదు తప్పనిసరి.
• లోపలి తరగతులు సీరియలైజేషన్‌లో పాల్గొనకుండా ఉండాలి.

దీనితో, మేము ఈ వ్యాసం చివరికి వచ్చాము. జావాలో సీరియలైజేషన్ యొక్క ప్రాథమికాలు, దాని రకాలు మరియు దాని కార్యాచరణలను మీరు అర్థం చేసుకున్నారని నేను ఆశిస్తున్నాను.

చూడండి ప్రపంచవ్యాప్తంగా 250,000 కంటే ఎక్కువ సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది. వసంత .

మాకు ప్రశ్న ఉందా? ఈ “జావాలో సీరియలైజేషన్” వ్యాసంలోని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.