JsonDeserializer<T> 反序列化方法未在缺少的属性上调用

Question

我有一个简单而复杂的问题：是否可以在缺少 JSON 属性时调用 JsonDeserializer？

为什么：我有一个 RegisterableProfile，它对应于用户填充并发送到服务器的表单。在最简单的形式中，它看起来像这样：

JSON-Request，将映射到 RegisterableProfile：

{
    "username": "someUser",
    "password": "somePass",
    "email": "some@mail.com",
    "language": "en"
}

它映射到的实体（RegisterableProfile）：

@Getter
@Setter
@EqualsAndHashCode(callSuper = true)
@MappedSuperclass
public class RegisterableProfile extends CredentialsProfile {
    @Column(nullable = false, unique = true)
    private String email;

    @OneToOne
    @Convert(converter = LanguageConverter.class)
    private Language language;

    @Override
    public String toString() {
        return new StringBuilder(RegisterableProfile.class.getSimpleName())
                                                                           .append(" {")
                                                                           .append("name : '").append(getUsername()).append("',")
                                                                           .append("password : '").append(getPassword()).append("',")
                                                                           .append("email : '").append(email)
                                                                           .append("'}")
                                                                           .toString();
    }
}

请注意，CredentialsProfile 仅提供用户名和密码并与此类分开，因为在初始登录时可能会单独发生。

语言实体：

@JsonDeserialize(using = LanguageDeserializer.class)
@Data
@NoArgsConstructor
@Entity(name = "Languages")
public class Language {
    @Id
    @Column(nullable = false, unique = true)
    private String  languageCode;
    @Column(nullable = false, unique = true)
    private String  name;
    @Column(nullable = false, unique = true)
    private String  i18nName;
    private boolean localizeUi      = false;
    private boolean canChoose       = false;
    private boolean defaultLanguage = false;
}

使用 LanguageDeserializer 将 JSON 字符串中的“语言”属性正确转换为语言对象 - 如果该属性存在。 但是：如果 属性缺失或为空，则不会调用 LanguageDeserializer#deserialize 方法并且 RegisterableProfile 中的“语言”属性保持为空。

我可能可以通过检查我的 ProfileService 方法中的语言属性是否为“null”并将其设置在那里来解决这个问题，但它似乎不像在缺少的属性上调用自定义反序列化器那样干净.

另一个想法（仍然是一种解决方法）是为 RegisterableProfile 提供一个自定义反序列化器，并让它检测语言属性是否丢失或其他什么，但我不知道如何去做。

我的LanguageDeserializer：

public class LanguageDeserializer extends JsonDeserializer<Language> {

    @Autowired
    private LanguageService languageService;

    @Override
    public Language deserialize(final JsonParser p, final DeserializationContext ctxt) throws IOException, JsonProcessingException {
        final JsonNode node = p.readValueAsTree();
        final String languageCode = node.asText();
        return languageService.getLanguage(languageCode);
    }
}

注意：languageService.getLanguage(...) 始终返回与 languageCode 匹配的 Language-object 或默认 Language-object。

此外：解决方案应该使用 spring-boot（及其库堆栈）。我目前使用的是 spring-boot 版本 1.5.7.RELEASE 和 2.8.10（与 spring-boot 捆绑）。

Answer 1

缺少语言属性更新

如果您希望语言属性丢失，您可以编写一个BeanDeserializerModifier，它将RegisterableProfile 的创建委托给默认反序列化程序。它根据提供的值创建完整的Language 对象。如果完全缺少语言属性，请使用默认值。这里]1 是一个工作示例。

RegisterableProfile 反序列化器委托给默认反序列化器

package com.divstar.particle.authservice.rest.accountservice.mapper;

import com.divstar.particle.authservice.rest.languageservice.LanguageService;
import com.divstar.particle.authservice.rest.tos.RegisterableAccount;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.deser.ResolvableDeserializer;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
import java.io.IOException;

public class RegisterableAccountDeserializer
        extends StdDeserializer<RegisterableAccount>
        implements ResolvableDeserializer {

    private final JsonDeserializer<?> defaultDeserializer;

    private LanguageService languageService;

    public RegisterableAccountDeserializer(
            JsonDeserializer<?> defaultDeserializer,
            LanguageService languageService) {
        super(RegisterableAccount.class);
        this.defaultDeserializer = defaultDeserializer;
        this.languageService = languageService;
    }

    @Override
    public RegisterableAccount deserialize(JsonParser parser,
            DeserializationContext context) throws IOException, JsonProcessingException {
        RegisterableAccount account =
                (RegisterableAccount) defaultDeserializer.deserialize(parser,
                        context);

        if (account.getLanguage() != null && account.getLanguage().getLanguageCode() != null) {
            account.setLanguage(
                    languageService.getLanguage(
                            account.getLanguage().getLanguageCode()));
        } else {
            account.setLanguage(languageService.getLanguage("en"));
        }

        return account;
    }

    @Override
    public void resolve(
            DeserializationContext context) throws JsonMappingException {
        ((ResolvableDeserializer) defaultDeserializer).resolve(context);
    }
}

弹簧配置

package com.divstar.particle.authservice.rest.config;

import com.divstar.particle.authservice.rest.accountservice.mapper.RegisterableAccountDeserializer;
import com.divstar.particle.authservice.rest.languageservice.LanguageService;
import com.divstar.particle.authservice.rest.tos.RegisterableAccount;
import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.DeserializationConfig;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.deser.BeanDeserializerModifier;
import com.fasterxml.jackson.databind.module.SimpleModule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;

@Configuration
public class SpringConfiguration {

    @Bean
    public Jackson2ObjectMapperBuilder objectMapperBuilder(
            final LanguageService service) {
        Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();

        SimpleModule module = new SimpleModule();
        module.setDeserializerModifier(new BeanDeserializerModifier() {
            @Override
            public JsonDeserializer<?> modifyDeserializer(
                    DeserializationConfig config, BeanDescription beanDesc,
                    JsonDeserializer<?> deserializer) {
                if (beanDesc.getBeanClass() == RegisterableAccount.class) {
                    return new RegisterableAccountDeserializer(deserializer,
                            service);
                }

                return deserializer;
            }
        });

        builder.modules(module);

        return builder;
    }
}

RegisterableAccount 的变化

注释掉this.language = Language.getDefaultLanguage()这一行。

public class RegisterableAccount extends Credentials {
    @Column(nullable = false, unique = true)
    private String email;

    @OneToOne
    @Convert(converter = LanguageConverter.class)
    private Language language;

    /**
     * Default constructor.
     */
    public RegisterableAccount() {
        // set language to default; will be overridden if valid languageCode is provided
        //this.language = Language.getDefaultLanguage();
    }
    ...

}

对 LanguageDeserializer 的更改

public class LanguageDeserializer extends JsonDeserializer<Language> {

    @Override
    public Language deserialize(final JsonParser p, final DeserializationContext ctxt) throws IOException, JsonProcessingException {
        final JsonNode node = p.readValueAsTree();
        final String languageCode = node.asText();

        if (languageCode != null) {
            Language language = new Language();
            language.setLanguageCode(languageCode);
            return language;
        }

        return null;
    }
}