JAXB

"அவ்வளவு வேகமில்லை, இளைஞனே! உனக்கு இன்னும் இரண்டு பாடங்கள் உள்ளன!"

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

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

"JAXB என்பது XML உடன் பணிபுரிவதற்கான ஒரு சிறந்த பல்நோக்கு கட்டமைப்பாகும்."

"JAXB என்பது JDK இன் ஒரு பகுதியாகும், எனவே நீங்கள் அதைத் தனியாகப் பதிவிறக்க வேண்டியதில்லை."

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

public static void main(String[] args) throws JAXBException
{
 // Create an object to be serialized into XML
 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();

 // Create a Marshaller object that will perform the serialization
 JAXBContext context = JAXBContext.newInstance(Cat.class);
 Marshaller marshaller = context.createMarshaller();
 marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
 // And here's the serialization itself:
 marshaller.marshal(cat, writer);

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

@XmlType(name = "cat")
@XmlRootElement
public class Cat
{
 public String name;
 public int age;
 public int weight;

 public Cat()
 {
 }
}

<cat> 
<name> Missy < / name 
> <age> 5 < / age> 
<weight> 4 </weight> </ 
cat>

"சில காரணங்களால், வரிக்கான வரி, இந்தக் குறியீடு எனக்கு JSON வரிசையாக்கத்தை நினைவூட்டுகிறது. அதே சிறுகுறிப்புகள், ஆனால் JSON ஒரு ஆப்ஜெக்ட்மேப்பரைப் பயன்படுத்தியது, மேலும் இது சூழல் மற்றும் மார்ஷல்லரைப் பயன்படுத்துகிறது."

"ஆமாம். அவர்கள் உண்மையில் மிகவும் ஒத்தவர்கள். ஜாக்சன் JAXB மாதிரியாக வடிவமைக்கப்பட்டார். ஆனால் JAXB யும் எங்கிருந்தோ நகலெடுக்கப்பட்டது. நீங்கள் புதிதாக ஏதாவது ஒரு மேதையை கண்டுபிடிக்க முடியாது."

"அப்படித்தான் தெரிகிறது."

"சரி, இதோ என்ன நடக்கிறது:"

"வரிகள் 4-7 இல், நாங்கள் ஒரு பூனைப் பொருளை உருவாக்கி அதை தரவுகளுடன் நிரப்புகிறோம்."

"வரி 10 இல், முடிவை எழுத ஒரு எழுத்தாளர் பொருளை உருவாக்குகிறோம்."

"வரி 13 இல், நாங்கள் 'சூழலை' உருவாக்குகிறோம். இது ஆப்ஜெக்ட்மேப்பரைப் போன்றது, ஆனால் அதிலிருந்து இரண்டு கூடுதல் குழந்தைப் பொருள்கள் உருவாக்கப்படுகின்றன. மார்ஷலர் வரிசைப்படுத்தலுக்கானது, அன்மார்ஷல்லர் டீரியலைசேஷன் ஆகும். ஜாக்சனிடமிருந்து சிறிய வேறுபாடுகள் உள்ளன, ஆனால் அது இல்லை. அடிப்படையில் வேறுபட்டதல்ல."

"வரி 14 இல், நாங்கள் ஒரு மார்ஷலர் பொருளை உருவாக்குகிறோம். மார்ஷலிங் என்பது வரிசைப்படுத்துதலுக்கான ஒரு பொருளாகும்."

"வரி 15 இல், FORMATTED_OUTPUT சொத்தை TRUE என அமைத்துள்ளோம். இதன் விளைவாக வரி முறிவுகள் மற்றும் இடைவெளிகள் சேர்க்கப்படும், இதனால் குறியீடு மனிதர்கள் படிக்கக்கூடியதாக இருக்கும், மேலும் ஒரு வரியில் அனைத்து உரைகளும் இருக்காது."

"வரி 17 இல், நாங்கள் பொருளை வரிசைப்படுத்துகிறோம்."

"வரிகள் 20-21 இல், வரிசைப்படுத்தலின் முடிவை திரையில் காண்பிக்கிறோம்."

"@XmlType(name = 'cat&') மற்றும் @XmlRootElement குறிப்புகள் என்ன?"

" @XmlRootElement இந்த பொருள் எக்ஸ்எம்எல் உறுப்புகளின் 'ஒரு மரத்தின் வேர்' ஆக இருக்கக்கூடும் என்பதைக் குறிக்கிறது. வேறுவிதமாகக் கூறினால், இது மிக உயர்ந்த நிலை உறுப்பு மற்றும் மற்ற அனைத்து கூறுகளையும் கொண்டிருக்கலாம்."

" @XmlType(name = 'cat') என்பது JAXB வரிசைப்படுத்தலில் வகுப்பு ஈடுபட்டுள்ளது என்பதைக் குறிக்கிறது, மேலும் இந்த வகுப்பிற்கான XML குறிச்சொல்லின் பெயரையும் குறிப்பிடுகிறது."

"சரி, இப்போது நான் உங்களுக்கு XML டீரியலைசேஷன் உதாரணத்தைக் காட்டுகிறேன்:"

public static void main(String[] args) throws JAXBException
{
 String xmldata = "<cat><name>Missy</name><age>5</age><weight>4</weight></cat>";
 StringReader reader = new StringReader(xmldata);

 JAXBContext context = JAXBContext.newInstance(Cat.class);
 Unmarshaller unmarshaller = context.createUnmarshaller();

 Cat cat = (Cat) unmarshaller.unmarshal(reader);
}

@XmlType(name = "cat")
@XmlRootElement
public class Cat
{
 public String name;
 public int age;
 public int weight;

 public Cat()
 {
 }
}

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

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

"வரி 4 இல், நாங்கள் XML-சரத்தை ஒரு StringReader இல் மடிக்கிறோம் ."

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

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

"வரி 9 இல், ரீடர் பொருளில் இருந்து எக்ஸ்எம்எல்லை சீரழித்து, கேட் பொருளைப் பெறுகிறோம்."

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

"நீங்கள் புத்திசாலியாக இருக்கும்போது அது எப்போதும் நடக்கும். சிக்கலான விஷயங்கள் எளிமையாகிவிடும்."

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

"நல்லது. JAXB வரிசையாக்கத்தின் முடிவைக் கட்டுப்படுத்த நீங்கள் பயன்படுத்தக்கூடிய சிறுகுறிப்புகளின் பட்டியல் இதோ:"

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

"சரி. நான் உங்களுக்கு ஒரு உதாரணத்தைக் காட்டுகிறேன். புலங்களுக்குப் பதிலாகப் பெறுபவர்/செட்டர் முறைகளை விளக்குவதற்கு JAXB உங்களை அனுமதிக்கிறது என்பதைச் சேர்க்க விரும்புகிறேன்."

"நான் உறுதியளித்த அந்த உதாரணம் இதோ:"

public static void main(String[] args) throws JAXBException
{
 // Create Cat and Zoo objects to be serialized into XML
 Cat cat = new Cat();
 cat.name = "Missy";
 cat.age = 5;
 cat.weight = 4;

 Zoo zoo = new Zoo();
 zoo.animals.add(cat);
 zoo.animals.add(cat);

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

 // Create a Marshaller object that will perform the serialization
 JAXBContext context = JAXBContext.newInstance(Cat.class, Zoo.class);
 Marshaller marshaller = context.createMarshaller();
 marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
 // Here's the serialization itself
 marshaller.marshal(zoo, writer);

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

@XmlType(name = "zoo")
@XmlRootElement
public class Zoo
{
 @XmlElementWrapper(name = "wild-animals", nillable = true)
 @XmlElement(name = "tiger")
 public List<Cat> animals = new ArrayList<>();
}

public class Cat
{
 @XmlElement(name = "catname")
 public String name;
 @XmlAttribute(name = "age")
 public int age;
 @XmlAttribute(name = "w")
 public int weight;

 public Cat()
 {
 }
}

<zoo> 
<wild-animals> 
<புலி வயது = "5" w = "4"> 
<catname>Missy</catname> 
</tiger> 
<tiger age = "5" w = "4"> 
<catname>Missy </catname> 
</tiger> 
</wild-animals> 
</zoo>

"இம்முறை நாங்கள் பூனைப் பொருளைத் தொடரவில்லை, ஆனால் பூனைப் பொருட்களின் தொகுப்பைச் சேமிக்கும் மிருகக்காட்சிசாலையின் பொருளைத் தொடர்கிறோம் என்பதைக் கவனியுங்கள்."

"பூனைப் பொருள் இரண்டு முறை சேகரிப்பில் சேர்க்கப்பட்டது, எனவே இது இரண்டு முறை XML இல் உள்ளது."

"சேகரிப்புக்கு அதன் சொந்த ' காட்டு-விலங்குகள் ' குறிச்சொல் உள்ளது, இது சேகரிப்பின் அனைத்து கூறுகளையும் உள்ளடக்கியது."

" வயது & எடை கூறுகள் வயது & w w பண்புக்கூறுகளாக மாறிவிட்டன ."

" @XmlElement பண்புக்கூறைப் பயன்படுத்தி , பூனைக் குறிச்சொல்லை புலிக் குறிக்கு மாற்றியுள்ளோம் ."

"வரி 17 க்கு கவனம் செலுத்துங்கள். இங்கே நாம் இரண்டு வகுப்புகளை ( மிருகக்காட்சிசாலை மற்றும் பூனை ) JAXB சூழலுக்கு அனுப்புகிறோம் , ஏனெனில் அவை இரண்டும் சீரியலைசேஷன்களில் ஈடுபட்டுள்ளன."

"இன்று மிகவும் சுவாரஸ்யமான நாள். பல புதிய தகவல்கள்."

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