Сериализация аннотаций, а также полей в JSON

Question

У меня есть приложение весенней загрузки, и я хочу отправить ограничения проверки DTO, а также значение поля клиенту.

Имея DTO

class PetDTO {
  @Length(min=5, max=15)
  String name;
}

где имя "Левиафан", должно привести к отправке этого JSON клиенту:

{
    name: 'Leviathan'
    name_constraint: { type: 'length', min:5, max: 15},
}

Рассуждение должно иметь единый источник правды для валидации. Можно ли это сделать с разумным количеством работы?

Answer 1

Чтобы расширить ответ Фредерика, я покажу небольшой пример кода, который обращается к объекту для сопоставления и сериализует его.

Так вот пользователь pojo:

import org.hibernate.validator.constraints.Length;

public class User {

    private String name;

    public User(String name) {
        this.name = name;
    }

    @Length(min = 5, max = 15)
    public String getName() {
        return name;
    }
}

Тогда актуальный сериализатор:

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import org.springframework.util.ReflectionUtils;

import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.*;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toMap;

public class UserSerializer extends StdSerializer<User> {

    public UserSerializer(){
        this(User.class);
    }

    private UserSerializer(Class t) {
        super(t);
    }

    @Override
    public void serialize(User bean, JsonGenerator gen, SerializerProvider provider) throws IOException {
        Map<String, Object> properties = beanProperties(bean);
        gen.writeStartObject();
        for (Map.Entry<String, Object> entry : properties.entrySet()) {
            gen.writeObjectField(entry.getKey(), entry.getValue());
        }
        gen.writeEndObject();
    }

    private static Map<String, Object> beanProperties(Object bean) {
        try {
            return Arrays.stream(Introspector.getBeanInfo(bean.getClass(), Object.class).getPropertyDescriptors())
                    .filter(descriptor -> Objects.nonNull(descriptor.getReadMethod()))
                    .flatMap(descriptor -> {
                        String name = descriptor.getName();
                        Method getter = descriptor.getReadMethod();
                        Object value = ReflectionUtils.invokeMethod(getter, bean);
                        Property originalProperty = new Property(name, value);

                        Stream<Property> constraintProperties = Stream.of(getter.getAnnotations())
                                .map(anno -> new Property(name + "_constraint", annotationProperties(anno)));

                        return Stream.concat(Stream.of(originalProperty), constraintProperties);
                    })
                    .collect(toMap(Property::getName, Property::getValue));
        } catch (Exception e) {
            return Collections.emptyMap();
        }
    }

    // Methods from Annotation.class
    private static List<String> EXCLUDED_ANNO_NAMES = Arrays.asList("toString", "equals", "hashCode", "annotationType");

    private static Map<String, Object> annotationProperties(Annotation anno) {
        try {
            Stream<Property> annoProps = Arrays.stream(Introspector.getBeanInfo(anno.getClass(), Proxy.class).getMethodDescriptors())
                    .filter(descriptor -> !EXCLUDED_ANNO_NAMES.contains(descriptor.getName()))
                    .map(descriptor -> {
                        String name = descriptor.getName();
                        Method method = descriptor.getMethod();
                        Object value = ReflectionUtils.invokeMethod(method, anno);
                        return new Property(name, value);
                    });
            Stream<Property> type = Stream.of(new Property("type", anno.annotationType().getName()));
            return Stream.concat(type, annoProps).collect(toMap(Property::getName, Property::getValue));
        } catch (IntrospectionException e) {
            return Collections.emptyMap();
        }
    }

    private static class Property {
        private String name;
        private Object value;

        public Property(String name, Object value) {
            this.name = name;
            this.value = value;
        }

        public String getName() {
            return name;
        }

        public Object getValue() {
            return value;
        }
    }
}

И, наконец, нам нужно зарегистрировать этот сериализатор для использования Джексоном:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication(scanBasePackages = "sample.spring.serialization")
public class SerializationApp {

    @Bean
    public Jackson2ObjectMapperBuilder mapperBuilder(){
        Jackson2ObjectMapperBuilder jackson2ObjectMapperBuilder = new Jackson2ObjectMapperBuilder();
        jackson2ObjectMapperBuilder.serializers(new UserSerializer());
        return jackson2ObjectMapperBuilder;
    }

    public static void main(String[] args) {
        SpringApplication.run(SerializationApp.class, args);
    }
}

@RestController
class SerializationController {
    @GetMapping("/user")
    public User user() {
        return new User("sample");
    }
}

Json, который будет выпущен:

{  
   "name_constraint":{  
      "min":5,
      "max":15,
      "payload":[],
      "groups":[],
      "message":"{org.hibernate.validator.constraints.Length.message}",
      "type":"org.hibernate.validator.constraints.Length"
   },
   "name":"sample"
}

Надеюсь это поможет. Удачи.

Answer 2

Для этого вы всегда можете использовать специальный сериализатор Jackson. В Интернете можно найти множество документов, которые могут выглядеть примерно так:

public void serialize(PetDTO value, JsonGenerator jgen, ...) {

    jgen.writeStartObject();
    jgen.writeNumberField("name", value.name);
    jgen.writeObjectField("name_consteaint", getConstraintValue(value));
}

public ConstaintDTO getConstraintValue(PetDTO value) {

    // Use reflection to check if the name field on the PetDTO is annotated
    // and extract the min, max and type values from the annotation
    return new ConstaintDTO().withMaxValue(...).withMinValue(...).ofType(...);
}

Возможно, вы захотите создать класс base-DTO, для которого включается конвертер, поэтому вам не нужно создавать собственный конвертер для всех ваших доменных объектов, которые должны предоставлять ограничения.

Комбинируя отражение и умное использование полей для письма, вы можете приблизиться. Недостатком является то, что вы не можете воспользоваться @JsonXXX аннотации к объектам вашего домена, поскольку вы сами пишете JSON.

Более идеальным решением было бы преобразование Джексона, но какой-то пост-конверсионный звонок для добавления дополнительных XX_condtion свойства к объекту. Может быть, начать с переопределения объекта-сериализатора по умолчанию (если это возможно)?