Peut Jackson être configuré pour la garniture avant/après les espaces de toutes les propriétés de la chaîne?

Exemple JSON (notez que la chaîne des espaces):

{ "aNumber": 0, "aString": "string   " }

Idéalement, le deserialised instance aurait un aString propriété avec une valeur de "chaîne" (c'est à dire sans les espaces). Cela semble être quelque chose qui est sans doute pris en charge, mais je ne le trouve pas (par exemple dans DeserializationConfig.Fonction).

Nous sommes à l'aide de Spring MVC 3.x si un Ressort à base de solution serait aussi bien.

J'ai essayé la configuration du Printemps WebDataBinder basée sur la suggestion dans un post sur le forum mais il ne semble pas fonctionner lors de l'utilisation d'un Jackson message converter:

@InitBinder
public void initBinder( WebDataBinder binder )
{
    binder.registerCustomEditor( String.class, new StringTrimmerEditor( " \t\r\n\f", true ) );
}

Êtes-vous sûr à 100%, les espaces ne sont pas à la valeur réelle? Parce que je n'ai jamais vu Jackson ce faire. Ou dites-vous que la classe que vous passez à Jackson a ces espaces intentionnellement, et vous voulez mettre en place Jackson pour le supprimer pour vous?
Je pensais que c'était assez clairement déclaré que les données des espaces à partir de la source et il veut configurer Jackson pour supprimer les espaces à droite sur la désérialisation.
C'est exact, nous n'avons aucune raison valable de garder de fuite (ou à la tête) les espaces présents dans l'arrivée d'un message JSON.

InformationsquelleAutor penfold | 2011-07-27

16

Avec un personnalisé deserializer, vous pouvez effectuer les opérations suivantes:
```
 <your bean>
 @JsonDeserialize(using=WhiteSpaceRemovalSerializer.class)
 public void setAString(String aString) {
    //body
 }

 <somewhere>
 public class WhiteSpaceRemovalDeserializer extends JsonDeserializer<String> {
     @Override
     public String deserialize(JsonParser jp, DeserializationContext ctxt) {
         //This is where you can deserialize your value the way you want.
         //Don't know if the following expression is correct, this is just an idea.
         return jp.getCurrentToken().asText().trim();
     }
 }
```
Cette solution implique que ce bean attribut sera toujours sérialisé de cette façon, et vous aurez à annoter chaque attribut que vous souhaitez être désérialisé de cette façon.
- Merci, même si je pense que cette.aString = aString.trim() est probablement plus facile 🙂 j'espère qu'il va être un élément dans une future version.
- Bien que ce soit plus facile, l'annotation assure la garniture ne se produit que lorsque le bean est créé par JSON désérialisation 🙂
- Pourquoi ne pas simplement enregistrer votre propre deserializer à l'échelle mondiale via le Module d'interface? Je ne peux pas penser à de mauvaises conséquences dans un typique Printemps app quand Jackson est utilisé uniquement pour les services web RESTful, pouvez-vous?
- Notez que si la post-combustion est utilisée, alors l'enregistrement d'un mondial deserializer ne fonctionne pas comme afterburner optimise ceux par défaut deserializers et ne permet pas l'personnalisés, à moins que annoté avec JsonDeserialize.
- Est-ce une bonne pratique en considérant la performance? Qu'advient-il si le champ texte est null je veux dire, si je rajoute de vérifications pour la valeur null ou si je veux enlever blanc aussi des espaces entre les mots, de caractères spéciaux, ne serait-ce pas ralentir le système? Performance sage, ne devrait-on pas cette conversion et de vérification de la faire dans le front-end?
- Je ne comprends pas la motivation de votre question. Si d'entrée de base de filtrage est un souci de performances, en premier lieu, je ne peux pas aider mais se demander comment écrire le code dans votre application. Non, c'est une opération simple et ne coûte pas la performance à tous.
- J'ai été vraiment prise en considération d'éventuelles options. Je commence mon projet, je veux juste vous faire pour éviter les retouches ou refactoring... Ma première idée était de créer une classe d'assistance avec un removeChars(objet regExp) de la méthode et des ressources couche je traiter mon entrée... quelque chose comme ça. Parce que je suis en utilisant des entités jpa et je ne suis pas à l'aise à propos de la décoration de chaque chaîne de caractères set méthode d'entre eux et il n'était pas sûr au sujet de la performance, c'est pourquoi j'ai demandé. Je pense que je vais juste lui donner un aller.
- Couple de choses; asText() est de me donner un "impossible de trouver le symbole d'erreur". Tout le reste résolu à jackson.de base, tout simplement pas cette méthode. Aussi, le lien que vous avez posté pour "custom deserializer" est cassé.
InformationsquelleAutor DCKing

Solution facile pour le Printemps de Démarrage des utilisateurs, il suffit d'ajouter que walv de SimpleModule extension à votre contexte d'application:

package com.example;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.deser.std.StdScalarDeserializer;
import com.fasterxml.jackson.databind.module.SimpleModule;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
public class StringTrimModule extends SimpleModule {

    public StringTrimModule() {
        addDeserializer(String.class, new StdScalarDeserializer<String>(String.class) {
            @Override
            public String deserialize(JsonParser jsonParser, DeserializationContext ctx) throws IOException,
                    JsonProcessingException {
                return jsonParser.getValueAsString().trim();
            }
        });
    }
}

Une autre façon de personnaliser Jackson est à ajouter les haricots de type com.fasterxml.jackson.databind.Module à votre contexte. Ils seront inscrits avec tous les bean de type ObjectMapper, en fournissant un mécanisme mondial pour contribuer modules personnalisés lorsque vous ajoutez de nouvelles fonctionnalités à votre application.

http://docs.spring.io/spring-boot/docs/current/reference/html/howto-spring-mvc.html#howto-customize-the-jackson-objectmapper

si vous êtes pas à l'aide de spring boot, vous devez vous inscrire à la StringTrimModule vous-même (vous n'avez pas besoin de les annoter avec @Component)

