Kann Jackson so konfiguriert werden, dass er führende / nachfolgende Leerzeichen aus allen String-Eigenschaften trimmt?

Beispiel JSON (beachten Sie, dass der string Leerzeichen):

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

Ideal, die deserialised Instanz hätte eine aString Eigenschaft mit einem Wert von "string" (also ohne Leerzeichen). Dies scheint wie etwas, das wird wohl unterstützt, aber ich kann es nicht finden (z.B. in DeserializationConfig.Feature).

Wir sind mit Spring MVC 3.x so eine Feder-basierte Lösung wäre auch in Ordnung.

Habe ich versucht die Konfiguration von Spring WebDataBinder basiert auf einem Vorschlag in einem forum-post aber es scheint nicht zu funktionieren, wenn mit einem Jackson message converter:

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

InformationsquelleAutor der Frage penfold | 2011-07-27

Mit einem benutzerdefinierte deserializerkönnen Sie das folgende tun:

 <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();
     }
 }

Diese Lösung bedeutet, dass die bean-Attribut wird immer serialisiert werden, diese Weise, und Sie müssen kommentieren jedes Attribut, das Sie wollen deserialisiert werden auf diese Weise.

InformationsquelleAutor der Antwort DCKing

Einfache Lösung für die Spring-Boot-Benutzer, nur hinzufügen, dass walv ist SimpleModule Erweiterung zu Ihrer Anwendung Kontext:

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();
            }
        });
    }
}

Eine weitere Möglichkeit zur Anpassung Jackson ist das hinzufügen von Bohnen des Typs com.fasterxml.jackson.databind-Methode.Modul zu Ihrem Kontext. Sie werden registriert, mit jedem bean-Typ ObjectMapper, die Bereitstellung eines globalen Mechanismus für den Beitrag custom Module, wenn Sie neue features hinzufügen, um Ihre Anwendung.

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

wenn Sie nicht mit spring boot, müssen Sie Sie registrieren die StringTrimModule sich selbst (Sie brauchen nicht zu kommentieren mit @Component)

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

InformationsquelleAutor der Antwort Maciej Marczuk

Das problem der annotation @JsonDeserialize ist, dass Sie müssen immer daran denken, es zu setzen on der setter.
Um es Global zu "einmal und für immer" mit Spring MVC, habe ich die nächsten Schritte:

pom.xml:

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

Erstellen von benutzerdefinierten 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());
                }
            });
        }
    }

Update Spring 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>

InformationsquelleAutor der Antwort walv

Für Spring Boot, wir müssen einfach erstellen Sie eine benutzerdefinierte deserializer als im Handbuch dokumentiert.

Das folgende ist meine Groovy-code, aber fühlen Sie sich frei, um eine Anpassung an die Arbeit in 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 der Antwort adarshr

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.