JSONలోకి సీరియలైజేషన్

"హాయ్, అమిగో!"

"హాయ్, ఎల్లీ!"

"మీరు ఇప్పటికే JSONకి పరిచయం చేయబడినందున, ఈ రోజు దాని గురించి మరింత మాట్లాడదాం."

"సరే. సాధారణంగా ఎక్కడ వాడతారు?"

"ఇది సాధారణంగా ఎలా పనిచేస్తుందో ఇక్కడ ఉంది. ఎవరైనా (క్లయింట్) జావా ప్రోగ్రామ్ (సర్వర్) నుండి డేటాను అభ్యర్థిస్తారు. ప్రోగ్రామ్ జావా ఆబ్జెక్ట్‌లను సృష్టించి, డేటాబేస్ నుండి సమాచారంతో వాటిని నింపుతుంది. ఆపై వాటిని అభ్యర్థి (క్లయింట్) ఫార్మాట్‌లోకి మారుస్తుంది. ) JSON వంటి వాటిని అర్థం చేసుకోవచ్చు మరియు వాటిని తిరిగి పంపుతుంది."

"జావాలో JSONతో ఎలా పని చేయాలో నేను మీకు చెప్తాను. ముఖ్యంగా, మనం కేవలం రెండు పనులు మాత్రమే చేయాలి: జావా ఆబ్జెక్ట్‌లను JSON ఫార్మాట్‌లోకి సీరియలైజ్ చేయడం మరియు JSON ఫార్మాట్ నుండి జావా ఆబ్జెక్ట్‌లను డీరియలైజ్ చేయడం."

"మరో మాటలో చెప్పాలంటే, JSON అనేది ఒక ప్రోగ్రామ్ నుండి మరొక ప్రోగ్రామ్‌కు సందేశాలు/డేటాను పంపడానికి ఒక ప్రమాణం. అలాంటి ప్రమాణాలు చాలా ఉన్నాయి. కానీ ప్రోగ్రామ్ జావాస్క్రిప్ట్‌లో వ్రాసినట్లయితే, ఇది సాధారణంగా JSONని ఉపయోగించడానికి ప్రయత్నిస్తుంది."

"సరే. నేను రెడీ."

"గ్రేట్. అప్పుడు ప్రారంభిద్దాం."

"మీకు ఇప్పటికే తెలిసినట్లుగా, జావా అంతర్నిర్మిత ప్రామాణిక సీరియలైజేషన్ సాధనాలను కలిగి ఉంది. కానీ అవి JSONకి మద్దతు ఇవ్వవు. కాబట్టి, మీరు ఒక వస్తువును JSONలోకి సీరియల్ చేయవలసి వస్తే, మీరు ఎలా చేయాలో తెలిసిన ప్రముఖ ఫ్రేమ్‌వర్క్‌లలో (లైబ్రరీలు) ఒకదాన్ని ఉపయోగించవచ్చు. ఇది చేయి."

"ఈ విభిన్న ఫ్రేమ్‌వర్క్‌ల మధ్య తేడా ఏమిటి?"

"అవి సాధారణంగా వాటి సంక్లిష్టత స్థాయికి భిన్నంగా ఉంటాయి: చాలా ప్రాథమిక అంశాలను మాత్రమే చేయగల ఫ్రేమ్‌వర్క్‌లు ఉన్నాయి, కానీ అవి చాలా చిన్నవి మరియు సరళమైనవి. ఇంకా చాలా ఎక్కువ చేయగల పెద్ద కాంప్లెక్స్ ఫ్రేమ్‌వర్క్‌లు ఉన్నాయి."

"జాక్సన్ అత్యంత జనాదరణ పొందిన ఫ్రేమ్‌వర్క్‌లలో ఒకటి. మేము JSONతో ఎలా పని చేయాలో చూసేటప్పుడు మేము దానిని ఉదాహరణగా ఉపయోగిస్తాము."

