Course మాడ్యూల్ 2: జావా కోర్ - Lecture: జాక్సన్ యొక్క ఆబ్జెక్ట్ మ్యాపర్

జావా ఆబ్జెక్ట్‌లను వివిధ టెక్స్ట్ ఫార్మాట్‌లలోకి సీరియలైజ్ చేయడానికి/డీరియలైజ్ చేయడానికి జాక్సన్ ఒక ప్రసిద్ధ లైబ్రరీ. ఆబ్జెక్ట్‌మ్యాపర్ క్లాస్ అనేది JSON ఫార్మాట్‌తో పని చేయడానికి లైబ్రరీ యొక్క ప్రధాన మార్గం. ఇతర ఫార్మాట్‌ల కోసం, మేము దాని వారసులను కలిగి ఉన్నాము ( XmlMapper , YAMLMapper ). వారసత్వానికి ధన్యవాదాలు, మేము ఒకే ఇంటర్‌ఫేస్ ద్వారా అన్ని ఫార్మాట్‌లతో స్థిరమైన మార్గంలో పని చేయవచ్చు.

jar ఫైల్‌లను డౌన్‌లోడ్ చేయండి

ఉదాహరణలను అధ్యయనం చేయడానికి ముందు, మేము జాక్సన్ జార్ ఫైల్‌లను డౌన్‌లోడ్ చేసి, వాటిని IntelliJ IDEAలోని ప్రాజెక్ట్‌కి కనెక్ట్ చేయాలి. అవసరమైన ఫైల్‌ల కోసం ఎలా శోధించాలో చూడటానికి jackson-databind ఉదాహరణను తీసుకుందాం :

మావెన్ రిపోజిటరీ వెబ్‌సైట్‌కి వెళ్లండి .
శోధన పెట్టెలో " jackson-databind "ని నమోదు చేయండి. మీరు ఈ క్రింది వాటిని పొందుతారు:
మొదటి శోధన ఫలితం మనకు ఆసక్తిని కలిగిస్తుంది. లింక్‌ని అనుసరించండి.
ప్రాజెక్ట్‌లోని ఇతర భాగాలతో అనుకూలతను నిర్ధారించడానికి కొన్నిసార్లు లైబ్రరీ యొక్క నిర్దిష్ట సంస్కరణ అవసరం కావచ్చు. తాజా సంస్కరణ పని చేయాలి (ఈ పాఠం వ్రాసే సమయంలో, ఇది 2.13.2.2). లింక్‌ని అనుసరించండి.
తెరుచుకునే పేజీలో, మీకు "బండిల్" లింక్ కావాలి:
ఈ లింక్‌ని ఉపయోగించి jar ఫైల్‌ని డౌన్‌లోడ్ చేయండి .

ఇదే విధానాన్ని అనుసరించి, మీరు మిగిలిన అవసరమైన jar ఫైల్‌లను కనుగొని డౌన్‌లోడ్ చేసుకోవచ్చు:

అవసరమైన అన్ని ఫైల్‌లను డౌన్‌లోడ్ చేసిన తర్వాత, వాటిని IntelliJ IDEAలోని ప్రాజెక్ట్‌కి కనెక్ట్ చేయండి:

ప్రాజెక్ట్ సెట్టింగ్‌లను తెరవండి (మీరు Ctrl+Alt+Shift+S కీ కలయికతో చేయవచ్చు ).
లైబ్రరీలకు వెళ్లండి .
నొక్కండి + ఆపై "జావా". డౌన్‌లోడ్ చేసిన అన్ని ఫైల్‌లను ఎంచుకోండి. మనం ముగించాల్సినవి ఇక్కడ ఉన్నాయి:
ఇది మా సన్నాహక పనిని ముగించింది. ఇప్పుడు మనం ObjectMapperని చర్యలో ప్రయత్నించవచ్చు .

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

ముందుగా, JSONకి కొంత వస్తువును సీరియలైజ్ చేద్దాం:


import com.fasterxml.jackson.databind.ObjectMapper;
 
class Book {
	public String title;
	public String author;
	public int pages;
}
 
