Jackson ObjectMapper

Jackson-ը հայտնի գրադարան ա, որն օգնում ա սերիալիզացիայի/դեսերիალიზացիայի համար Java-օբյեկտները տարբեր տեքստային ֆորմատներով։ Հիմնական ֆունկցիոնալությունը JSON-ի հետ աշխատանքում — դա ObjectMapper դասն ա։ Մնացած ֆորմատների համար կօգնեն նրա ժառանգները (XmlMapper, YAMLMapper)։ Ժառանգության շնորհիվ բոլոր ֆորմատներով աշխատանքը կկատարվի միատեսակ, միակ ինտերֆեյսով։

Ներբեռնում ենք jar-ներ

Նախքան փորձերը ուսումնասիրելը, պետք է ներբեռնել Jackson-ի jar-ֆայլերը և նրանց միացնել IntellijIDEA-ի նախագծին։ Եկեք տեսնենք, ինչպես փնտրել անհրաժեշտ ֆայլերը օրինակով jackson-databind:

1. Գնա Maven Repository կայքը։

2. Փնտրի տողի մեջ գրի “jackson-databind”, և ստացիր արդյունք:

3. Մեզ հետաքրքրում ա առաջին արդյունքը, անցնում ենք հղումով։

4. Երբեմն կարող ա անհրաժեշտ լինել գրադարանի կոնկրետ տարբերակ՝ նախագծի մյուս բաղադրիչների հետ համատեղելիությունը ապահովելու համար։ Քո համար հարմար կլինի վերջին տարբերակը (այս դասախոսության գրելու պահին դա 2.13.2.2 ա), անցիր հղումով։

5. Բացված էջում քեզ պետք կլինի “bundle” հղումը:

6. Ներբեռնում ենք jar-ֆայլը հղումով:

Նմանապես կարող ենք գտնել և ներբեռնել մնացած անհրաժեշտ jar-ները:

• jackson-annotations

• jackson-core

• jackson-dataformat-xml

• jackson-dataformat-yaml

• snakeyaml

• woodstox-core

• stax2-api

Բոլոր անհրաժեշտ ֆայլերը ներբեռնելուց հետո, միացրու նրանց IntellijIDEA նախագծին:

1. Բացիր նախագծի կարգավորումները (դա կարելի է անել Ctrl+Alt+Shift+S համադրությամբ)։

2. Անցիր Libraries բաժինը։

3. Սեղմի +, հետո Java, ընտրիր բոլոր ներբեռնված ֆայլերը։ Պետք է ստացվի այսպես:

4. Այսով պատրաստությունը ավարտված է, փորձելու ենք 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 = "Обитаемый остров";
    	book.author = "Стругацкий А., Стругацкий Б.";
    	book.pages = 413;
 
    	ObjectMapper mapper = new ObjectMapper();
    	String jsonBook = mapper.writeValueAsString(book);
    	System.out.println(jsonBook);
	}
}

Մեկնարկելով main-ը, դուք կստանաք այսպիսի արդյունք:

ObjectMapper-ը ունի լրացուցիչ կարգավորումների մեծ քանակություն։ Օգտվենք մեկը դրանցից, որպեսզի JSON տողը լինի հեշտ ընթերբելի կազմված։ Ստեղծելուց հետո ObjectMapper օբյեկտը կատարենք հրամանը:

Արդյունքի մեջ ունեցած տեղեկությունը մնաց նույնը, բայց ավելացան հեռացումներ և տողերի անցումներ:

Դեսերիալիզացիա JSON-ից

Այժմ կատարենք հակառակ գործողություն: դեսերիալիզացնում ենք տողը օբյեկտի։ Որպեսզի գնահատել ծրագրի աշխատանքը, Book դասում ավելացնենք toString մեթոդը:

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

Եվ պատվիրենք այսպիսի main:

public static void main(String[] args) throws Exception {
	String jsonString = "{\"title\":\"Обитаемый остров\",\"author\":\"Стругацкий А., Стругацкий Б.\",\"pages\":413}";
	Book book = new ObjectMapper().readValue(jsonString, Book.class);
	System.out.println(book);
}

Արդյունքներ:

readValue մեթոդը գերբեռնված է, ունի տարբեր փոփոխություններ, ընդունելով ֆայլներ, հղումներ, տարբեր հոսանքներ և այլն։ Մեր օրինակով օգտագործված է պարզեցած տարբերակը, ընդունելով JSON տող տեսքով։

Ինչպես վերը նշված է, ObjectMapper-ը ունի շատ կարգավորումներ, եկե՛ք դրանցից մի քանիսը դիտարկենք։

Անտեսելով անհայտ հատկանիշները

Դիտարկենք վիճակ, երբ JSON-տողը ունի հատկանիշ, որը չկա Book դասում:

public static void main(String[] args) throws Exception {
	String jsonString = """
        	{
          	"title" : "Обитаемый остров",
          	"author" : "Стругацкий А., Стругацкий Б.",
          	"pages" : 413,
          	"unknown property" : 42
        	}""";
	ObjectMapper mapper = new ObjectMapper();
	Book book = mapper.readValue(jsonString, Book.class);
	System.out.println(book);
}

