Course தொகுதி 2: ஜாவா கோர் - Lecture: ஜாக்சனின் ஆப்ஜெக்ட்மேப்பர்

ஜாக்சன் என்பது ஜாவா பொருள்களை பல்வேறு உரை வடிவங்களில் வரிசையாக்கம்/மாற்றி வைப்பதற்கான பிரபலமான நூலகமாகும். ObjectMapper வகுப்பு என்பது JSON வடிவத்துடன் பணிபுரிய நூலகத்தின் முக்கிய வழி. மற்ற வடிவங்களுக்கு, எங்களிடம் அதன் வழித்தோன்றல்கள் உள்ளன ( XmlMapper , YAMLMapper ). பரம்பரைக்கு நன்றி, ஒரே இடைமுகத்தின் மூலம் அனைத்து வடிவங்களுடனும் ஒரு சீரான வழியில் செயல்பட முடியும்.

ஜார் கோப்புகளைப் பதிவிறக்கவும்

எடுத்துக்காட்டுகளைப் படிப்பதற்கு முன், நாம் Jackson jar கோப்புகளைப் பதிவிறக்கம் செய்து IntelliJ IDEA இல் உள்ள திட்டத்துடன் இணைக்க வேண்டும். தேவையான கோப்புகளை எவ்வாறு தேடுவது என்பதைப் பார்க்க, jackson-databind இன் உதாரணத்தை எடுத்துக் கொள்வோம் :

Maven Repository இணையதளத்திற்குச் செல்லவும் .
தேடல் பெட்டியில் " jackson-databind " ஐ உள்ளிடவும். பின்வருவனவற்றைப் பெறுவீர்கள்:
முதல் தேடல் முடிவு நமக்கு ஆர்வமாக உள்ளது. இணைப்பைப் பின்தொடரவும்.
சில நேரங்களில் ஒரு திட்டத்தில் உள்ள மற்ற கூறுகளுடன் இணக்கத்தன்மையை உறுதிப்படுத்த நூலகத்தின் ஒரு குறிப்பிட்ட பதிப்பு தேவைப்படலாம். சமீபத்திய பதிப்பு வேலை செய்ய வேண்டும் (இந்த பாடத்தை எழுதும் நேரத்தில், அது 2.13.2.2 ஆகும்). இணைப்பைப் பின்தொடரவும்.
திறக்கும் பக்கத்தில், "தொகுப்பு" இணைப்பை நீங்கள் விரும்புகிறீர்கள்:
இந்த இணைப்பைப் பயன்படுத்தி 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":"நல்ல சகுனங்கள்","author":"Pratchett T., Gaiman N.","pages":383}

ObjectMapper பல மேம்பட்ட அமைப்புகளைக் கொண்டுள்ளது . JSON சரத்தை மேலும் படிக்கக்கூடியதாக மாற்ற, அவற்றில் ஒன்றைப் பயன்படுத்துவோம். உருவாக்கிய பிறகுஆப்ஜெக்ட்மேப்பர்பொருள், இந்த அறிக்கையை செயல்படுத்தவும்:

mapper.enable(SerializationFeature.INDENT_OUTPUT);

வெளியீட்டில் உள்ள தகவல் அப்படியே உள்ளது, ஆனால் இப்போது உள்தள்ளல் மற்றும் வரி முறிவுகள் உள்ளன:

{
"title" : "நல்ல சகுனங்கள்",
"author" : "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}

readValue முறை ஓவர்லோட் செய்யப்பட்டுள்ளது - இது ஒரு கோப்பு, இணைப்பு, பல்வேறு உள்ளீட்டு ஸ்ட்ரீம்கள் போன்றவற்றை எடுக்கும் பல மாறுபாடுகளைக் கொண்டுள்ளது. எளிமைக்காக, 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);

ஒரு உருவாக்கும் போதுஆப்ஜெக்ட்மேப்பர்object, configure முறையைப் பயன்படுத்தி அதனுடன் தொடர்புடைய அமைப்பை 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" : "நல்ல சகுனங்கள்",
  "author" : "Pratchett T., Gaiman 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" : "நல்ல சகுனங்கள்",
  "author" : "Pratchett T., Gaiman 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" : "நல்ல சகுனங்கள்",
  "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;
}

சீரமைப்பின் முடிவு:

{
  "author" : "Pratchett T., Gaiman N.",
  "title" : "நல்ல சகுனங்கள்",
  "பக்கங்கள்" : 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>

எக்ஸ்எம்எல்லின் சீரியலைசேஷன்:


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);
}

﻿ஜாக்சனின் ஆப்ஜெக்ட்மேப்பர்

ஜார் கோப்புகளைப் பதிவிறக்கவும்

JSON க்கு வரிசைப்படுத்தல்

JSON இலிருந்து சீரியலைசேஷன்

அறியப்படாத பண்புகளை புறக்கணித்தல்

வசதியான சிறுகுறிப்புகள்

XML இல் சீரியலைசேஷன் மற்றும் டீரியலைசேஷன்

YAML இல் சீரியலைசேஷன் மற்றும் டீரியலைசேஷன்

ஜாக்சனின் ஆப்ஜெக்ட்மேப்பர்