Shembull tutorial i Jackson JSON Java Parser API

Jackson JSON Java Parser është shumë popullor dhe përdoret gjithashtu në kuadrin Spring. Google Gson API dhe pa se sa e lehtë për t'u përdorur.

Jackson JSON Java Parser

<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>2.2.3</version>
</dependency>

Kavanoza jackson-databind varet nga bibliotekat jackson-core dhe jackson-notations, kështu që nëse po i shtoni ato drejtpërdrejt për të ndërtuar rrugën, sigurohuni që shtoni të treja përndryshe do të merrni gabim në kohën e ekzekutimit. Jackson JSON Parser API ofron një mënyrë të thjeshtë për të kthyer JSON në Objekt POJO dhe mbështet konvertimin e lehtë në Hartë nga të dhënat JSON. Jackson gjithashtu mbështet gjenerikët dhe i konverton ato drejtpërdrejt nga JSON në objekt.

Shembull Jackson JSON

Për shembullin tonë për konvertimin e objektit JSON në POJO/Java, ne do të marrim një shembull kompleks me objekte dhe vargje të ndërlidhura. Ne do të përdorim vargje, listë dhe Map në objektet java për konvertim. Kompleksi ynë json ruhet në një skedar punonjës.txt me strukturën e mëposhtme:

{
  "id": 123,
  "name": "Pankaj",
  "permanent": true,
  "address": {
    "street": "Albany Dr",
    "city": "San Jose",
    "zipcode": 95129
  },
  "phoneNumbers": [
    123456,
    987654
  ],
  "role": "Manager",
  "cities": [
    "Los Angeles",
    "New York"
  ],
  "properties": {
    "age": "29 years",
    "salary": "1000 USD"
  }
}

Ne kemi klasat e mëposhtme java që korrespondojnë me të dhënat json.

package com.journaldev.jackson.model;

public class Address {
	
	private String street;
	private String city;
	private int zipcode;
	
	public String getStreet() {
		return street;
	}
	public void setStreet(String street) {
		this.street = street;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public int getZipcode() {
		return zipcode;
	}
	public void setZipcode(int zipcode) {
		this.zipcode = zipcode;
	}
	
	@Override
	public String toString(){
		return getStreet() + ", "+getCity()+", "+getZipcode();
	}
}

Klasa e adresës korrespondon me objektin e brendshëm në të dhënat rrënjë json.

package com.journaldev.jackson.model;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

public class Employee {

	private int id;
	private String name;
	private boolean permanent;
	private Address address;
	private long[] phoneNumbers;
	private String role;
	private List<String> cities;
	private Map<String, String> properties;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public boolean isPermanent() {
		return permanent;
	}
	public void setPermanent(boolean permanent) {
		this.permanent = permanent;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
	public long[] getPhoneNumbers() {
		return phoneNumbers;
	}
	public void setPhoneNumbers(long[] phoneNumbers) {
		this.phoneNumbers = phoneNumbers;
	}
	public String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
	
	@Override
	public String toString(){
		StringBuilder sb = new StringBuilder();
		sb.append("***** Employee Details *****\n");
		sb.append("ID="+getId()+"\n");
		sb.append("Name="+getName()+"\n");
		sb.append("Permanent="+isPermanent()+"\n");
		sb.append("Role="+getRole()+"\n");
		sb.append("Phone Numbers="+Arrays.toString(getPhoneNumbers())+"\n");
		sb.append("Address="+getAddress()+"\n");
		sb.append("Cities="+Arrays.toString(getCities().toArray())+"\n");
		sb.append("Properties="+getProperties()+"\n");
		sb.append("*****************************");
		
		return sb.toString();
	}
	public List<String> getCities() {
		return cities;
	}
	public void setCities(List<String> cities) {
		this.cities = cities;
	}
	public Map<String, String> getProperties() {
		return properties;
	}
	public void setProperties(Map<String, String> properties) {
		this.properties = properties;
	}
}

Punonjësi është java bean që përfaqëson objektin rrënjë json. Tani le të shohim se si mund ta transformojmë JSON në objekt java duke përdorur API-në e analizës së Jackson JSON.

package com.journaldev.jackson.json;

import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.journaldev.jackson.model.Address;
import com.journaldev.jackson.model.Employee;


public class JacksonObjectMapperExample {

