Jackson和Gson是Java中處理JSON的兩大主流庫，均支持對象與JSON的相互轉換。 2. 使用前需在Maven中添加對應依賴：Jackson使用jackson-databind，Gson使用gson。 3. 基本序列化反序列化操作中，Jackson通過ObjectMapper實現(xiàn)，Gson通過Gson實例完成。 4. 處理泛型集合時，Jackson使用TypeReference，Gson使用TypeToken。 5. 自定義序列化時，Jackson支持豐富註解（如@JsonProperty、@JsonIgnore）並可註冊模塊，Gson可通過TypeAdapter或JsonDeserializer實現(xiàn)。 6. 性能方面，Jackson通常更快、內存佔用更低，集成Spring Boot更緊密；Gson更簡單易用，適合小型項目或Android開發(fā)。 7. 常見註意事項包括：Gson需無參構造函數(shù)、日期格式需顯式設置、泛型需借助TypeToken或TypeReference。 8. 推薦在Spring項目中使用Jackson，在輕量級或Android項目中選擇Gson，兩者可共存但應按模塊保持一致性，最終選擇取決於生態(tài)系統(tǒng)和性能需求。

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 prototyping.

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
  mapper.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.

  以上是使用Jackson和Gson在Java與Json合作的詳細內容。更多資訊請關注PHP中文網其他相關文章！