Vue de mappage Spring MVC pour Google-GSON?

Personne ne sait si il y a un Spring MVC vue de cartographie pour Gson? Je suis à la recherche de quelque chose de semblable à org.springframework.web.servlet.vue.json.MappingJacksonJsonView.

Idéalement, il faudrait à mon ModelMap et de le rendre au JSON, en respectant mon renderedAttributes situé dans le ContentNegotiatingViewResolver déclaration

Nous avons l'intention d'utiliser Gson largement dans la demande telle qu'il semble plus sûr et mieux que Jackson. Cela dit, nous sommes en train suspendu par la nécessité d'avoir deux différents JSON bibliothèques afin de ne JSON native vues.

Merci d'avance!

[cross-posté sur Printemps forums]

source d'informationauteur Ted Pennings

  1. 11

    aweigold m'a fait le plus de chemin, mais, concrètement, à esquisser une solution pour le Printemps 3.1 Java en fonction de la configuration, voici ce que j'ai fait.

    Saisir GsonHttpMessageConverter.java de la printemps-android-repos-modèle projet.

    Enregistrer votre GsonHttpMessageConverter avec le message de convertisseurs dans votre MVC config.

    @EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {
  @Override
  public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    converters.add(new GsonHttpMessageConverter());
  }
}

    Le Printemps docs décrire ce processus, mais ne sont pas claires. Afin d'obtenir que cela fonctionne correctement, j'ai dû prolonger WebMvcConfigurerAdapterpuis remplacer configureMesageConverters. Après avoir fait cela, vous devriez être en mesure de faire ce qui suit dans votre méthode de contrôleur:

    @Controller
public class AppController {
  @RequestMapping(value = "messages", produces = MediaType.APPLICATION_JSON_VALUE)
  public List<Message> getMessages() {
    //.. Get list of messages
    return messages;
  }
}

    Et le tour est joué! Sortie JSON.

  2. 5

    Je vous recommande d'étendre AbstractView tout comme le MappingJacksonJsonView.

    Personnellement, JSON, je préfère utiliser @Responsebody, et il suffit de retourner l'objet plutôt que d'un modèle et de vue, ce qui rend plus facile à tester. Si vous souhaitez utiliser GSON pour cela, il suffit de créer un personnalisé HttpMessageConverter comme ceci:

    import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonParseException;
import com.google.gson.reflect.TypeToken;
import com.vitalimages.string.StringUtils;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractHttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.stereotype.Component;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.lang.reflect.Type;
import java.nio.charset.Charset;
import java.sql.Timestamp;
@Component
public class GSONHttpMessageConverter extends AbstractHttpMessageConverter<Object> {
public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
private GsonBuilder gsonBuilder = new GsonBuilder()
.excludeFieldsWithoutExposeAnnotation()
.setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ")
.registerTypeAdapter(Timestamp.class, new GSONTimestampConverter());
public GSONHttpMessageConverter() {
super(new MediaType("application", "json", DEFAULT_CHARSET));
}
@Override
protected boolean supports(Class<?> clazz) {
//should not be called, since we override canRead/Write instead
throw new UnsupportedOperationException();
}
@Override
public boolean canRead(Class<?> clazz, MediaType mediaType) {
return MediaType.APPLICATION_JSON.isCompatibleWith(mediaType);
}
public boolean canWrite(Class<?> clazz, MediaType mediaType) {
return MediaType.APPLICATION_JSON.isCompatibleWith(mediaType);
}
public void registerTypeAdapter(Type type, Object serializer) {
gsonBuilder.registerTypeAdapter(type, serializer);
}
@Override
protected Object readInternal(Class<? extends Object> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
try {
Gson gson = gsonBuilder.create();
return    gson.fromJson(StringUtils.convertStreamToString(inputMessage.getBody()), clazz);
} catch (JsonParseException e) {
throw new HttpMessageNotReadableException("Could not read JSON: " + e.getMessage(), e);
}
}
@Override
protected void writeInternal(Object o, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
Type genericType = TypeToken.get(o.getClass()).getType();
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputMessage.getBody(), DEFAULT_CHARSET));
try {
//See http://code.google.com/p/google-gson/issues/detail?id=199 for details on SQLTimestamp conversion
Gson gson = gsonBuilder.create();
writer.append(gson.toJson(o, genericType));
} finally {
writer.flush();
writer.close();
}
}
}

    Puis l'ajouter à votre convertisseur de liste dans votre gestionnaire d'adaptateur comme ceci:

    @Bean
public HandlerAdapter handlerAdapter() {
final AnnotationMethodHandlerAdapter handlerAdapter = new AnnotationMethodHandlerAdapter();
handlerAdapter.setAlwaysUseFullPath(true);
List<HttpMessageConverter<?>> converterList = new ArrayList<HttpMessageConverter<?>>();
converterList.addAll(Arrays.asList(handlerAdapter.getMessageConverters()));
converterList.add(jibxHttpMessageConverter);
converterList.add(gsonHttpMessageConverter);
handlerAdapter.setMessageConverters(converterList.toArray(new HttpMessageConverter<?>[converterList.size()]));
return handlerAdapter;
}