	public static void main(String[] args) throws IOException {
		
		//read json file data to String
		byte[] jsonData = Files.readAllBytes(Paths.get("employee.txt"));
		
		//create ObjectMapper instance
		ObjectMapper objectMapper = new ObjectMapper();
		
		//convert json string to object
		Employee emp = objectMapper.readValue(jsonData, Employee.class);
		
		System.out.println("Employee Object\n"+emp);
		
		//convert Object to json string
		Employee emp1 = createEmployee();
		//configure Object mapper for pretty print
		objectMapper.configure(SerializationFeature.INDENT_OUTPUT, true);
		
		//writing to console, can write to any output stream such as file
		StringWriter stringEmp = new StringWriter();
		objectMapper.writeValue(stringEmp, emp1);
		System.out.println("Employee JSON is\n"+stringEmp);
	}
	
	public static Employee createEmployee() {

		Employee emp = new Employee();
		emp.setId(100);
		emp.setName("David");
		emp.setPermanent(false);
		emp.setPhoneNumbers(new long[] { 123456, 987654 });
		emp.setRole("Manager");

		Address add = new Address();
		add.setCity("Bangalore");
		add.setStreet("BTM 1st Stage");
		add.setZipcode(560100);
		emp.setAddress(add);

		List<String> cities = new ArrayList<String>();
		cities.add("Los Angeles");
		cities.add("New York");
		emp.setCities(cities);

		Map<String, String> props = new HashMap<String, String>();
		props.put("salary", "1000 Rs");
		props.put("age", "28 years");
		emp.setProperties(props);

		return emp;
	}

}

Kur të ekzekutojmë programin e mësipërm, do të merrni rezultatin e mëposhtëm.

Employee Object
***** Employee Details *****
ID=123
Name=Pankaj
Permanent=true
Role=Manager
Phone Numbers=[123456, 987654]
Address=Albany Dr, San Jose, 95129
Cities=[Los Angeles, New York]
Properties={age=29 years, salary=1000 USD}
*****************************
Employee JSON is
//printing same as above json file data

com.fasterxml.jackson.databind.ObjectMapper është klasa më e rëndësishme në Jackson API që ofron metoda readValue() dhe writeValue() për të transformuar JSON në Java Object dhe Objekti Java në JSON. Klasa ObjectMapper mund të ripërdoret dhe mund ta inicializojmë një herë si objekt Singleton. Ka kaq shumë versione të mbingarkuara të metodave readValue() dhe writeValue() për të punuar me grup bajt, File, rrymë hyrëse/dalëse dhe objekte Reader/Writer.

Jackson JSON - Konvertimi i JSON në Hartë

Ndonjëherë kemi një objekt JSON si më poshtë, në skedarin data.txt:

{
  "name": "David",
  "role": "Manager",
  "city": "Los Angeles"
}

dhe ne duam ta konvertojmë atë në një Hartë dhe jo në një objekt java me të njëjtat veti dhe çelësa. Mund ta bëjmë shumë lehtë në Jackson JSON API me dy metoda me kodin e mëposhtëm:

//converting json to Map
byte[] mapData = Files.readAllBytes(Paths.get("data.txt"));
Map<String,String> myMap = new HashMap<String, String>();

ObjectMapper objectMapper = new ObjectMapper();
myMap = objectMapper.readValue(mapData, HashMap.class);
System.out.println("Map is: "+myMap);

//another way
myMap = objectMapper.readValue(mapData, new TypeReference<HashMap<String,String>>() {});
System.out.println("Map using TypeReference: "+myMap);

Pasi të ekzekutojmë fragmentin e mësipërm, marrim daljen e mëposhtme:

Map is: {name=David, role=Manager, city=Los Angeles}
Map using TypeReference: {name=David, role=Manager, city=Los Angeles}

Jackson JSON - Lexoni çelësin specifik JSON

Ndonjëherë ne kemi të dhëna json dhe ne jemi të interesuar vetëm për disa nga vlerat e çelësave, kështu që në atë rast konvertimi i të gjithë JSON në objekt nuk është një ide e mirë. Jackson JSON API ofron opsionin për të lexuar të dhënat json si pemë si DOM Parser dhe ne mund të lexojmë elementë specifikë të objektit JSON përmes kësaj. Kodi i mëposhtëm ofron një fragment për të lexuar hyrje të veçanta nga skedari json.

//read json file data to String
byte[] jsonData = Files.readAllBytes(Paths.get("employee.txt"));

//create ObjectMapper instance
ObjectMapper objectMapper = new ObjectMapper();

//read JSON like DOM Parser
JsonNode rootNode = objectMapper.readTree(jsonData);
JsonNode idNode = rootNode.path("id");
System.out.println("id = "+idNode.asInt());

JsonNode phoneNosNode = rootNode.path("phoneNumbers");
Iterator<JsonNode> elements = phoneNosNode.elements();
while(elements.hasNext()){
	JsonNode phone = elements.next();
	System.out.println("Phone No = "+phone.asLong());
}

Ne marrim daljen e mëposhtme kur ekzekutojmë fragmentin e kodit të mësipërm.

id = 123
Phone No = 123456
Phone No = 987654

Jackson JSON - Redakto dokumentin JSON

Jackson JSON Java API ofron metoda të dobishme për të shtuar, modifikuar dhe hequr çelësat nga të dhënat JSON dhe më pas mund ta ruajmë atë si skedar të ri json ose ta shkruajmë në çdo transmetim. Kodi i mëposhtëm na tregon se si ta bëjmë këtë me lehtësi.

byte[] jsonData = Files.readAllBytes(Paths.get("employee.txt"));

ObjectMapper objectMapper = new ObjectMapper();

//create JsonNode
JsonNode rootNode = objectMapper.readTree(jsonData);

//update JSON data
((ObjectNode) rootNode).put("id", 500);
//add new key value
((ObjectNode) rootNode).put("test", "test value");
//remove existing key
((ObjectNode) rootNode).remove("role");
((ObjectNode) rootNode).remove("properties");
objectMapper.writeValue(new File("updated_emp.txt"), rootNode);

Nëse do të ekzekutoni kodin e mësipërm dhe do të kërkoni skedarin e ri, do të vini re se ai nuk ka çelësin \role dhe \properties. Do të vini re gjithashtu se vlera \id është përditësuar në 500 dhe një çelës i ri \test është shtuar në skedarin updated_emp.txt.

Shembull i API-së së transmetimit të Jackson JSON

Jackson JSON Java API ofron gjithashtu mbështetje transmetimi që është e dobishme për të punuar me të dhëna të mëdha json sepse lexon të gjithë skedarin si shenja dhe përdor më pak memorie. Problemi i vetëm me API-në e transmetimit është se ne duhet të kujdesemi për të gjitha shenjat gjatë analizimit të të dhënave JSON. Nëse kemi të dhëna json si {\role:\Menaxheri} atëherë do të marrim shenjat e mëposhtme në rend - { (objekti i fillimit), \role (emri i çelësit), \Menaxheri (vlera kryesore) dhe } (objekt fundor). Dy pika (:) është kufiri në JSON dhe për këtë arsye nuk konsiderohet si shenjë.

package com.journaldev.jackson.json;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.journaldev.jackson.model.Address;
import com.journaldev.jackson.model.Employee;

public class JacksonStreamingReadExample {

