Biblioteca Java Gson

Java 常用类库Bibliotecas comunes de Java

Gson es una biblioteca de Java proporcionada por Google, que se utiliza para convertir objetos Java a representación JSON (serialización) y convertir cadenas JSON a objetos Java (deserialización).

Las principales características de Gson incluyen:

  • API simple y fácil de usar
  • No requiere agregar anotaciones en las clases Java (pero admite anotaciones)
  • Alto rendimiento
  • Soporte para genéricos
  • Soporte para serialización y deserialización personalizadas

Clases principales:

  • Gson: clase principal, proporciona métodos de serialización y deserialización

  • JsonElement: clase abstracta para elementos JSON

  • JsonObject: representación de objeto JSON

  • JsonArray: representación de array JSON

¿Por qué usar Gson?

En el desarrollo de Java, a menudo necesitamos manejar datos JSON en los siguientes escenarios:

  • Interactuar con API RESTful
  • Lectura y escritura de archivos de configuración
  • Persistencia de datos
  • Intercambio de datos entre diferentes sistemas

Gson ofrece una forma simple y eficiente de completar estas tareas, siendo más conveniente que el manejo JSON nativo de Java.

Uso básico de Gson

Agregar dependencia de Gson

Primero necesitas agregar la dependencia de Gson en el proyecto. Si usas Maven, puedes agregarla en pom.xml:

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

Un ejemplo sencillo de conversión mutua entre objetos Java y JSON:

Ejemplo

import com.google.gson.Gson;

public class GsonDemo {
    public static void main(String[] args) {
        Gson gson = new Gson();
       
        // Convertir objeto Java a JSON
        Person person = new Person(Zhang San, 30);
        String json = gson.toJson(person);
        System.out.println(json); // Salida: {"name":"Zhang San","age":30}
       
        // Convertir JSON a objeto Java
        Person parsedPerson = gson.fromJson(json, Person.class);
        System.out.println(parsedPerson.getName()); // Salida: Zhang San
    }
}

class Person {
    private String name;
    private int age;
   
    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
   
    // Método getter (Gson necesita getter/setter)
    public String getName() { return name; }
    public int getAge() { return age; }
}

Crear una instancia de Gson

Gson gson = new Gson();

Convertir objeto Java a JSON (serialización)

Ejemplo

class User {
    private String name;
    private int age;
   
    // Se omiten constructor, getters y setters
}

User user = new User(Zhang San, 25);
String json = gson.toJson(user);
// Salida: {"name":"Zhang San","age":25}

Convertir JSON a objeto Java (deserialización)

Ejemplo

String json = "{\"name\":\"Li Si\",\"age\":30}";
User user = gson.fromJson(json, User.class);
System.out.println(user.getName()); // Salida: Li Si

Funciones comunes

Manejo de colecciones

Ejemplo

// Serializar colección
List<Person> people = Arrays.asList(
    new Person(Wang Wu, 28),
    new Person(Zhao Liu, 32)
);
String jsonList = gson.toJson(people);

// Deserializar colección
Type listType = new TypeToken<List<Person>>(){}.getType();
List<Person> parsedPeople = gson.fromJson(jsonList, listType);

Manejo de fechas

Ejemplo

Gson gson = new GsonBuilder()
    .setDateFormat("yyyy-MM-dd HH:mm:ss")
    .create();

Date now = new Date();
String dateJson = gson.toJson(now);
Date parsedDate = gson.fromJson(dateJson, Date.class);

Procesamiento del modelo de árbol

Ejemplo

String json = "{\"name\":\"Li Si\",\"age\":25}";
JsonElement element = JsonParser.parseString(json);
JsonObject object = element.getAsJsonObject();
String name = object.get("name").getAsString();
int age = object.get("age").getAsInt();

Configuraciones comunes

Salida formateada

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

Manejo de valores nulos

Gson gson = new GsonBuilder()
    .serializeNulls() // 序列化null值
    .create();

Estrategia de nombres de campos

Gson gson = new GsonBuilder()
    .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
    .create();
// 会将userName转换为user_name

Características avanzadas de Gson

Manejo de objetos complejos

Gson puede manejar estructuras de datos complejas que incluyen objetos anidados, arrays, colecciones, etc.:

Ejemplo

class Order {
    private String orderId;
    private List<Product> products;
    // Se omite otro código
}

Order order = new Order("123", Arrays.asList(
    new Product(Teléfono móvil, 1, 2999.00),
    new Product(Auriculares, 2, 199.00)
));

String json = gson.toJson(order);

Uso de TypeToken para manejar genéricos

Cuando necesitas manejar colecciones genéricas, puedes usar TypeToken:

Ejemplo

String json = "[{\"name\":\"Manzana\",\"price\":5.5},{\"name\":\"Plátano\",\"price\":3.2}]";

Type productListType = new TypeToken<List<Product>>(){}.getType();
List<Product> products = gson.fromJson(json, productListType);

Serialización y deserialización personalizadas

Puedes personalizar la lógica de procesamiento implementando las interfaces JsonSerializer y JsonDeserializer:

Ejemplo

public class DateSerializer implements JsonSerializer<Date> {
    private static final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
   
    @Override
    public JsonElement serialize(Date date, Type type, JsonSerializationContext context) {
        return new JsonPrimitive(format.format(date));
    }
}

// Usar serializador personalizado
Gson gson = new GsonBuilder()
    .registerTypeAdapter(Date.class, new DateSerializer())
    .create();

Uso de anotaciones

Gson proporciona algunas anotaciones útiles:

Ejemplo

class User {
    @SerializedName("user_name")  // Nombre del campo JSON
    private String name;
   
    @Expose(serialize = false)   // No se incluye en la serialización
    private String password;
   
    @Since(1.0)                  // Control de versiones
    private String email;
}

Configuración de GsonBuilder

GsonBuilder ofrece varias opciones de configuración:

Ejemplo

Gson gson = new GsonBuilder()
    .setPrettyPrinting()         // Salida con formato
    .serializeNulls()           // Serializar valores null
    .setDateFormat("yyyy-MM-dd") // Formato de fecha
    .disableHtmlEscaping()       // Deshabilitar escape HTML
    .create();

Consideraciones de rendimiento

  • Reutiliza la instancia de Gson: Gson es seguro para subprocesos (thread-safe), se recomienda reutilizarla en lugar de crearla con frecuencia.
  • Para el procesamiento de grandes volúmenes de datos, considera usar la API de flujo (JsonReader/JsonWriter).
  • Las estructuras de objetos complejas pueden afectar el rendimiento

Comparación de Gson con otras bibliotecas JSON

Características Gson Jackson org.json
Facilidad de uso Alto Medio Alto
Rendimiento Medio Alto bajo
Integridad de funciones Alto Muy alta bajo
Soporte comunitario Alto Muy alto Medio

Resumen

Gson es una biblioteca de procesamiento JSON potente y simple, adecuada para la mayoría de los proyectos Java. Proporciona:

  • Diseño de API simple
  • Opciones de configuración flexibles
  • Buen rendimiento
  • Amplia variedad de funciones

Para necesidades simples de procesamiento JSON, Gson suele ser la primera opción de los desarrolladores Java. Para requisitos de alto rendimiento o escenarios complejos, se puede considerarJacksony otras bibliotecas.

Java 常用类库Bibliotecas comunes de Java

Otras extensiones