Json in Mercury

Java offers built-in support for JSON encoding and decoding, including to and from built-in and custom data types. We’ll use the popular Jackson library for JSON processing in Java.

First, let’s define our custom types:

import com.fasterxml.jackson.annotation.JsonProperty;

class Response1 {
    public int page;
    public String[] fruits;
}

class Response2 {
    @JsonProperty("page")
    public int page;
    
    @JsonProperty("fruits")
    public String[] fruits;
}

Now, let’s look at the main method where we’ll perform JSON encoding and decoding:

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.*;

public class JsonExample {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();

        // First we'll look at encoding basic data types to JSON strings.
        // Here are some examples for atomic values.
        System.out.println(mapper.writeValueAsString(true));
        System.out.println(mapper.writeValueAsString(1));
        System.out.println(mapper.writeValueAsString(2.34));
        System.out.println(mapper.writeValueAsString("gopher"));

        // And here are some for slices and maps, which encode
        // to JSON arrays and objects as you'd expect.
        List<String> slcD = Arrays.asList("apple", "peach", "pear");
        System.out.println(mapper.writeValueAsString(slcD));

        Map<String, Integer> mapD = new HashMap<>();
        mapD.put("apple", 5);
        mapD.put("lettuce", 7);
        System.out.println(mapper.writeValueAsString(mapD));

        // The Jackson library can automatically encode your
        // custom data types.
        Response1 res1D = new Response1();
        res1D.page = 1;
        res1D.fruits = new String[]{"apple", "peach", "pear"};
        System.out.println(mapper.writeValueAsString(res1D));

        // You can use annotations on class field declarations
        // to customize the encoded JSON key names.
        Response2 res2D = new Response2();
        res2D.page = 1;
        res2D.fruits = new String[]{"apple", "peach", "pear"};
        System.out.println(mapper.writeValueAsString(res2D));

        // Now let's look at decoding JSON data into Java values.
        // Here's an example for a generic data structure.
        String byt = "{\"num\":6.13,\"strs\":[\"a\",\"b\"]}";

        // We need to provide a type where the Jackson library
        // can put the decoded data. This Map<String, Object>
        // will hold a map of strings to arbitrary data types.
        Map<String, Object> dat = mapper.readValue(byt, Map.class);
        System.out.println(dat);

        // In order to use the values in the decoded map,
        // we'll need to cast them to their appropriate type.
        double num = (Double) dat.get("num");
        System.out.println(num);

        // Accessing nested data requires a series of casts.
        List<String> strs = (List<String>) dat.get("strs");
        String str1 = strs.get(0);
        System.out.println(str1);

        // We can also decode JSON into custom data types.
        String str = "{\"page\": 1, \"fruits\": [\"apple\", \"peach\"]}";
        Response2 res = mapper.readValue(str, Response2.class);
        System.out.println(res.page);
        System.out.println(res.fruits[0]);

        // In the examples above we always used strings as
        // intermediates between the data and JSON representation.
        // We can also stream JSON encodings directly to Writers.
        mapper.writeValue(System.out, mapD);
    }
}

To run this program, you’ll need to include the Jackson library in your project. You can do this by adding the following dependency to your Maven pom.xml file:

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

Or if you’re using Gradle, add this to your build.gradle file:

implementation 'com.fasterxml.jackson.core:jackson-databind:2.12.3'

When you run this program, you should see output similar to the following:

true
1
2.34
"gopher"
["apple","peach","pear"]
{"apple":5,"lettuce":7}
{"page":1,"fruits":["apple","peach","pear"]}
{"page":1,"fruits":["apple","peach","pear"]}
{num=6.13, strs=[a, b]}
6.13
a
1
apple
{"apple":5,"lettuce":7}

We’ve covered the basics of JSON in Java here, but check out the Jackson library documentation for more advanced features and options.

Random Numbers in Mercury

Xml in Mercury

Learn X By Example

Title here

Json in Mercury