	public static void main(String[] args) throws JsonParseException, IOException {
		
		//create JsonParser object
		JsonParser jsonParser = new JsonFactory().createParser(new File("employee.txt"));
		
		//loop through the tokens
		Employee emp = new Employee();
		Address address = new Address();
		emp.setAddress(address);
		emp.setCities(new ArrayList<String>());
		emp.setProperties(new HashMap<String, String>());
		List<Long> phoneNums = new ArrayList<Long>();
		boolean insidePropertiesObj=false;
		
		parseJSON(jsonParser, emp, phoneNums, insidePropertiesObj);
		
		long[] nums = new long[phoneNums.size()];
		int index = 0;
		for(Long l :phoneNums){
			nums[index++] = l;
		}
		emp.setPhoneNumbers(nums);
		
		jsonParser.close();
		//print employee object
		System.out.println("Employee Object\n\n"+emp);
	}

	private static void parseJSON(JsonParser jsonParser, Employee emp,
			List<Long> phoneNums, boolean insidePropertiesObj) throws JsonParseException, IOException {
		
		//loop through the JsonTokens
		while(jsonParser.nextToken() != JsonToken.END_OBJECT){
			String name = jsonParser.getCurrentName();
			if("id".equals(name)){
				jsonParser.nextToken();
				emp.setId(jsonParser.getIntValue());
			}else if("name".equals(name)){
				jsonParser.nextToken();
				emp.setName(jsonParser.getText());
			}else if("permanent".equals(name)){
				jsonParser.nextToken();
				emp.setPermanent(jsonParser.getBooleanValue());
			}else if("address".equals(name)){
				jsonParser.nextToken();
				//nested object, recursive call
				parseJSON(jsonParser, emp, phoneNums, insidePropertiesObj);
			}else if("street".equals(name)){
				jsonParser.nextToken();
				emp.getAddress().setStreet(jsonParser.getText());
			}else if("city".equals(name)){
				jsonParser.nextToken();
				emp.getAddress().setCity(jsonParser.getText());
			}else if("zipcode".equals(name)){
				jsonParser.nextToken();
				emp.getAddress().setZipcode(jsonParser.getIntValue());
			}else if("phoneNumbers".equals(name)){
				jsonParser.nextToken();
				while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
					phoneNums.add(jsonParser.getLongValue());
				}
			}else if("role".equals(name)){
				jsonParser.nextToken();
				emp.setRole(jsonParser.getText());
			}else if("cities".equals(name)){
				jsonParser.nextToken();
				while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
					emp.getCities().add(jsonParser.getText());
				}
			}else if("properties".equals(name)){
				jsonParser.nextToken();
				while(jsonParser.nextToken() != JsonToken.END_OBJECT){
					String key = jsonParser.getCurrentName();
					jsonParser.nextToken();
					String value = jsonParser.getText();
					emp.getProperties().put(key, value);
				}
			}
		}
	}

}

