Jackson and Gson are two mainstream libraries in Java that handle JSON, both supporting the mutual conversion of objects and JSON. 2. Before using it, you need to add the corresponding dependencies in Maven: Jackson uses jackson-databind, and Gson uses gson. 3. In the basic serialization deserialization operation, Jackson is implemented through ObjectMapper and Gson is completed through Gson instance. 4. When processing generic collections, Jackson uses TypeReference and Gson uses TypeToken. 5. When custom serialization, Jackson supports rich annotations (such as @JsonProperty, @JsonIgnore) and can register modules. Gson can be implemented through TypeAdapter or JsonDeserializer. 6. In terms of performance, Jackson is usually faster, has lower memory footprint, and is more compact in integration with Spring Boot; Gson is simpler and easier to use, suitable for small projects or Android development. 7. Common precautions include: Gson needs to have no parameter constructor, date format needs to be explicitly set, and generics need to use TypeToken or TypeReference. 8. It is recommended to use Jackson in Spring projects, and choose Gson in lightweight or Android projects. The two can coexist but should be consistent by module. The final choice depends on ecosystem and performance requirements.

Working with JSON in Java has become a standard part of modern application development—especially in REST APIs, microservices, and data serialization. Two of the most popular libraries for handling JSON in Java are Jackson and Gson . Both are powerful, widely used, and well-documented, but they have different design philosophies, performance characteristics, and usage patterns.

Here's a practical comparison and guide on how to use both.

1. Adding Dependencies

Before using either library, you need to include them in your project.

For Jackson:

Add to pom.xml (Maven):

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

For Gson:

 <dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

2. Basic Object to JSON and Back

Let's assume we have a simple POJO:

 public class User {
    private String name;
    private int age;

    // Constructors (required for Gson deserialization if no setters)
    public User() {}

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getters and setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    @Override
    public String toString() {
        return "User{name='" name "', age=" age "}";
    }
}

Using Jackson:

 import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper mapper = new ObjectMapper();

User user = new User("Alice", 30);

// Object to JSON
String json = mapper.writeValueAsString(user);
System.out.println(json); // {"name":"Alice","age":30}

// JSON to Object
User deserialized = mapper.readValue(json, User.class);
System.out.println(deserialized);

Using Gson:

 import com.google.gson.Gson;

Gson gson = new Gson();

User user = new User("Bob", 25);

// Object to JSON
String json = gson.toJson(user);
System.out.println(json); // {"name":"Bob","age":25}

// JSON to Object
User deserialized = gson.fromJson(json, User.class);
System.out.println(deserialized);

3. Handling Nested Objects and Collections

Both libraries handle nested objects and collections seamlessly.

Example:

 List<User> users = Arrays.asList(
    new User("Alice", 30),
    new User("Bob", 25)
);

With Jackson:

 String json = mapper.writeValueAsString(users);
List<User> list = mapper.readValue(json, new TypeReference<List<User>>(){});

With Gson:

 String json = gson.toJson(users);
List<User> list = gson.fromJson(json, new TypeToken<List<User>>(){}.getType());

Note: Gson requires TypeToken for generic types. Jackson uses TypeReference .

4. Custom Serialization and Deserialization

Sometimes you need to customize how fields are (de)serialized.

Jackson: Using Annotations

 public class User {
    @JsonProperty("full_name")
    private String name;

    @JsonIgnore
    private int age;

    // ...
}

Or register custom serializers/deserializers via SimpleModule .

Gson: Using TypeAdapter or JsonSerializer

 Gson gson = new GsonBuilder()
    .registerTypeAdapter(User.class, new JsonDeserializer<User>() {
        @Override
        public User deserialize(JsonElement json, Type typeOfT,
                                JsonDeserializationContext context) {
            JsonObject obj = json.getAsJsonObject();
            String name = obj.get("name").getAsString();
            int age = obj.has("age") ? obj.get("age").getAsInt() : 0;
            return new User(name, age);
        }
    })
    .create();

Jackson offers more built-in annotations and better integration with frameworks like Spring.

5. Performance and Use Case Considerations

Jackson is often preferred in enterprise and high-performance environments.
Gson is simpler for basic use cases and quick prototype.

6. Common Pitfalls

• No-arg constructor : Gson requires a no-arg constructor for classes (unless using @JsonCreator or custom deserializer).

• Generic types : Always use TypeToken (Gson) or TypeReference (Jackson) for List<T> , Map<K,V> , etc.

• Date formatting : Both support custom date formats:

   // Jackson
  mappper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd"));
  
  // Gson
  new GsonBuilder().setDateFormat("yyyy-MM-dd").create();

  ---

  Final Thoughts

  • Use Jackson if you're building a Spring-based application or need high performance and fine-grained control.
  • Use Gson if you want simplicity, fewer dependencies, and are working on smaller or Android-based projects.

  You can even use both in the same project if needed—just be consistent per module.

  Basically, it comes down to your ecosystem and performance needs. Both get the job done well.

  The above is the detailed content of Working with JSON in Java using Jackson and Gson. For more information, please follow other related articles on the PHP Chinese website!