XML, JAXB (నెస్టెడ్ క్లాస్‌లు మొదలైనవి)కి సంక్లిష్టమైన సీరియలైజేషన్

"సరే, అయితే. మీరు బహుశా ఇప్పటికే ఊహించినట్లుగా, అది అంతా కాదు."

"ఇప్పుడు నేను మీకు JAXB యొక్క అనేక ఇతర అంశాల గురించి చెబుతాను. కానీ మేము JSONతో చేసినట్లుగా, మేము సేకరణలతో ప్రారంభిస్తాము."

"JAXBని ఉపయోగించి సేకరణలను డీరియలైజ్ చేస్తున్నప్పుడు, జాబితా వేరియబుల్ కోసం ఏ నిర్దిష్ట సేకరణ (అరేలిస్ట్, లింక్డ్‌లిస్ట్, వెక్టర్, మొదలైనవి) ఉపయోగించాలనే దానిపై కూడా అనిశ్చితి ఉంటుంది. మరియు మళ్లీ ఈ ప్రశ్నకు సమాధానం ఉల్లేఖనాల ద్వారా అందించబడుతుంది."

"ఇదంతా చాలా సులభం. సేకరణ రకాన్ని దాని ఉల్లేఖనంలో పేర్కొనకపోతే, JAXB దాని రకాన్ని ఉపయోగించి అత్యంత సముచితమైన సేకరణను ఎంచుకోవడానికి ప్రయత్నిస్తుంది. జాబితా కోసం, ఇది అర్రేలిస్ట్; మ్యాప్ కోసం, ఇది HashMap, మొదలైనవి ."

"వాస్తవానికి, ఇక్కడ JSON కంటే చాలా తక్కువ సమస్యలు ఉన్నాయి, ఎందుకంటే ప్రతి తరగతికి ప్రత్యేకమైన ట్యాగ్ ఉంటుంది మరియు మీరు ఖచ్చితమైన తరగతిని పేర్కొనడానికి ట్యాగ్‌ని ఉపయోగించవచ్చు."

"ఉదాహరణకు, మీరు సాధారణ పూర్వీకులను వారసత్వంగా పొందే మూలకాల సమూహాన్ని డీరియలైజ్ చేయవలసి వస్తే, మీరు  @XmlAny: ఉల్లేఖనాన్ని ఉపయోగిస్తారు"

public static void main(String[] args) throws JAXBException
{
 String xmldata = "<zoo><cat/><cat/><dog/><cat/></zoo>";
 StringReader reader = new StringReader(xmldata);

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

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

@XmlType(name = "zoo") 
@XmlRootElement 
class  Zoo 
{ 
@XmlAny public  List<Object> జంతువులు; } 
 


@XmlType(పేరు = "పిల్లి") 
@XmlRootElement 
క్లాస్  క్యాట్ 
{ 
పబ్లిక్  స్ట్రింగ్ పేరు; పబ్లిక్  పూర్ణాంక వయస్సు; పబ్లిక్  పూర్ణాంక బరువు; 
 
 

 పిల్లి() 
 { 
 } 
}

@XmlType(పేరు = "కుక్క") 
@XmlRootElement 
క్లాస్  డాగ్ 
{ 
పబ్లిక్  స్ట్రింగ్ పేరు; పబ్లిక్  పూర్ణాంక వయస్సు; పబ్లిక్  పూర్ణాంక బరువు; 
 
 

 పిల్లి() 
 { 
 } 
} 

"ఒక సేకరణ @XmlAny ఉల్లేఖనంతో గుర్తించబడితే , దానిలో ఏవైనా సరిఅయిన వస్తువులను ఉంచవచ్చు. మరియు JAXB అన్‌మార్షలర్ సేకరణను నింపేటప్పుడు ట్యాగ్‌లపై శ్రద్ధ చూపుతుంది."

"ఈ సందర్భంలో, " <zoo> <cat/><cat/> <dog/> <cat/> </zoo> " ట్యాగ్‌ల క్రమం పిల్లి, పిల్లి, కుక్క మరియు పిల్లి వస్తువులతో సేకరణగా మార్చబడుతుంది ."

"నేను ఊహించిన దాని గురించి."

"ఉహ్-హహ్. ఓహ్, మరో విషయం. మీరు టెక్స్ట్ మరియు ట్యాగ్‌ల మిశ్రమాన్ని డీరియలైజ్ చేస్తే, మీరు @XmlMixed ఉల్లేఖనాన్ని ఉపయోగించాలి ."

"ఈ రకమైన XMLకి ఇదిగో ఉదాహరణ:"

<data> 
<items> 
పరీక్ష 1 <item/> text 2 <item> పేరు </item> text 3 </items> </data> 

 

 

 

"వావ్. అలాంటి XML ఉనికిలో ఉందని నేను మర్చిపోయాను. పొందుపరిచిన ట్యాగ్‌లు మరియు మిగతావన్నీ అందంగా ఉండటం నాకు అలవాటు పడింది."

"ఇది ఉనికిలో ఉంది. మరియు ఈ కేసుకు కూడా JAXB ఒక ఉల్లేఖనాన్ని కలిగి ఉంది!"

"అద్భుతం. మార్గం ద్వారా, నేను అడగాలనుకున్నాను: ఎనమ్స్ ఎలా సీరియల్‌గా ఉన్నాయి?"

"గుడ్ క్వశ్చన్! నైస్ క్యాచ్! ఎలాగోలా ఆ టాపిక్ దాటవేశాను."

"ఎనమ్‌లను గుర్తు పెట్టడానికి ప్రత్యేక @XmlEnum ఉల్లేఖనాన్ని తప్పనిసరిగా ఉపయోగించాలి. విలువలు సంఖ్యలు లేదా స్ట్రింగ్‌లుగా నిల్వ చేయబడతాయో లేదో పేర్కొనడానికి మీరు దాన్ని ఉపయోగించవచ్చు."

"ఒక నిర్దిష్ట enum ఫీల్డ్‌కు అనుగుణంగా ఉండే విలువను పేర్కొనడానికి మిమ్మల్ని అనుమతించే @XmlEnumValue ఉల్లేఖన కూడా ఉంది."

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

@XmlType
@XmlEnum(Integer.class)
public enum Code
{
 @XmlEnumValue("1")
  START,

 @XmlEnumValue("2")
  INPROGRESS,

 @XmlEnumValue("3")
  FINISH

 @XmlEnumValue("-1")
  ERROR
}

@XmlType
@XmlEnum(String.class)
public enum Card
{
 @XmlEnumValue("Spade")
  CLUBS,

 @XmlEnumValue("Diamond")
  DIAMONDS,

 @XmlEnumValue("Heart")
  HEARTS,

 @XmlEnumValue("Club")
  SPADES
}

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

"అవును. ఇది చాలా ఉపయోగకరంగా ఉంటుంది, ఉదాహరణకు, మీరు Facebook సర్వర్‌తో సందేశాలను మార్పిడి చేసే ప్రోగ్రామ్‌ను వ్రాసినప్పుడు మరియు వాటికి కేటాయించబడిన విలువల సెట్ ఉంటుంది. మీరు వాటిని వారి స్వంత enumకి కేటాయించాలి మరియు ప్రతిదీ పని చేస్తుంది. "

"అద్భుతం. నాకు ఖచ్చితంగా JAXB అంటే ఇష్టం."

"అద్భుతం. ఐతే ఈరోజుకి అంతే. వెళ్లి బ్రేక్ తీసుకో."