Փորձելով կատարելու այս կոդը, կստանաք UnrecognizedPropertyException։ Դա վերընշված է ըստ լռելյայն կարգավիճակի, բայց մենք կարող ենք դրա փոփոխել:

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

ObjectMapper օբյեկտը ստեղծելուց հետո օգտագործում ենք configure մեթոդը՝ անհրաժեշտ կարգավորումը սահմանելու համար false։ configure մեթոդը փոխում է այն օբյեկտը, որի վրա այն դրվում է, և վերադարձնում է նույն օբյեկտը, ուստի այդ մեթոդը կարելի է կախել նաև այսպես:

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

Ֆունկցիոնալության տարբերությունը չի լինի։

Եթե հիմա սկսենք main-ը, դեսերիալիզացիան տեղի կունենա հաջողությամբ, իսկ unknown property-ը կանցնի անտեսելով։

Հարմարավետ անոտացիաներ

Jackson-ը մեզ տրամադրում է տարբեր անոտացիաներով սերիալիզացման ամբողջական կարգաբերում։ Դիտարկենք մի քանիսը առավել օգտակարից:

Անոտացիաներից @JsonIgnore - տեղադրվում է հոն, որը պետք է անտեսել սերիալիզացման/դեսերիալիզացման ժամանակ:

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

Արդյունքում, սերիալիզացմանից հետո author դաշտը չի գրանցվի վերջնական JSON-ում։ Դեսերիալիզացման ժամանակ author դաշտը կստանա լռելյայն արժեք (null), նույնիսկ եթե JSON-ում նշված ա ուրիշ արժեք։

@JsonFormat - թույլ է տալիս սահմանել սերիալիզացված տվյալների ձևաչափ՝։ Ավելացնենք Book դասում ևս մեկ դաշտ Date տեսքով:

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

Սերիալիզացիայից հետո կստանանք այսպիսի JSON:

Ինչպես տեսնում եք, ամսաթիվը սերիալիզացված է որպես թիվ։ Ավելացնենք անոտացիա եւ սահմանենք ձևաչափը:

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

Հիմա սերիալիզացման արդյունքը:

@JsonProperty - հնարավորություն տալ փոխել հատկության անունը, որի մեջ դաշտը սերիալիզացվում է։ Այս անոտացիան կարող եք ավելացնել մեթոդներին, եւ նրանց վերադարձվող արժեքը կփոխակերպվի JSON հատկություն սերիալիզացման ժամանակ:

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

Սերիալիզացման արդյունքը:

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

Սերիալիզացման արդյունքը:

Եթե ավելացնենք հերթական անոտացիան:

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

Այժմ սերիալիզացման արդյունքը կլինի:

Այժմ դաշտերը, որոնք ունեն null արժեք, սերիալիզացված չեն:

@JsonPropertyOrder - թույլ է տալիս նշել սերիալիզացված դաշտերի կարգը:

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

Սերիալիզացման արդյունքը:

Իմացիր այժմ, թե ինչպես օգտագործել անոտացիաները, իսկ այս մոդուլում ավելի մանրամասն կծանոթանանք նրանց հետ և կստեղծենք մեր սեփական անոտացիաները՝:

Սերիալիզացիա և դեսերիալիզացիա XML-ում

Եթե անհրաժեշտ է սերիալիզացնել XML ֆորմատում, կարող ենք օգտագործել նույն կարգավորումները և անոտացիաները։ Միակ տարբերությունը կլինի mapper: օբյեկտի իրականացումը:

public static void main(String[] args) throws Exception {
	Book book = new Book();
	book.title = "Обитаемый остров";
	book.author = "Стругацкий Ա., Стругацкий Բ.";
	book.pages = 413;
 
	ObjectMapper mapper = new XmlMapper();
	mapper.enable(SerializationFeature.INDENT_OUTPUT);
	String xmlBook = mapper.writeValueAsString(book);
	System.out.println(xmlBook);
}

Արդյունքը:

Դեսերիալիզացիա XML-ում:

public static void main(String[] args) throws Exception {
   String xmlString = """
            <Book>
             <title>Обитаемый остров</title>
             <author>Стругацкий Ա., Стругацкий Բ.</author>
             <pages>413</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 = "Обитаемый остров";
	book.author = "Стругацкий Ա., Стругацкий Բ.";
	book.pages = 413;
 
	ObjectMapper mapper = new YAMLMapper();
	mapper.enable(SerializationFeature.INDENT_OUTPUT);
	String yamlBook = mapper.writeValueAsString(book);
	System.out.println(yamlBook);
}

Արդյունքը:

Դեսերիալիզացիա YAML-ում:

public static void main(String[] args) throws Exception {
   String yamlString = """
           ---
           title: "Обитаемый остров"
           author: "Стругацкий Ա., Стругацкий Բ."
           pages: 413""";
   ObjectMapper mapper = new YAMLMapper();
   Book book = mapper.readValue(yamlString, Book.class);
   System.out.println(book);
}