A JSONObject can parse the text from String to produce a Map kind of an object. An Enum can be used to define a collection of constants, when we need a predefined list of values which do not represent some kind of numeric or textual data then we can use an enum. We can convert a JSON object to an enum using the readValue() method of ObjectMapper class.In the below example, we can convert/deserialize a JSON object to Java enum using the Jackson library.Exampleimport com.fasterxml.jackson.databind.*; public class JSONToEnumTest {    public static void main(String arg[]) throws Exception {       ObjectMapper mapper ... Read More

The Jackson @JsonInclude annotation can be used to exclude the properties or fields of a class under certain conditions and it can be defined using the JsonInclude.Include enum. The JsonInclude.Include enum contains few constants like "ALWAYS", "NON_DEFAULT", "NON_EMPTY" and "NON_NULL" to determine whether to exclude the property(field) or not.Syntaxpublic static enum JsonInclude.Include extends EnumExampleimport com.fasterxml.jackson.annotation.*; import com.fasterxml.jackson.databind.*; import java.io.*; public class JsonIncludeTest {    public static void main(String args[]) throws IOException {       ObjectMapper objectMapper = new ObjectMapper();       Employee emp = new Employee();       String jsonString = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(emp);       System.out.println(jsonString);    } } // Employee class ... Read More

A JSONObject is an unordered collection of a key, value pairs, and the values can be any of these types like Boolean, JSONArray, JSONObject, Number and String. The constructor of a JSONObject can be used to convert an external form JSON text into an internal form whose values can be retrieved with the get() and opt() methods or to convert values into a JSON text using the put() and toString() methods.In the below example, we can sort the values of a JSONObject in the descending order.Exampleimport org.json.*; import java.util.*; public class JSonObjectSortingTest {    public static void main(String[] args) {       ... Read More

The Jackson @JacksonInject annotation can be used to inject the values into parsed objects instead of reading those values from the JSON. In order to inject values into a field, we can use the InjectableValues class and need to configure the ObjectMapper class to read both the injected values from the InjectableValues class and the remaining values from the JSON string.Syntax@Target(value={ANNOTATION_TYPE, METHOD, FIELD, PARAMETER}) @Retention(value=RUNTIME) public @interface JacksonInjectExampleimport com.fasterxml.jackson.annotation.*; import com.fasterxml.jackson.databind.*; import java.io.*; public class JacksonInjectTest {    public static void main(String args[]) throws IOException {       String jsonString = "{\"empName\": \"Raja Ramesh\"}";       InjectableValues injectableValues = new InjectableValues.Std().addValue(int.class, 110); ... Read More

The Jackson @JsonIgnoreType annotation can be used to ignore a class during the serialization process and it can mark all the properties or fields of a class to be ignored while serializing and deserializing a JSON object.Syntax@Target(value={ANNOTATION_TYPE, TYPE}) @Retention(value=RUNTIME) public @interface JsonIgnoreTypeExampleimport com.fasterxml.jackson.annotation.*; import com.fasterxml.jackson.core.*; import com.fasterxml.jackson.databind.*; import java.io.*; public class JsonIgnoreTypeTest {    public static void main(String args[]) throws IOException {       Employee emp = new Employee();       ObjectMapper mapper = new ObjectMapper();       String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(emp);       System.out.println(jsonString);    } } // Employee class class Employee {    @JsonIgnoreType    public static class Address {   ... Read More

A Gson is a json library for Java and it can be used to generate a JSON. In the initial step, we can read a JSON file and parsing to a Java object then need to typecast the Java object to a JSonObject and parsing to a JsonArray. Then iterating this JSON array to print the JsonElement. We can create a JsonWriter class to write a JSON encoded value to a stream, one token at a time. Finally, a new JSON string can be written to an existing json file. Exampleimport java.io.*; import java.util.*; import com.google.gson.*; import com.google.gson.stream.*; import com.google.gson.annotations.*; public class JSONFilewriteTest {   ... Read More

The @JsonAutoDetect annotation can be used at the class level to override the visibility of the properties of a class during serialization and deserialization. We can set the visibility with the properties like "creatorVisibility", "fieldVisibility", "getterVisibility", "setterVisibility" and "isGetterVisibility". The JsonAutoDetect class can define public static constants that are similar to Java class visibility levels like "ANY", "DEFAULT", "NON_PRIVATE", "NONE", "PROTECTED_AND_PRIVATE" and "PUBLIC_ONLY".Exampleimport com.fasterxml.jackson.annotation.*; import com.fasterxml.jackson.databind.*; import java.io.*; public class JsonAutoDetectTest {    public static void main(String[] args) throws IOException {       Address address = new Address("Madhapur", "Hyderabad", "Telangana");       Name name = new Name("Raja", "Ramesh");       Student student ... Read More

The Gson @SerializedName annotation can be serialized to a JSON with the provided name value as its field name. This annotation can override any FieldNamingPolicy including the default field naming policy that may have been set on the Gson instance. A different naming policy can set using the GsonBuilder class.Syntax@Retention(value=RUNTIME) @Target(value={FIELD, METHOD}) public @interface SerializedNameExampleimport com.google.gson.annotations.*; import com.google.gson.*; public class SerializedNameAnnotationTest {    public static void main(String args[]) {       Employee emp = new Employee("Rahul", "Dev", 30, "Nagpur");       Gson gson = new GsonBuilder().setPrettyPrinting().create(); // pretty print       String jsonStr = gson.toJson(emp);       System.out.println(jsonStr);    } ... Read More

The @JsonIgnoreProperties Jackson annotation can be used to specify a list of properties or fields of a class to ignore. The @JsonIgnoreProperties annotation can be placed above the class declaration instead of above the individual properties or fields to ignore.Syntax@Target(value={ANNOTATION_TYPE, TYPE, METHOD, CONSTRUCTOR, FIELD}) @Retention(value=RUNTIME) public @interface JsonIgnorePropertiesExampleimport java.io.*; import com.fasterxml.jackson.annotation.*; import com.fasterxml.jackson.databind.*; public class JsonIgnorePropertiesTest {    public static void main(String[] args) throws IOException {       Customer customer = new Customer("120", "Ravi", "Hyderabad");       System.out.println(customer);       ObjectMapper mapper = new ObjectMapper();       String jsonString = mapper.writeValueAsString(customer);       System.out.println("JSON: " + jsonString);     ... Read More

The Flexjson is a lightweight library for serializing and deserializing Java objects into and from JSON format. A JSONSerializer is the main class for performing serialization of Java objects to JSON. We can serialize a JSON string to an Output Handler using the WriterOutputHandler class and it implements the OutputHandler interface.Syntaxpublic class WriterOutputHandler extends Object implements OutputHandlerExampleimport java.io.*; import flexjson.JSONSerializer; import flexjson.OutputHandler; import flexjson.WriterOutputHandler; public class JsonOutputHandlerTest {    public static void main(String[] args) {       JSONSerializer serializer = new JSONSerializer().prettyPrint(true); // pretty print JSON       Employee emp = new Employee("Raja", "Ramesh", 28, "Hyderabad");       OutputHandler out = new WriterOutputHandler(new ... Read More