public class Solution {
	public static void main(String[] args) throws Exception {
    	Book book = new Book();
    	book.title = "Good Omens";
    	book.author = "Pratchett T., Gaiman N.";
    	book.pages = 383;
 
    	ObjectMapper mapper = new ObjectMapper();
    	String jsonBook = mapper.writeValueAsString(book);
    	System.out.println(jsonBook);
	}
}

రన్నింగ్ మెయిన్ మీకు ఈ అవుట్‌పుట్ ఇస్తుంది:

{"title":"మంచి శకునాలు","రచయిత":"Pratchett T., Gaiman N.","pages":383}

ObjectMapper చాలా అధునాతన సెట్టింగ్‌లను కలిగి ఉంది . JSON స్ట్రింగ్‌ను మరింత చదవగలిగేలా చేయడానికి వాటిలో ఒకదాన్ని ఉపయోగించుకుందాం. సృష్టించిన తర్వాతఆబ్జెక్ట్ మ్యాపర్వస్తువు, ఈ ప్రకటనను అమలు చేయండి:

mapper.enable(SerializationFeature.INDENT_OUTPUT);

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

{
"title" : "మంచి శకునాలు",
"రచయిత" : "Pratchett T., Gaiman N.",
"pages" : 383
}

JSON నుండి డీసీరియలైజేషన్

ఇప్పుడు వ్యతిరేక చర్య చేద్దాం: మేము ఒక స్ట్రింగ్‌ను వస్తువుగా మారుస్తాము. ప్రోగ్రామ్ ఏమి చేస్తుందో చూడడానికి, బుక్ క్లాస్‌లో toString పద్ధతిని భర్తీ చేద్దాం :


@Override
public String toString() {
	return "Book{" +
        	"title='" + title + '\'' +
        	", author='" + author + '\'' +
        	", pages=" + pages +
        	'}';
}

మరియు మేము ప్రధాన పద్ధతిలో ఈ క్రింది వాటిని చేస్తాము :


public static void main(String[] args) throws Exception {
	String jsonString = "{\"title\":\"Good Omens\",\"author\":\"Pratchett T., Gaiman N.\",\"pages\":383}";
	Book book = new ObjectMapper().readValue(jsonString, Book.class);
	System.out.println(book);
}

అవుట్‌పుట్:

పుస్తకం{శీర్షిక='మంచి శకునాలు', రచయిత='ప్రాట్చెట్ టి., గైమాన్ ఎన్.', పేజీలు=383}

రీడ్‌వాల్యూ పద్ధతి ఓవర్‌లోడ్ చేయబడింది — ఇది ఫైల్, లింక్, వివిధ ఇన్‌పుట్ స్ట్రీమ్‌లు మొదలైన వాటిని తీసుకునే అనేక వైవిధ్యాలను కలిగి ఉంది. సరళత కోసం, మా ఉదాహరణ JSON స్ట్రింగ్‌ను అంగీకరించే వేరియంట్‌ను ఉపయోగిస్తుంది .

పైన చెప్పినట్లుగా, ObjectMapper అనేక సెట్టింగ్‌లను కలిగి ఉంది. వాటిలో కొన్నింటిని చూద్దాం.

తెలియని లక్షణాలను విస్మరించడం

బుక్ క్లాస్‌లో లేని ఆస్తిని JSON స్ట్రింగ్ కలిగి ఉన్న పరిస్థితిని పరిగణించండి :


public static void main(String[] args) throws Exception {
	String jsonString = """
        	{
          	"title" : "Good Omens",
          	"author" : "Pratchett T., Gaiman N.",
          	"pages" : 383,
          	"unknown property" : 42
        	}""";
	ObjectMapper mapper = new ObjectMapper();
	Book book = mapper.readValue(jsonString, Book.class);
	System.out.println(book);
}

ఈ కోడ్‌ని అమలు చేయడం వలన మనకు గుర్తించబడని ఆస్తి మినహాయింపు లభిస్తుంది . ఇది డిఫాల్ట్ ప్రవర్తన, కానీ మనం దీన్ని మార్చవచ్చు:


ObjectMapper mapper =
new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

