JSON సీరియలైజేషన్ ఫ్రేమ్‌వర్క్‌లు

"హాయ్, మిత్రమా!"

"హే, డియెగో."

"మీరు JSON సీరియలైజేషన్ యొక్క ప్రాథమికాలను నేర్చుకున్నారని నేను ఇక్కడ చూస్తున్నాను?"

"బేసిక్స్' అంటే ఏమిటి? నాకు చాలా తెలుసు!"

"అంత అమాయకత్వం. అందులో సగం నీకు తెలియదు. పది శాతం బెస్ట్."

"నువ్వు తమాషా చేస్తున్నావు. ఇంకేముంది?"

"ఆబ్జెక్ట్ హైరార్కీ యొక్క డీసరియలైజేషన్ (పాలిమార్ఫిక్ డీరియలైజేషన్), కలెక్షన్ల డీరియలైజేషన్ మరియు ఇంకా చాలా ఎక్కువ! జాక్సన్ ఫ్రేమ్‌వర్క్ చాలా పెద్దది మరియు శక్తివంతమైనది. నిజాయితీగా, మీరు ఉపరితలంపై గీతలు గీసుకోవడం మాత్రమే ప్రారంభించారు."

"సరే, దాని గురించి నాకు చెప్పు - నేను అన్ని చెవుల్లో ఉన్నాను."

"నేను ప్రతి పాఠంతో తెలివిగా ఉండడాన్ని నిజంగా ఆనందిస్తున్నాను!"

"సరే, సహాయం చేయడం నా ఆనందం, నా రోబోట్ మిత్రమా!"

"మీరు సిద్ధంగా ఉన్నారా? అప్పుడు వినండి."

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

class Cat
{
 public String name = "missy";
 public Cat[] cats = new Cat[0];
}

{
 "name": "missy",
 "cats": []
}

class Cat
{
 public String name = "missy";
 public List cats = new ArrayList<Cat>();
}

{
 "name": "missy",
 "cats": []
}

class Cat
{
 public String name = "missy";
 public List cats = new LinkedList<Cat>();
}

{
 "name": "missy",
 "cats": []
}

"అరే, అర్రేలిస్ట్, లింక్డ్‌లిస్ట్ మరియు ఇతర తరగతుల ఉదాహరణలు JSON శ్రేణులుగా మార్చబడ్డాయి."

"కానీ మీరు JSON శ్రేణిని డీరియలైజ్ చేసినప్పుడు, మీరు ఏ వస్తువుని సృష్టించాలి: అర్రేలిస్ట్ లేదా లింక్డ్‌లిస్ట్?"

"రైట్. క్లాస్ మెంబర్ ఇంటర్‌ఫేస్ అయితే (ఉదా పబ్లిక్ లిస్ట్<Cat> పిల్లులు ), దానికి ఏ వస్తువును ఆపాదించాలి?"

"మేము ఫీల్డ్‌కు అదనపు ఉల్లేఖనాలను జోడించవచ్చు లేదా డీరియలైజేషన్ సమయంలో లక్ష్య తరగతులను స్పష్టంగా సూచించవచ్చు. ఈ ఉదాహరణను చూడండి:"

