GSON - Format de date

J'essaie d'avoir un format de date personnalisé dans la sortie Gson, mais .setDateFormat(DateFormat.FULL)ne semble pas fonctionner et c'est la même chose avec.registerTypeAdapter(Date.class, new DateSerializer()) .

C'est comme si Gson ne se souciait pas de l'objet "Date" et l'imprimait à sa manière.

Comment puis-je changer cela?

Merci

ÉDITER:

@Entity
public class AdviceSheet {
  public Date lastModif;
[...]
}

public void method {
   Gson gson = new GsonBuilder().setDateFormat(DateFormat.LONG).create();
   System.out.println(gson.toJson(adviceSheet);
}

J'utilise toujours java.util.Date; setDateFormat()ne fonctionne pas :(

Il semble que vous deviez définir des formats pour la partie date et heure ou utiliser un formatage basé sur une chaîne. Par exemple:

Gson gson = new GsonBuilder()
   .setDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz").create();

ou en utilisant java.text.DateFormat

Gson gson = new GsonBuilder()
   .setDateFormat(DateFormat.FULL, DateFormat.FULL).create();

ou faites-le avec des sérialiseurs:

Je crois que les formateurs ne peuvent pas produire d'horodatages, mais cette paire sérialiseur / désérialiseur semble fonctionner

JsonSerializer<Date> ser = new JsonSerializer<Date>() {
  @Override
  public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext 
             context) {
    return src == null ? null : new JsonPrimitive(src.getTime());
  }
};

JsonDeserializer<Date> deser = new JsonDeserializer<Date>() {
  @Override
  public Date deserialize(JsonElement json, Type typeOfT,
       JsonDeserializationContext context) throws JsonParseException {
    return json == null ? null : new Date(json.getAsLong());
  }
};

Gson gson = new GsonBuilder()
   .registerTypeAdapter(Date.class, ser)
   .registerTypeAdapter(Date.class, deser).create();

Si vous utilisez Java 8 ou supérieur, vous devez utiliser les sérialiseurs / désérialiseurs ci-dessus comme suit:

JsonSerializer<Date> ser = (src, typeOfSrc, context) -> src == null ? null
            : new JsonPrimitive(src.getTime());

JsonDeserializer<Date> deser = (jSon, typeOfT, context) -> jSon == null ? null : new Date(jSon.getAsLong());

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

Le format ci-dessus me semble meilleur car il a une précision allant jusqu'à millis.

Comme ML l'a souligné, JsonSerializer fonctionne ici. Cependant, si vous formatez des entités de base de données, utilisez java.sql.Date pour enregistrer votre sérialiseur. Le désérialiseur n'est pas nécessaire.

Gson gson = new GsonBuilder()
   .registerTypeAdapter(java.sql.Date.class, ser).create();

Ce rapport de bogue peut être lié: http://code.google.com/p/google-gson/issues/detail?id=230 . J'utilise la version 1.7.2 cependant.

Si vous détestez les classes Inner, en tirant parti de l'interface fonctionnelle, vous pouvez écrire moins de code en Java 8 avec une expression lambda.

JsonDeserializer<Date> dateJsonDeserializer = 
     (json, typeOfT, context) -> json == null ? null : new Date(json.getAsLong());
Gson gson = new GsonBuilder().registerTypeAdapter(Date.class,dateJsonDeserializer).create();

Cela ne fonctionnera pas vraiment du tout. Il n'y a pas de type de date dans JSON. Je recommanderais de sérialiser vers ISO8601 dans les deux sens (pour les formats indépendants et la compatibilité JS). Considérez que vous devez savoir quels champs contiennent des dates.

Vous pouvez spécifier votre format Gson gson = builder.setDateFormat("yyyy-MM-dd").create(); dans cette méthode au lieu d' yyyy-MM-ddutiliser d'autres formats

 GsonBuilder builder = new GsonBuilder();
                        builder.registerTypeAdapter(Date.class, new JsonDeserializer<Date>() {
                            public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
                                return new Date(json.getAsJsonPrimitive().getAsLong());
                            }
                        });

                        Gson gson = builder.setDateFormat("yyyy-MM-dd").create();

Ceci est un bug . Actuellement, vous devez également définir un timeStyleou utiliser l'une des alternatives décrites dans les autres réponses.

Je suis sur Gson 2.8.6 et j'ai découvert ce bogue aujourd'hui.

Mon approche permet à tous nos clients existants (mobile / web / etc) de continuer à fonctionner comme ils l'étaient, mais ajoute une certaine manipulation pour ceux qui utilisent des formats 24h et autorise aussi des millis, pour faire bonne mesure.

Gson rawGson = new Gson();
SimpleDateFormat fmt = new SimpleDateFormat("MMM d, yyyy HH:mm:ss")
private class DateDeserializer implements JsonDeserializer<Date> {
    @Override
    public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
            throws JsonParseException {
        try {
            return new rawGson.fromJson(json, Date.class);
        } catch (JsonSyntaxException e) {}
        String timeString = json.getAsString();
        log.warning("Standard date deserialization didn't work:" + timeString);
        try {
            return fmt.parse(timeString);
        } catch (ParseException e) {}
        log.warning("Parsing as json 24 didn't work:" + timeString);
        return new Date(json.getAsLong());
    }
}

Gson gson = new GsonBuilder()
    .registerTypeAdapter(Date.class, new DateDeserializer())
    .create();

J'ai gardé la même sérialisation car tous les clients comprennent le format de date json standard.

Normalement, je ne pense pas que ce soit une bonne pratique d'utiliser des blocs try / catch, mais cela devrait être un cas assez rare.