JsonParser është API-ja e transmetimit të jackson json për të lexuar të dhënat json, ne po e përdorim atë për të lexuar të dhënat nga skedari dhe më pas metoda parseJSON() përdoret për të kaluar nëpër tokenet dhe për t'i përpunuar ato për të krijuar objektin tonë java . Vini re se metoda parseJSON() thirret në mënyrë rekursive për \adresën sepse është një objekt i mbivendosur në të dhënat json. Për analizimin e vargjeve, ne jemi duke kaluar nëpër dokumentin json. Mund të përdorim klasën JsonGenerator për të gjeneruar të dhëna json me API të transmetimit.

package com.journaldev.jackson.json;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Set;

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
import com.journaldev.jackson.model.Employee;

public class JacksonStreamingWriteExample {

	public static void main(String[] args) throws IOException {
		Employee emp = JacksonObjectMapperExample.createEmployee();

		JsonGenerator jsonGenerator = new JsonFactory()
				.createGenerator(new FileOutputStream("stream_emp.txt"));
		//for pretty printing
		jsonGenerator.setPrettyPrinter(new DefaultPrettyPrinter());
		
		jsonGenerator.writeStartObject(); // start root object
		jsonGenerator.writeNumberField("id", emp.getId());
		jsonGenerator.writeStringField("name", emp.getName());
		jsonGenerator.writeBooleanField("permanent", emp.isPermanent());
		
		jsonGenerator.writeObjectFieldStart("address"); //start address object
			jsonGenerator.writeStringField("street", emp.getAddress().getStreet());
			jsonGenerator.writeStringField("city", emp.getAddress().getCity());
			jsonGenerator.writeNumberField("zipcode", emp.getAddress().getZipcode());
		jsonGenerator.writeEndObject(); //end address object
		
		jsonGenerator.writeArrayFieldStart("phoneNumbers");
			for(long num : emp.getPhoneNumbers())
				jsonGenerator.writeNumber(num);
		jsonGenerator.writeEndArray();
		
		jsonGenerator.writeStringField("role", emp.getRole());
		
		jsonGenerator.writeArrayFieldStart("cities"); //start cities array
		for(String city : emp.getCities())
			jsonGenerator.writeString(city);
		jsonGenerator.writeEndArray(); //closing cities array
		
		jsonGenerator.writeObjectFieldStart("properties");
			Set<String> keySet = emp.getProperties().keySet();
			for(String key : keySet){
				String value = emp.getProperties().get(key);
				jsonGenerator.writeStringField(key, value);
			}
		jsonGenerator.writeEndObject(); //closing properties
		jsonGenerator.writeEndObject(); //closing root object
		
		jsonGenerator.flush();
		jsonGenerator.close();
	}

}

JsonGenerator është i lehtë për t'u përdorur në krahasim me JsonParser. Kjo është e gjitha për një tutorial referimi të shpejtë për API Java Parser Jackson JSON. Jackson JSON Java API është i lehtë për t'u përdorur dhe ofron shumë opsione për lehtësinë e zhvilluesve që punojnë me të dhënat JSON. Shkarkoni projektin nga lidhja e mëposhtme dhe luani me të për të eksploruar më shumë opsione rreth Jackson Json API.

Shkarkoni Projektin Jackson JSON

Referenca: Faqja e Jackson GitHub