java - primeros - ¿Cómo usar Apache Avro para serializar el documento JSON y luego escribirlo en Cassandra?

primeros pasos con apache cassandra

Question

He estado leyendo mucho sobre Apache Avro estos días y estoy más inclinado a usarlo en lugar de usar JSON . Actualmente, lo que estamos haciendo es, estamos serializando el documento JSON usando Jackson y luego escribiendo ese documento serializado JSON en Cassandra por cada row key/user id . Luego tenemos un servicio REST que lee todo el documento JSON utilizando la clave de fila y luego lo deserializa y lo utiliza más.

Escribiremos en Casandra de esta manera:

user-id   column-name   serialize-json-document-value

A continuación se muestra un ejemplo que muestra el documento JSON que estamos escribiendo en Cassandra. Este documento JSON es para una clave de fila / id de usuario particular.

{
  "lv" : [ {
    "v" : {
      "site-id" : 0,
      "categories" : {
        "321" : {
          "price_score" : "0.2",
          "confidence_score" : "0.5"
        },
        "123" : {
          "price_score" : "0.4",
          "confidence_score" : "0.2"
        }
      },
      "price-score" : 0.5,
      "confidence-score" : 0.2
    }
  } ],
  "lmd" : 1379214255197
}

Ahora estamos pensando en utilizar Apache Avro para que podamos compactar este documento JSON serializando con Apache Avro y luego almacenarlo en Cassandra. Tengo un par de preguntas sobre esto-

1. ¿Es posible serializar el documento JSON anterior utilizando Apache Avro antes que nada y luego escribirlo en Cassandra? Si es así, ¿cómo puedo hacer eso? ¿Alguien puede dar un ejemplo simple?
2. Y también debemos deserializarlo al leer de Cassandra de nuestro servicio REST. ¿Esto también es posible de hacer?

Debajo está mi código simple que serializa el documento JSON y lo imprime en la consola.

public static void main(String[] args) {

    final long lmd = System.currentTimeMillis();

    Map<String, Object> props = new HashMap<String, Object>();
    props.put("site-id", 0);
    props.put("price-score", 0.5);
    props.put("confidence-score", 0.2);

    Map<String, Category> categories = new HashMap<String, Category>();
    categories.put("123", new Category("0.4", "0.2"));
    categories.put("321", new Category("0.2", "0.5"));
    props.put("categories", categories);

    AttributeValue av = new AttributeValue();
    av.setProperties(props);

    Attribute attr = new Attribute();
    attr.instantiateNewListValue();
    attr.getListValue().add(av);
    attr.setLastModifiedDate(lmd);

    // serialize it
    try {
        String jsonStr = JsonMapperFactory.get().writeValueAsString(attr);

        // then write into Cassandra
        System.out.println(jsonStr);
    } catch (JsonGenerationException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

El documento Serialzie JSON se verá algo como esto:

{"lv":[{"v":{"site-id":0,"categories":{"321":{"price_score":"0.2","confidence_score":"0.5"},"123":{"price_score":"0.4","confidence_score":"0.2"}},"price-score":0.5,"confidence-score":0.2}}],"lmd":1379214255197}

AttributeValue clases AttributeValue y Attribute están usando Jackson Annotations .

Y también una nota importante, las propiedades dentro del documento json anterior cambiarán dependiendo de los nombres de las columnas. Tenemos diferentes propiedades para diferentes nombres de columna. Algunos nombres de columna tendrán dos propiedades, algunas tendrán 5 propiedades. Por lo tanto, el documento JSON anterior tendrá sus propiedades correctas y su valor de acuerdo con nuestros metadatos que tenemos.

Espero que la pregunta sea lo suficientemente clara. ¿Alguien puede dar un ejemplo simple de esto? ¿Cómo puedo lograr eso usando Apache Avro? Estoy empezando con Apache Avro, así que estoy teniendo muchos problemas ...

Answer 1

Avro requiere un esquema, por lo que DEBE diseñarlo antes de usarlo; y el uso difiere mucho del JSON de forma libre.

Pero en lugar de Avro, es posible que desee considerar Smile : una serialización binaria uno a uno de JSON, diseñada para casos de uso donde es posible que desee ir y venir entre JSON y datos binarios; por ejemplo, para usar JSON para la depuración, o al servir clientes de Javascript.

Jackson tiene el backend de Smile (vea https://github.com/FasterXML/jackson-dataformat-smile ) y literalmente es un cambio de una línea para usar Smile en lugar de (o además de) JSON. Muchos proyectos lo usan (por ejemplo, Elastic Search) y es un formato maduro y estable; y el soporte de herramientas a través de Jackson es extenso para diferentes tipos de datos.

Answer 2

Como ya usas jackson, puedes probar el módulo de formato de datos Jackson para que admita datos codificados en Avro .