"మొదట, మీరు ఈ ఫ్రేమ్‌వర్క్‌ని డౌన్‌లోడ్ చేసి, మీ ప్రాజెక్ట్‌కి జోడించాలి. మీరు దీన్ని నేరుగా IntelliJ IDEAలో చేయాలి. మీరు ఈ లింక్‌ని ఉపయోగించి ఫ్రేమ్‌వర్క్‌ని డౌన్‌లోడ్ చేసుకోవచ్చు ."

"పూర్తి."

"గ్రేట్. లెట్స్ క్యారీ ఆన్, అప్పుడు."

"JAva ఆబ్జెక్ట్‌ను JSONలోకి మార్చడం అనేది దానిని సీరియలైజ్ చేసినంత సులభం. దీన్ని చేయడానికి, ఒక ప్రత్యేక ObjectMapper క్లాస్ (com.fasterxml.jackson.databind.ObjectMapper) ఉంది."

"నేను మీకు పని చేసే ఉదాహరణను చూపుతాను, ఆపై మేము దానిని విశ్లేషిస్తాము:"

public static void main(String[] args) throws IOException
{
 // Create an object to be serialized into JSON
 Cat cat = new Cat();
 cat.name = "Missy";
 cat.age = 5;
 cat.weight = 4;

 // Write the result of the serialization to a StringWriter
 StringWriter writer = new StringWriter();

 // This is the Jackson object that performs the serialization
 ObjectMapper mapper = new ObjectMapper();

 // And here's the serialization itself: the first argument is where, and the second is what
 mapper.writeValue(writer, cat);

 // Convert everything written to the StringWriter into a String
 String result = writer.toString();
 System.out.println(result);
}

@JsonAutoDetect
class Cat
{
 public String name;
 public int age;
 public int weight;
Cat(){}
}

{"name":"Missy", "age":5, "weight":4}

"ఇది ఎలా పని చేస్తుందో ఇక్కడ ఉంది:"

"4-7 లైన్లలో, మేము క్యాట్ ఆబ్జెక్ట్‌ని సృష్టించాము మరియు దానిని డేటాతో నింపుతాము."

"10వ పంక్తిలో, మేము ఒక రైటర్ ఆబ్జెక్ట్‌ను సృష్టిస్తాము, అక్కడ మేము ఆబ్జెక్ట్ యొక్క JSON-స్ట్రింగ్ ప్రాతినిధ్యాన్ని వ్రాస్తాము."

"13వ పంక్తిలో, మేము ఆబ్జెక్ట్‌మ్యాపర్ ఆబ్జెక్ట్‌ని సృష్టిస్తాము, అది మొత్తం సీరియలైజేషన్‌ను నిర్వహిస్తుంది."

"16వ పంక్తిలో, మేము రచయితకు పిల్లి వస్తువు యొక్క JSON ప్రాతినిధ్యాన్ని వ్రాస్తాము ."

"19-20 లైన్లలో, మేము స్క్రీన్‌పై ఫలితాన్ని ప్రదర్శిస్తాము."

"ప్రతిదీ చాలా సరళంగా కనిపిస్తోంది. జావాలో స్థానిక సీరియలైజేషన్ కంటే కష్టం కాదు."

"డీరియలైజేషన్ ఎలా ఉంటుంది?"

"ఇది దాదాపు అదే, కేవలం చిన్నది:"

public static void main(String[] args) throws IOException
{
 String jsonString = "{ \"name\":\"Missy\", \"age\":5, \"weight\":4}";
 StringReader reader = new StringReader(jsonString);

 ObjectMapper mapper = new ObjectMapper();

 Cat cat = mapper.readValue(reader, Cat.class);
}

@JsonAutoDetect
class Cat
{
 public String name;
 public int age;
 public int weight;

 Cat() { }
}

"ఇది ఇంకా సులభం. మేము ఆబ్జెక్ట్‌మ్యాపర్‌ని తీసుకుంటాము మరియు దానిని JSONతో ఒక స్ట్రింగ్ లేదా స్ట్రింగ్‌రీడర్‌ని పాస్ చేస్తాము, అలాగే డీరియలైజ్ చేయాల్సిన ఆబ్జెక్ట్ యొక్క క్లాస్‌ను పాస్ చేస్తాము. ఆపై మనం రీడ్‌వాల్యూ పద్ధతిని పిలుస్తాము మరియు అవుట్‌పుట్‌గా మనకు రెడీమేడ్ జావా ఆబ్జెక్ట్ లభిస్తుంది మొత్తం డేటా."