<bean class="org.springframework.http.converter.json.Jackson2Objec‌tMapperFactoryBean">
    <property name="modulesToInstall" value="com.example.StringTrimModule"/>
</bean

Comment peut-on ignorer cette coupe du processus pour certains domaines spécifiques? (ex. un champ de mot de passe)

InformationsquelleAutor Maciej Marczuk

Le problème de l'annotation @JsonDeserialize est que vous devez toujours vous rappeler de le mettre sur le setter.
Pour le faire à l'échelle mondiale "une fois et pour toujours" avec Spring MVC, je n'ai prochaines étapes:

pom.xml:

<dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.3.3</version>
</dependency>

Créer des ObjectMapper:

package com.mycompany;

    import java.io.IOException;
    import org.apache.commons.lang3.StringUtils;
    import com.fasterxml.jackson.core.JsonParser;
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.DeserializationContext;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.deser.std.StdScalarDeserializer;
    import com.fasterxml.jackson.databind.module.SimpleModule;

    public class MyObjectMapper extends ObjectMapper {

        public MyObjectMapper() {
            registerModule(new MyModule());
        }
    }

    class MyModule extends SimpleModule {

        public MyModule() {
            addDeserializer(String.class, new StdScalarDeserializer<String>  (String.class) {
                @Override
                public String deserialize(JsonParser jp, DeserializationContext  ctxt) throws IOException,
                    JsonProcessingException {
                    return StringUtils.trim(jp.getValueAsString());
                }
            });
        }
    }

Mise à jour du Printemps servlet-context.xml:

<bean id="objectMapper" class="com.mycompany.MyObjectMapper" />

    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper" ref="objectMapper" />
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

Cela semble une belle solution globale qui a été facile d'ajouter ma source de Démarrage de l'application déjà en utilisant un custom ObjectMapper: j'ai juste défini et enregistré "StringTrimmerModule" le long de ces lignes. (Même si j'ai préféré le bon vieux String.trim() pour les valeurs non null à la place des Communes StringUtils.)
Notez que si post-combustion est utilisée, alors il ne fonctionnera pas comme afterburner optimise ceux par défaut deserializers. Si c'est le cas, alors je suppose que vous êtes coincé avec @JsonDeserialize?
Quel est l'impact de cette solution sur JSON attributs qui ne sont pas des chaînes comme des nombres ou des valeurs booléennes
d'autres types seront ignorées parce que ce désérialisé est remplacé par String.class seulement.

InformationsquelleAutor walv

Pour le Printemps Démarrage, il suffit de créer un personnalisé deserializer comme documenté dans le manuel.

Voici mon code Groovy mais n'hésitez pas à l'adapter pour travailler en Java.

import com.fasterxml.jackson.core.JsonParser
import com.fasterxml.jackson.databind.DeserializationContext
import com.fasterxml.jackson.databind.JsonDeserializer
import org.springframework.boot.jackson.JsonComponent

import static com.fasterxml.jackson.core.JsonToken.VALUE_STRING

@JsonComponent
class TrimmingJsonDeserializer extends JsonDeserializer<String> {

    @Override
    String deserialize(JsonParser parser, DeserializationContext context) {
        parser.hasToken(VALUE_STRING) ? parser.text?.trim() : null
    }
}

InformationsquelleAutor adarshr

com.fasterxml.jackson.format

pom.xml

   <dependency>
      <groupId>com.fasterxml.jackson.dataformat</groupId>
      <artifactId>jackson-dataformat-csv</artifactId>
      <version>2.5.3</version>
    </dependency>

CsvUtil.java

     CsvSchema bootstrapSchema = CsvSchema.emptySchema().withHeader().sortedBy();
     CsvMapper mapper = new CsvMapper();
     mapper.enable(CsvParser.Feature.TRIM_SPACES);
     InputStream inputStream = ResourceUtils.getURL(fileName).openStream();
     MappingIterator<T> readValues =
          mapper.readerFor(type).with(bootstrapSchema).readValues(inputStream);

InformationsquelleAutor vanduc1102

Vous devez vous connecter pour publier un commentaire.