సృష్టించేటప్పుడు ఒకఆబ్జెక్ట్ మ్యాపర్వస్తువు, సంబంధిత సెట్టింగ్‌ను తప్పుగా సెట్ చేయడానికి మేము కాన్ఫిగర్ పద్ధతిని ఉపయోగిస్తాము . కాన్ఫిగర్ పద్ధతి అది పిలిచిన ఆబ్జెక్ట్‌ని సవరించి, అదే ఆబ్జెక్ట్‌ని తిరిగి ఇస్తుంది, కాబట్టి మనం ఈ కాల్‌ని వేరే విధంగా చేయవచ్చు :


ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

కార్యాచరణ పరంగా, ఈ సంజ్ఞామానం మునుపటి మాదిరిగానే ఉంటుంది.

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

అనుకూలమైన ఉల్లేఖనాలు

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

@JsonIgnore — ఈ ఉల్లేఖనం సీరియలైజేషన్/డీరియలైజేషన్ సమయంలో విస్మరించాల్సిన మూలకం పైన ఉంచబడింది:


class Book {
	public String title;
	@JsonIgnore
	public String author;
	public int pages;
}

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

@JsonFormat — ఈ ఉల్లేఖనం సీరియలైజ్ చేయబడిన డేటా యొక్క ఆకృతిని సెట్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. పుస్తక తరగతికి మరో ఫీల్డ్, తేదీని జోడిద్దాం :


class Book {
	public String title;
	public String author;
	public int pages;
	public Date createdDate = new Date();
}

సీరియలైజేషన్ తర్వాత, మేము ఈ క్రింది JSONని పొందుతాము:

{
  "title" : "మంచి శకునాలు",
  "రచయిత" : "Pratchett T., గైమాన్ N.",
  "pages" : 383,
  "createdDate" : 1649330880788
}

మీరు చూడగలిగినట్లుగా, తేదీ ఒక సంఖ్యగా క్రమీకరించబడింది. మేము ఉల్లేఖనాన్ని జోడించి, ఆకృతిని సెట్ చేస్తాము:


class Book {
	public String title;
	public String author;
	public int pages;
	@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
	public Date createdDate = new Date();
}

ఇప్పుడు సీరియలైజేషన్ ఫలితం:

{
  "title" : "మంచి శకునాలు",
  "రచయిత" : "Pratchett T., గైమాన్ N.",
  "pages" : 383,
  "createdDate" : "2022-04-07"
}

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


class Book {
	@JsonProperty("name")
	public String title;
	public String author;
	public int pages;
 
	@JsonProperty("quotedTitle")
	public String getQuotedTitle() {
    	    return "\"" + title + "\"";
	}
}

సీరలైజేషన్ ఫలితం:

{
  "author" : "Pratchett T., Gaiman N.",
  "pages" : 383,
  "name" : "Good Omens",
  "quotedTitle" : "\"మంచి శకునాలు\""
}

@JsonInclude — ఈ ఉల్లేఖనాన్ని ఉపయోగించి, మీరు ఫీల్డ్‌ని ధారావాహికీకరించడానికి తప్పనిసరిగా సంతృప్తి చెందాల్సిన షరతులను పేర్కొనవచ్చు. మీరు దీన్ని వ్యక్తిగత ఫీల్డ్‌లకు లేదా మొత్తం తరగతికి వర్తింపజేయవచ్చు. ముందుగా, అన్‌ఇనిషియలైజ్డ్ ఫీల్డ్‌లతో ఆబ్జెక్ట్‌ని సీరియలైజ్ చేయడానికి ప్రయత్నిద్దాం:


public class Solution {
	public static void main(String[] args) throws Exception {
    		Book book = new Book();

    		ObjectMapper mapper = new ObjectMapper();
    		mapper.enable(SerializationFeature.INDENT_OUTPUT);
    		String jsonBook = mapper.writeValueAsString(book);
    		System.out.println(jsonBook);
	}
}

సీరలైజేషన్ ఫలితం:

{
  "title" : null,
  "author" : null,
  "pages" : 0
}

మరియు మీరు ఉల్లేఖనాన్ని జోడిస్తే:


@JsonInclude(JsonInclude.Include.NON_NULL)
class Book {
	public String title;
	public String author;
	public int pages;
}

అప్పుడు మేము ఈ ఫలితాన్ని పొందుతాము:

{
"పేజీలు" : 0
}

