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<Cat> 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<Cat> cats = new ArrayList<>();
 Cat() {
 }
}

" எந்தப் பட்டியல் இடைமுகத்தைப் பயன்படுத்த வேண்டும் என்பதைக் குறிக்க, வரி 5 இல் @JsonDeserialize(as = ArrayList.class, contentAs = Cat.class) என்ற சிறுகுறிப்பைச் சேர்க்கிறோம் ."

"ஆ, நான் பார்க்கிறேன். அது உண்மையில் மிகவும் எளிமையானது."

"ஆனால் இன்னும் இருக்கிறது. பட்டியலில் உள்ள தரவு வகையும் ஒரு இடைமுகம் என்று வைத்துக்கொள்வோம்! நீங்கள் என்ன செய்வீர்கள்?"

"நாம் இங்கேயும் ஒரு சிறுகுறிப்பைப் பயன்படுத்துகிறோமா?"

"ஆம், அதே ஒன்று. அளவுரு வகையைக் குறிப்பிடவும் இதைப் பயன்படுத்தலாம். இது போல்:"

"அருமை! நாம் எதிர்பார்க்க முடியாத பல்வேறு சூழ்நிலைகளுக்கு நிறைய சிறுகுறிப்புகள் தேவைப்படுகின்றன."

"அதெல்லாம் இல்லை. அது நம்மை முக்கிய பாடத்திற்குக் கொண்டுவருகிறது: உண்மையான திட்டங்களில், வகுப்புகள் பெரும்பாலும் ஒரே அடிப்படை வகுப்பு அல்லது இடைமுகத்தைப் பெறுகின்றன, இது கிட்டத்தட்ட எல்லா இடங்களிலும் பயன்படுத்தப்படுகிறது. இப்போது நீங்கள் அத்தகைய வகுப்புகளைக் கொண்ட தரவு கட்டமைப்பை சீரழிக்க வேண்டும் என்று கற்பனை செய்து பாருங்கள். உதாரணத்திற்கு:"

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<Pet> 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 பெறும் வெளிப்புறப் பயன்பாட்டிற்குப் பெயர்கள் எப்படித் தெரியும் எங்கள் வகுப்புகள்? மோசமானது, வகுப்புகள் சில நேரங்களில் மறுபெயரிடப்படுகின்றன. குறிப்பிட்ட வகுப்பை அடையாளம் காண சில தனிப்பட்ட பெயரைப் பயன்படுத்துவது நல்லது."

"கூல்! பெருமூச்சு விடுங்கள். டீரியலைசேஷன் மிகவும் சிக்கலானது என்பதை நான் உணரவில்லை. மேலும் உங்களால் நன்றாக மாற்றியமைக்க முடியும்."

"ஆமாம். உங்களுக்கு இது புது கான்செப்ட்கள், ஆனால் இந்த மாதிரியான நடைமுறை அறிவு உங்களை ஒரு மேதை ப்ரோக்ராமர் ஆக்கும்."

"அமிகோ ஒரு கூல் புரோகிராமர். கூல்!"

"சரி. போய் ஓய்வு எடு."