es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Valor dinámico basado en un valor de entrada en Java.

05 Jun, 2023 Programación

Estoy teniendo una clase como la siguiente:

public class ResponseData {
    private Long entityId;
    private String type;
    private List<String> value;
}

Declaración del problema:

Estoy enviando una lista de ResponseData al llamador en formato JSON.

Los valores posibles de la variable “type” son “String”, “Integer”, “Date”, “Time” y “Reference”.

Mi requisito es que si el valor de “type” es “Integer” o “Reference”, entonces el tipo del campo “value” debería ser una lista de Integer y para todos los demás valores del campo “type”, el tipo del campo “value” debería ser una lista de String.

Tags:  , , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para lograr el requisito anterior, podemos definir un serializador/deserializador personalizado para la clase ResponseData usando la biblioteca JSON Jackson en nuestra aplicación Spring Boot.

    En primer lugar, debemos agregar la siguiente dependencia a nuestro archivo pom.xml para incluir la biblioteca Jackson:

    <dependency>
    <groupid>com.fasterxml.jackson.core</groupid>
    <artifactid>jackson-databind</artifactid>
</dependency>

    A continuación, podemos definir nuestro serializador/deserializador personalizado de la siguiente manera:

    public class ResponseDataJsonSerializer extends JsonSerializer<responsedata> {
    @Override
    public void serialize(ResponseData responseData, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeNumberField("entityId", responseData.getEntityId());
        jsonGenerator.writeStringField("type", responseData.getType());
        if (responseData.getType().equals("Integer") || responseData.getType().equals("Reference")) {
            List<integer> intList = responseData.getValue().stream().map(Integer::valueOf).collect(Collectors.toList());
            jsonGenerator.writeObjectField("value", intList);
        } else {
            jsonGenerator.writeObjectField("value", responseData.getValue());
        }
        jsonGenerator.writeEndObject();
    }

    @Override
    public Class<responsedata> handledType() {
        return ResponseData.class;
    }
}

public class ResponseDataJsonDeserializer extends JsonDeserializer<responsedata> {
    @Override
    public ResponseData deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
        JsonNode node = jsonParser.getCodec().readTree(jsonParser);
        Long entityId = node.get("entityId").asLong();
        String type = node.get("type").asText();
        List<string> value = new ArrayList<>();
        if (type.equals("Integer") || type.equals("Reference")) {
            List<integer> intList = new ArrayList<>();
            JsonNode valueNode = node.get("value");
            if (valueNode.isArray()) {
                for (JsonNode element : valueNode) {
                    intList.add(element.asInt());
                }
            }
            value = intList.stream().map(String::valueOf).collect(Collectors.toList());
        } else {
            JsonNode valueNode = node.get("value");
            if (valueNode.isArray()) {
                for (JsonNode element : valueNode) {
                    value.add(element.asText());
                }
            }
        }
        ResponseData responseData = new ResponseData();
        responseData.setEntityId(entityId);
        responseData.setType(type);
        responseData.setValue(value);
        return responseData;
    }
}

Podemos usar estos serializadores/deserializadores para convertir objetos ResponseData a JSON y viceversa, mientras manejamos el typecasting requerido para el campo value según el valor del campo type.

Por ejemplo, si tenemos una lista de objetos ResponseData y queremos enviarla al llamante como JSON, podemos hacer lo siguiente:

    List responseList = // obtener la lista de respuesta
    ObjectMapper objectMapper = new ObjectMapper();
    SimpleModule module = new SimpleModule();
    module.addSerializer(ResponseData.class, new ResponseDataJsonSerializer());
    objectMapper.registerModule(module);
    String json = objectMapper.writeValueAsString(responseList);


    Aquí, estamos registrando nuestro serializador personalizado con la instancia ObjectMapper y usándolo para convertir la lista de objetos ResponseData a JSON.

De manera similar, si recibimos una cadena JSON del llamante y queremos convertirla de vuelta a una lista de objetos ResponseData, podemos hacer lo siguiente:

    String jsonString = // obtener la cadena JSON
    ObjectMapper objectMapper = new ObjectMapper();
    SimpleModule module = new SimpleModule();
    module.addDeserializer(ResponseData.class, new ResponseDataJsonDeserializer());
    objectMapper.registerModule(module);
    List responseList = objectMapper.readValue(jsonString, new TypeReference<>>() {});
    “`

    Aquí, estamos registrando nuestro deserializador personalizado con la instancia ObjectMapper y usándolo para convertir la cadena JSON a una lista de objetos ResponseData.

Comments are closed.