ఇప్పుడు శూన్యంగా ఉన్న ఫీల్డ్‌లు సీరియలైజ్ చేయబడవు.

@JsonPropertyOrder — ఈ ఉల్లేఖనం మిమ్మల్ని ఏ ఫీల్డ్‌లలో సీరియలైజ్ చేయబడిందో సెట్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది:


@JsonPropertyOrder({"author", "title", "pages"})
class Book {
	public String title;
	public String author;
	public int pages;
}

సీరలైజేషన్ ఫలితం:

{
  "రచయిత" : "ప్రాట్చెట్ టి., గైమాన్ ఎన్.",
  "శీర్షిక" : "మంచి శకునాలు",
  "పేజీలు" : 383
}

ప్రస్తుతానికి, ఉల్లేఖనాలను ఎలా ఉపయోగించాలో గుర్తుంచుకోండి. ఈ మాడ్యూల్ చివరిలో, మేము వాటిని బాగా తెలుసుకుంటాము మరియు మా స్వంత ఉల్లేఖనాలను కూడా సృష్టిస్తాము.

XMLలో సీరియలైజేషన్ మరియు డీరియలైజేషన్

మనం XMLలోకి సీరియల్ చేయవలసి వస్తే, మనం ఒకే విధమైన సెట్టింగ్‌లు మరియు ఉల్లేఖనాలను ఉపయోగించవచ్చు. యొక్క అమలులో మాత్రమే తేడా ఉంటుందిమ్యాపర్ వస్తువు:


public static void main(String[] args) throws Exception {
	Book book = new Book();
	book.title = "Good Omens";
	book.author = "Pratchett T., Gaiman N.";
	book.pages = 383;
 
	ObjectMapper mapper = new XmlMapper();
	mapper.enable(SerializationFeature.INDENT_OUTPUT);
	String xmlBook = mapper.writeValueAsString(book);
	System.out.println(xmlBook);
}

అవుట్‌పుట్:

<బుక్>
  <title>మంచి శకునాలు</title>
  <author>Pratchett T., Gaiman N.</author>
  <pages>383</pages>
</Book>

XML యొక్క డీసీరియలైజేషన్:


public static void main(String[] args) throws Exception {
   String xmlString = """
            <Book>
             <title>Good Omens</title>
             <author>Pratchett T., Gaiman N.</author>
             <pages>383</pages>
           </Book>""";
   ObjectMapper mapper = new XmlMapper();
   Book book = mapper.readValue(xmlString, Book.class);
   System.out.println(book);
}

YAMLలో సీరియలైజేషన్ మరియు డీరియలైజేషన్

మేము XMLని నిర్వహించే విధంగానే YAMLని నిర్వహిస్తాము:


public static void main(String[] args) throws Exception {
	Book book = new Book();
	book.title = "Good Omens";
	book.author = "Pratchett T., Gaiman N.";
	book.pages = 383;
 
	ObjectMapper mapper = new YAMLMapper();
	mapper.enable(SerializationFeature.INDENT_OUTPUT);
	String yamlBook = mapper.writeValueAsString(book);
	System.out.println(yamlBook);
}

అవుట్‌పుట్:

---
శీర్షిక: "మంచి శకునాలు"
రచయిత: "Pratchett T., Gaiman N."
పేజీలు: 383

YAML యొక్క డీసీరియలైజేషన్:


public static void main(String[] args) throws Exception {
   String yamlString = """
           ---
           title: "Good Omens"
           author: "Pratchett T., Gaiman N."
           pages: 383""";
   ObjectMapper mapper = new YAMLMapper();
   Book book = mapper.readValue(yamlString, Book.class);
   System.out.println(book);
}

﻿జాక్సన్ యొక్క ఆబ్జెక్ట్ మ్యాపర్

jar ఫైల్‌లను డౌన్‌లోడ్ చేయండి

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

JSON నుండి డీసీరియలైజేషన్

తెలియని లక్షణాలను విస్మరించడం

అనుకూలమైన ఉల్లేఖనాలు

XMLలో సీరియలైజేషన్ మరియు డీరియలైజేషన్

YAMLలో సీరియలైజేషన్ మరియు డీరియలైజేషన్

జాక్సన్ యొక్క ఆబ్జెక్ట్ మ్యాపర్