public static void main(String[] args) throws IOException
{
 String jsonString = ""{\"name\":\"Missy\",\"cats\":[{\"name\":\"Timmy\"},{\"name\":\"Killer\"}]}"";
 StringReader reader = new StringReader(jsonString);
 ObjectMapper mapper = new ObjectMapper();
 Cat cat = mapper.readValue(reader, TypeFactory.collectionType(ArrayList.class, Cat.class));
}

@JsonAutoDetect
class Cat {
 public String name;
 public List&ltCat> cats = new ArrayList<>();
 Cat() {
 }
}

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

"నాకు ఇది నచ్చింది. అది అనుకూలమైనది. కాబట్టి మీరు JSON శ్రేణిని మీకు అవసరమైన వాటిలో, అర్రేలిస్ట్ లేదా లింక్డ్‌లిస్ట్‌లో డీరియలైజ్ చేయవచ్చు.

"మీరు ఉల్లేఖనాలను కూడా ఉపయోగించారు. మీరు దానిని ఎలా చేస్తారు?"

"ఇది సులభం. ఉదాహరణకు:"

public static void main(String[] args) throws IOException
{
 String jsonString = ""{\"name\":\"Missy\",\"cats\":[{\"name\":\"Timmy\"},{\"name\":\"Killer\"}]}"";
 StringReader reader = new StringReader(jsonString);

 ObjectMapper mapper = new ObjectMapper();

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

@JsonAutoDetect
class Cat
{
 public String name;
 @JsonDeserialize(as = ArrayList.class, contentAs = Cat.class)
 public List&ltCat> cats = new ArrayList<>();
 Cat() {
 }
}

" జాబితా ఇంటర్‌ఫేస్ యొక్క ఏ అమలును ఉపయోగించాలో సూచించడానికి మేము కేవలం @JsonDeserialize(as = ArrayList.class, contentAs = Cat.class) అనే ఉల్లేఖనాన్ని 5వ పంక్తికి జోడిస్తాము ."

"ఆహ్. నేను చూస్తున్నాను. ఇది నిజంగా చాలా సులభం."

"అయితే ఇంకా చాలా ఉన్నాయి. లిస్ట్‌లోని డేటా టైప్ కూడా ఇంటర్‌ఫేస్ అని అనుకుందాం! మీరు ఏమి చేస్తారు?"

"మనం ఇక్కడ కూడా ఉల్లేఖనాన్ని ఉపయోగిస్తామా?"

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

"కూల్! మేము ఊహించలేని వివిధ పరిస్థితులకు చాలా ఉల్లేఖనాలు అవసరం."

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

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

 Dog dog = new Dog();
 dog.name = "Killer";
 dog.age = 8;
 dog.owner = "Bill Jefferson";

 ArrayList<Pet> pets = new ArrayList<Pet>();
 pets.add(cat);
 pets.add(dog);

 StringWriter writer = new StringWriter();
 ObjectMapper mapper = new ObjectMapper();
 mapper.writeValue(writer, pets);
 System.out.println(writer.toString());
}

@JsonAutoDetect
class Pet
{
 public String name;
}

@JsonAutoDetect
class Cat extends Pet
{
 public int age;
}

@JsonAutoDetect
class Dog extends Pet
{
 public int age;
 public String owner;
}

[
 { "name" : "Missy", "age" : 5},
 { "name" : "Killer", "age" : 8 , "owner" : "Bill Jeferson"}
]

"సీరియలైజేషన్ ఫలితంపై శ్రద్ధ వహించండి."

"మేము ఈ డేటాను జావా ఆబ్జెక్ట్‌గా మార్చలేము, ఎందుకంటే ఇది ఇతర తరగతుల డేటా నుండి తప్పనిసరిగా వేరు చేయలేము."

"కొన్ని ప్రత్యేక లక్షణాలు ఉన్నాయి: కుక్కకు యజమాని ఫీల్డ్ ఉంది."

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

"సరే, మనకు తెలిసిన ఉల్లేఖనాలను ఉపయోగించి డేటా రకాన్ని పేర్కొనలేమా?"

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

"మీరు ఇక్కడ ఏమి చేయగలరు?"

"ఇక్కడ రెండు విషయాలు ఉపయోగించబడ్డాయి."

"మొదట, ఒక రకం నుండి మరొక రకాన్ని వేరు చేయడానికి ఒక నిర్దిష్ట ఫీల్డ్ ఎంచుకోబడుతుంది. ఒకటి లేకుంటే, అది సృష్టించబడుతుంది."

"రెండవది, «పాలిమార్ఫిక్ డీరియలైజేషన్» ప్రక్రియను నియంత్రించడానికి మిమ్మల్ని అనుమతించే ప్రత్యేక ఉల్లేఖనాలు ఉన్నాయి. మీరు ఏమి చేయగలరో ఇక్కడ ఉంది:"

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

 Dog dog = new Dog();
 dog.name = "Killer";
 dog.age = 8;
 dog.owner = "Bill Jeferson";

 House house = new House();
 house.pets.add(dog);
 house.pets.add(cat);

 StringWriter writer = new StringWriter();
 ObjectMapper mapper = new ObjectMapper();
 mapper.writeValue(writer, house);
 System.out.println(writer.toString());
}

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
@JsonSubTypes({
@JsonSubTypes.Type(value = Cat.class, name = "cat"),
@JsonSubTypes.Type(value = Dog.class, name = "dog")
})
class Pet
{
 public String name;
}

class Cat extends Pet
{
 public int age;
}

class Dog extends Pet
{
 public int age;
 public String owner;
}

class House
{
 public List&ltPet> pets = new ArrayList<>();
}

{
 "pets" : [
 {"type" : "dog", "name" : "Killer", "age" : 8, "owner" : "Bill Jeferson"},
 {"type" : "cat", "name" : "Missy", "age" : 5}
]
}

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

"కొన్నిసార్లు తరగతి పేరు టైప్ ఫీల్డ్ యొక్క విలువగా ఉపయోగించబడుతుంది (ఉదా. «com.example.entity.Cat.class»), కానీ ఇది మంచి పద్ధతి కాదు. మా JSONని స్వీకరించే బాహ్య అప్లికేషన్‌కు వీటి పేర్లు ఎలా తెలుస్తాయి మా తరగతులు? అధ్వాన్నంగా, తరగతులు కొన్నిసార్లు పేరు మార్చబడతాయి. నిర్దిష్ట తరగతిని గుర్తించడానికి కొన్ని ప్రత్యేకమైన పేరును ఉపయోగించడం ఉత్తమం."

"కూల్! నిట్టూర్పు. డీరియలైజేషన్ చాలా క్లిష్టంగా ఉందని నేను గ్రహించలేదు. మరియు మీరు బాగా ట్యూన్ చేయగలరు."

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

"అమిగో ఒక కూల్ ప్రోగ్రామర్. కూల్!"

"సరే. వెళ్లి విశ్రాంతి తీసుకో."