当前位置：首页 > 后端开发 > 正文

java中怎么使用gson

Java中使用Gson，需先添加依赖，如Maven中 com.google.code.gsongson8.9，创建Gson实例后，用 toJson()方法将Java对象转为JSON字符串，用 fromJson()方法将JSON字符串转为Java对象

Java中使用Gson进行JSON数据的处理,主要涉及序列化和反序列化两个过程，以下是详细的步骤和示例：

添加Gson依赖

需要在项目中引入Gson库,如果使用Maven，可以在pom.xml文件中添加以下依赖：

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

如果使用Gradle,可以在build.gradle文件中添加以下依赖：

implementation 'com.google.code.gson:gson:2.10.1'

基本用法

Java对象转JSON字符串（序列化）

假设我们有一个简单的Java类Person：

public class Person {
    private String name;
    private int age;
    private String email;
    // 构造函数、getter和setter方法
    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getEmail() { return email; }
}

我们可以使用Gson的toJson()方法将Person对象转换为JSON字符串：

import com.google.gson.Gson;
public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30, "alice@example.com");
        Gson gson = new Gson();
        String json = gson.toJson(person);
        System.out.println(json); // 输出: {"name":"Alice","age":30,"email":"alice@example.com"}
    }
}

JSON字符串转Java对象（反序列化）

我们可以使用Gson的fromJson()方法将JSON字符串转换为Person对象：

import com.google.gson.Gson;
public class Main {
    public static void main(String[] args) {
        String json = "{"name":"Bob","age":25,"email":"bob@example.com"}";
        Gson gson = new Gson();
        Person person = gson.fromJson(json, Person.class);
        System.out.println(person.getName()); // 输出: Bob
        System.out.println(person.getAge()); // 输出: 25
        System.out.println(person.getEmail()); // 输出: bob@example.com
    }
}

处理复杂对象和集合

Gson不仅可以处理简单的Java对象,还可以处理包含集合（如List、Map）的复杂对象。

嵌套对象

假设我们有一个包含Address对象的User类：

public class Address {
    private String city;
    private String street;
    // 构造函数、getter和setter方法
    public Address(String city, String street) {
        this.city = city;
        this.street = street;
    }
    public String getCity() { return city; }
    public String getStreet() { return street; }
}
public class User {
    private String name;
    private Address address;
    // 构造函数、getter和setter方法
    public User(String name, Address address) {
        this.name = name;
        this.address = address;
    }
    public String getName() { return name; }
    public Address getAddress() { return address; }
}

我们可以将User对象序列化为JSON：

import com.google.gson.Gson;
public class Main {
    public static void main(String[] args) {
        User user = new User("Alice", new Address("北京", "长安街"));
        Gson gson = new Gson();
        String json = gson.toJson(user);
        System.out.println(json); // 输出: {"name":"Alice","address":{"city":"北京","street":"长安街"}}
    }
}

处理List和Map

假设我们有一个包含Person对象的列表：

import java.util.ArrayList;
import java.util.List;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 30, "alice@example.com"));
        people.add(new Person("Bob", 25, "bob@example.com"));
        Gson gson = new Gson();
        String jsonList = gson.toJson(people);
        System.out.println(jsonList); // 输出: [{"name":"Alice","age":30,"email":"alice@example.com"},{"name":"Bob","age":25,"email":"bob@example.com"}]
        // 反序列化
        Type listType = new TypeToken<List<Person>>() {}.getType();
        List<Person> parsedPeople = gson.fromJson(jsonList, listType);
        for (Person p : parsedPeople) {
            System.out.println(p.getName());
        }
    }
}

自定义序列化和反序列化

默认的序列化和反序列化方式可能不满足需求,你可能需要格式化日期，或者忽略某些字段，Gson提供了自定义序列化器和反序列化器的机制来实现这些需求。

处理日期格式

假设我们需要将日期格式化为yyyy-MM-dd：

import com.google.gson.;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateAdapter implements JsonSerializer<Date>, JsonDeserializer<Date> {
    private final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    @Override
    public JsonElement serialize(Date date, Type type, JsonSerializationContext context) {
        return new JsonPrimitive(format.format(date));
    }
    @Override
    public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        try {
            return format.parse(json.getAsString());
        } catch (Exception e) {
            throw new JsonParseException(e);
        }
    }
}

我们可以使用GsonBuilder来注册这个自定义的适配器：

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import java.util.Date;
public class Main {
    public static void main(String[] args) {
        GsonBuilder builder = new GsonBuilder();
        builder.registerTypeAdapter(Date.class, new DateAdapter());
        Gson gson = builder.create();
        Date now = new Date();
        String jsonDate = gson.toJson(now);
        System.out.println(jsonDate); // 输出: 2025-07-15（假设当前日期是2025-07-15）
        Date parsedDate = gson.fromJson(jsonDate, Date.class);
        System.out.println(parsedDate); // 输出: Sun Jul 15 00:00:00 GMT 2025（假设当前日期是2025-07-15）
    }
}

常用配置

美化输出

Gson gson = new GsonBuilder().setPrettyPrinting().create();

空值处理

Gson gson = new GsonBuilder().serializeNulls().create();

字段命名策略

Gson gson = new GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES).create();

相关问答FAQs

问题1：Gson如何处理泛型集合？

答：Gson在处理泛型集合时，需要使用TypeToken来指定集合的类型，要将JSON数组反序列化为List<Person>，可以这样做：

Type listType = new TypeToken<List<Person>>() {}.getType();
List<Person> people = gson.fromJson(jsonArray, listType);

问题2：Gson如何忽略某些字段？

答：可以使用transient关键字或@Expose注解来控制字段的序列化和反序列化。

public class Person {
    private String name;
    private int age;
    @Expose private String email; // 只有标记了@Expose的字段才会被处理
    private transient String password; // transient字段不会被序列化和反序列化
va gson
0

相关文章