"సరే, అది సరిగ్గా జావాలో డీరియలైజేషన్ లాంటిది."

"దాదాపు. JSON నుండి సీరియల్ చేయబడిన లేదా డీరియలైజ్ చేయబడిన వస్తువులపై అనేక అవసరాలు ఉన్నాయి:"

" 1)  ఫీల్డ్‌లు తప్పనిసరిగా కనిపించాలి: అవి పబ్లిక్‌గా ఉండాలి లేదా గెట్టర్‌లు మరియు సెట్టర్‌లను కలిగి ఉండాలి"

" 2)  తప్పనిసరిగా డిఫాల్ట్ కన్స్ట్రక్టర్ ఉండాలి (పారామితులు లేనిది)"

"నేను చూస్తున్నాను. అది చాలా ఆశ్చర్యం కలిగించదు. కానీ జావా ప్రతిదీ, ప్రైవేట్ ఫీల్డ్‌లను కూడా సీరియల్ చేసింది."

"సరే, అది జావా. ఇది దాచిన డేటాకు ప్రాప్యతను కలిగి ఉంది. మీరు మీ నుండి దాచలేరు."

"ఇక్కడ మూడవ అంశం ఉంది. మీరు క్యాట్ క్లాస్‌లో @JsonAutoDetect ఉల్లేఖనాన్ని గమనించారని నేను ఆశిస్తున్నాను?"

"అవును. అదేమిటి అని అడగబోతున్నాను."

"ఇది ఒక ఉల్లేఖనం: జాక్సన్ ఫ్రేమ్‌వర్క్ కోసం హౌస్ కీపింగ్ సమాచారం. సరైన ఉల్లేఖనాలను ఉపయోగించడం ద్వారా, మీరు JSONలోకి సీరియలైజేషన్ ఫలితాలపై చాలా సరళమైన నియంత్రణను కలిగి ఉంటారు."

"కూల్! ఎలాంటి ఉల్లేఖనాలు ఉన్నాయి?"

"ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి:"

"ఎంత ఇంటరెస్టింగ్! ఇంకా ఉన్నాయా?"

"చాలా ఉన్నాయి. కానీ మేము వాటిని ప్రస్తుతం కవర్ చేయము. ఇప్పుడు మన మొదటి ఉదాహరణను కొంచెం రీవర్క్ చేద్దాం:"

public static void main(String[] args) throws IOException
{
 Cat cat = new Cat();
 cat.name = "Missy";
 cat.age = 5;
 cat.weight = 4;

 StringWriter writer = new StringWriter();

 ObjectMapper mapper = new ObjectMapper();

 mapper.writeValue(writer, cat);

 String result = writer.toString();
 System.out.println(result);
}

@JsonAutoDetect
class Cat
{
 @JsonProperty("alias")
 public String name;
 public int age;
 @JsonIgnore
 public int weight;

 Cat() {
 }
}

{"age":5, "alias":"Missy"}

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

"మీరు ప్రతిదానిని అలా అనుకూలీకరించడం మంచిది. నేను ఖచ్చితంగా ఇది ఉపయోగకరంగా ఉంటుందని భావిస్తున్నాను."

"మరియు డీరియలైజేషన్ దీనితో ఎలా పని చేయాలో అర్థం చేసుకుంటుంది? JSON నుండి జావా ఆబ్జెక్ట్‌కి డీరియలైజ్ చేసినప్పుడు, అలియాస్ ఫీల్డ్ విలువ క్యాట్ ఆబ్జెక్ట్ నేమ్ ఫీల్డ్‌కి వ్రాయబడుతుందా?"

"అవును, డీరియలైజేషన్ పని చేస్తుంది. ఇది తెలివైనది."

"అప్పుడు సంతోషించాల్సిన పనిలేదు."

"ఈ ఆసక్తికరమైన పాఠానికి ధన్యవాదాలు, ఎల్లీ."