Converting Java objects to JSON with Jackson

java

serialization

json-serialization

jackson-library

byAlex Kataev·Jan 17, 2025

Quickly convert Java objects to JSON using Jackson and ObjectMapper's writeValueAsString(). Example below:

import com.fasterxml.jackson.databind.ObjectMapper;

// Prepare your Java object for its voyage to JSON land
SomeClass obj = new SomeClass();

// Commence the voyage!
String json = new ObjectMapper().writeValueAsString(obj);

// Congrats! Your object is now in JSON land.
System.out.println(json);

Substitute SomeClass with your class. This code snippet shows you how Jackson turns a Java object into a JSON string.

How to setup Jackson in your project

In order to use Jackson, first ensure its library exists in your project. You can add the Jackson library through Maven or Gradle.

For Maven, let the pom.xml know that you want Jackson onboard:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.1</version> <!-- Newest version of Jackson at the time of writing -->
</dependency>

For Gradle, drop this line in your build.gradle file:

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

Ensure you have the latest version of Jackson to make use of all its recent features and benefits.

Beyond simple serialization: Jackson's advanced features

Jackson is not just a one-trick pony; it can do much more than simple serialization. Using annotations and module registrations, you can customize serialization to fit your needs.

Custom types and collections

Did Jackson just throw a tantrum because your Java class didn't play nice with JSON? Fret not! Annotations like @JsonProperty and @JsonFormat tell Jackson exactly how to serialize custom types and collections:

public class User {
    private String name;
    
    // Because Jackson likes your date in a particular format
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
    private Date birthDate;
    // getters and setters...
}

Pretty print your JSON

Jackson also knows how to make your JSON look pretty with its writerWithDefaultPrettyPrinter() method:

// ObjectMapper putting on its best suit
String prettyJson = new ObjectMapper()
    .writerWithDefaultPrettyPrinter()
    .writeValueAsString(obj);
    
// Your JSON is ready to hit the JSON catwalk
System.out.println(prettyJson);

Use custom ObjectWriter for repeated use

Keep those bytes dry (Don't Repeat Yourself) with a customized ObjectWriter:

// Create your tailored suit, err... I mean ObjectWriter
ObjectWriter writer = new ObjectMapper().writer(new DefaultPrettyPrinter());

// Dress up your object any time you want
String json = writer.writeValueAsString(obj);

This allows you to reuse your ObjectWriter with just the right configuration each time.

Dealing with potential errors & troubleshooting

Programming is not without its fair share of bugs 🐛. When using Jackson, you may encounter issues such as malformed JSON or problems with the serialization structure of your classes.

Handling exceptions intelligently

Just like in life, when something goes wrong in code, we use try-catch:

try {
    // Because sometimes things don’t go as planned
    String json = new ObjectMapper().writeValueAsString(obj);
} catch (JsonProcessingException e) {
    // Tell the console all about your problems...
    e.printStackTrace(); // Maybe use a logger here... or you could have a conversation with the console.
}

Ensuring class structure compatibility

Check that your Java classes and annotations match your JSON's schema. Remember, Jackson doesn't like surprises!

Writing JSON to file and streaming output

If you want to channel your inner writer and start writing JSON to a file or data stream, then be our guest:

// And... action! Direct your JSON to file
new ObjectMapper().writeValue(new File("output.json"), obj);

Go the other way: Deserialize JSON to Java objects

To turn your JSON back into a Java object, use:

// The return trip from JSON land
SomeClass obj = new ObjectMapper().readValue(jsonString, SomeClass.class);

Armed with the knowledge of serialization (⇄), you're ready to converse in Fluent JSONese!

Gson vs. Jackson: A tale of two libraries

If Jackson feels a tad bit overwhelming, then Google's Gson library might be your cup of tea☕. To make a choice between the two:

Gson is straightforward, providing toJson() and fromJson() methods.
On the other hand, Jackson's extensive annotation library and streaming capabilities might tip the scales ⚖️ in its favor for larger projects.