Java Cassandra: novidades da vers�o 2.0.1 do Easy-Cassandra

Recentemente foi lançada a nova vers�o do Easy-Cassandra - vers�o 2.0. - e dentre as novidades podemos citar:

Refatoraç�o nos construtores das f�bricas de sess�o;
QueryBuilder (InsertBuilder, UpdateBuilder, DeleteBuilder, SelectBuilder e BatchBuilder);
Maior velocidade na leitura e escrita;
Suporte nos processos ass�ncronos;
Maior suporte ao Cassandra com Spring-Data.

Nota: Se voc� n�o conhece o projeto, n�o deixe de conferir esse artigo e entender o que � o Easy Cassandra.

Um ponto importante � que para facilitar a configuraç�o foi criada a classe ClusterInformation, que � passada no par�metro, de maneira simples, deixando o c�digo mais limpo, afinal, sobrecarga de construtores n�o � uma boa pr�tica. Um exemplo de configuraç�es pode ser visto na Listagem 1.

Listagem 1. Classe ClusterInformation


  ClusterInformation clusterInformation = ClusterInformation.create()
                  .addHost(HOST)
                  .withDefaultKeySpace(KEY_SPACE).withUser(USER).withPassword(PASS);
          easyCassandraManager = new EasyCassandraManager(clusterInformation);

Dessa forma, a configuraç�o para usar o Spring no Cassandra tamb�m mudou. Veja a Listagem 2.

Listagem 2. Configuraç�o para o Cassandra


  <beans xmlns="http://www.springframework.org/schema/beans"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xmlns:context="http://www.springframework.org/schema/context"
              xsi:schemaLocation="http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-3.0.xsd
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   
  <context:component-scan base-package="org.easycassandra.persistence.cassandra.spring" />
   
  <bean id = "clusterInformation" class="org.easycassandra.persistence.cassandra.ClusterInformation">
              <property name="keySpace" value="campus" />
              <property name="hosts">
                          <list>
                                     <value>localhost</value>
                          </list>
              </property>
  </bean>
   
  <bean id="cassandraFactory" class="org.easycassandra.persistence.cassandra.spring.CassandraFactoryAnnotation">
              <constructor-arg name="clusterInformation" ref="clusterInformation" />
              <property name="annotatedClasses">
                          <list>
                                     <value>org.easycassandra.persistence.cassandra.spring.entity.Contact</value>
              <value>org.easycassandra.bean.model.Step</value>
              <value>org.easycassandra.bean.model.Weight</value>
                          </list>
              </property>
  </bean>
   
  <bean id="cassandraTemplate" class="org.easycassandra.persistence.cassandra.spring.SimpleCassandraTemplateImpl" >
              <constructor-arg name="factory" ref="cassandraFactory" />
  </bean>
   
  </beans>

A melhoria mais marcante nessa vers�o s�o os recursos dos QueryBuilders, que s�o maneiras muito mais f�cil de fazer interaç�es com o Cassandra com configuraç�es adversas de uma maneira mais simples. Com esses recursos, � poss�vel definir o n�vel de consist�ncia, definir o timeStamp e quais campos ser�o manipulados.

Nota: Para quem tem d�vidas e problemas com o timestamp, n�o podem deixar de dar uma olhada nesse t�pico que mostra como subtrair hora do timestamp.

Veja na Listagem 3 como inserir valores a partir da chave.

Listagem 3. Simples exemplo inserindo valores a partir da chave


   SimpleID id = new SimpleID();
      id.setIndex(ONE_HUNDRED_THIRTY);
      id.setKey(ONE_HUNDRED_THIRTY);
      UpdateBuilder<SimpleQueryBuilder> update = template.updateBuilder(SimpleQueryBuilder.class, key);
      update.put("map", "name", "otavioMap").value("value", TEN_DOUBLE).execute();

Na Listagem 4 vemos toda a query de atualizaç�o.

Listagem 4. Query de atualizaç�o


  UpdateBuilder<SimpleQueryBuilder> update = persistence.updateBuilder(SimpleQueryBuilder.class);
   update.whereEq(Constant.KEY, Constant.ONE).whereEq(Constant.INDEX, Constant.ONE).addList("list", "otavioList").execute();

Na Listagem 5 temos o c�digo de criaç�o da atualizaç�o ass�ncrona.

Listagem 5. Executando uma atualizaç�o assincronamente


   UpdateBuilder<SimpleQueryBuilder> update = persistence.updateBuilder(SimpleQueryBuilder.class);
   update.whereEq(Constant.KEY, Constant.ONE).whereEq(Constant.INDEX, Constant.ONE).value("value", 12D).executeAsync(new ResultAsyncCallBack<Boolean>() {
      @Override
      public void result(Boolean bean) {
          // do some action
      }
  });

Nas Listagens 6 e 7 veremos a codificaç�o do processo de inserç�o do nosso exemplo.

Listagem 6. Realizando inserç�o


  InsertBuilder<SimpleQueryBuilder> insert= persistence.updateBuilder(SimpleQueryBuilder.class);
  Set<String> set = new HashSet<>();
  set.add("Linda");
  Map<String, String> map = new HashMap<>();
  map.put("love", "Otavio and Poliana");
  insert.value(Constant.KEY, Constant.ONE_HUNDRED).value(Constant.INDEX,
              Constant.ONE_HUNDRED).value(Constant.LIST_COLUMN, Arrays.asList("Poliana", "Otavio", "Love")).value(Constant.SET_COLUMN, set).value("map", map).execute();

Listagem 7. Realizando inserç�o de modo ass�ncrono


    SimpleID id = new SimpleID();
      id.setIndex(ONE_HUNDRED_TWO);
      id.setKey(ONE_HUNDRED_TWO);
      SimpleBean simpleBean = new SimpleBean();
      simpleBean.setId(id);
      simpleBean.setValue(VALUE);
      InsertBuilder<SimpleQueryBuilder> insert2 = persistence.updateBuilder(simpleBean);
      insert2.executeAsync((new ResultAsyncCallBack<Boolean>() {
      @Override
      public void result(Boolean bean) {
          // do some action
      }
      });

Na Listagem 8 vemos o c�digo de duas query: a primeira query remove todas as colunas a partir da chave, e a segunda query remove apenas os campos map, list e set.

Listagem 8. Querys de remoç�o


    DeleteBuilder<SimpleBean> delete = persistence.deleteBuilder(SimpleQueryBuilder.class); 
      delete.whereEq(Constant.INDEX, ONE_HUNDRED_TWO).whereEq(Constant.KEY, ONE_HUNDRED_TWO).execute();
      DeleteBuilder<SimpleBean> delete2 = persistence.deleteBuilder(SimpleQueryBuilder.class,"map", "list", "set"); //Delete specific columns
      delete2 .whereEq(Constant.INDEX, ONE_HUNDRED_TWO).whereEq(Constant.KEY, ONE_HUNDRED_TWO).execute();

Na Listagem 9 vemos o c�digo da remoç�o ass�ncrona.


   SimpleID id = new SimpleID();
      id.setIndex(ONE_HUNDRED_TWO);
      id.setKey(ONE_HUNDRED_TWO);
   
      DeleteBuilder<SimpleBean> delete2 = persistence.deleteBuilder(SimpleQueryBuilder.class, id);
      delete2.executeAsync((new ResultAsyncCallBack<Boolean>() {
      @Override
      public void result(Boolean bean) {
          // do some action
      }
      });

Na Listagem 10 realizamos o select em que o campo nome � igual a nome e o �ndice est� em um, dois e tr�s.

Listagem 10. C�digo select


    SelectBuilder<SimpleQueryBuilder> select = persistence.selectBuilder(SimpleQueryBuilder.class);
    select.eq("name", "name");
    select.in("index", ONE, TWO, THREE);
    List<SimpleQueryBuilder> result = select.execute();

Na Listagem 11 temos o c�digo da execuç�o da query assincronamente, em que o �ndice seja mais que tr�s e seja ordenado de forma descendente no �ndice.

Listagem 11. Execuç�o da query


  SelectBuilder<SimpleQueryBuilder> select = persistence.selectBuilder(SimpleQueryBuilder.class);
  select.eq(NAME, NAME).gt("index", THREE).asc(INDEX).executeAsync(new ResultAsyncCallBack<List<SimpleBean>>() {
   
          @Override
          public void result(List<SimpleBean> beans) {
            // do some thing
          }
      });

O Batch � um recurso do Cassandra e permite que se executem alteraç�es no banco (inserç�o, atualizaç�o e remoç�o) de forma at�mica. Dessa forma, pode-se enviar insert, updates e deletes como se fosse apenas uma requisiç�o.

Na Listagem 12 temos o c�digo de execuç�o do processo de inserç�o, remoç�o e atualizaç�o de forma at�mica com o BatchBuilder.

Listagem 12. Alteraç�es no banco com BatchBuilder


  DeleteBuilder<SimpleBean> delete = dao.deleteBuilder();
      delete.whereEq(Constant.INDEX, Constant.ONE_HUNDRED_TWO)
              .whereEq(Constant.KEY, Constant.ONE_HUNDRED_TWO);
   
      InsertBuilder<SimpleBean> insert = dao.insertBuilder();
      insert.value(Constant.KEY, Constant.ONE_HUNDRED).value(Constant.INDEX,
              Constant.ONE_HUNDRED);
      insert.value(Constant.LIST_COLUMN,
              Arrays.asList("Poliana", "Otavio", "Love"));
   
      UpdateBuilder<SimpleBean> update = dao.update();
      update.whereEq(Constant.KEY, Constant.ONE).whereEq(Constant.INDEX, Constant.ONE);
      update.addList("list", "otavioList");
   
      BatchBuilder batchBuilder = dao.batchBuilder();
   
      batchBuilder.addOperations(delete, insert, update);
      batchBuilder.executeAsync(new ResultAsyncCallBack<Boolean>() {
          @Override
          public void result(Boolean bean) {
              // do some action
          }
      });

Vale lembrar que recurso do Batch deve ser usado em casos espec�ficos, j� que distribuir as requisiç�es entre os n�s, no Cassandra, sempre ser� uma boa pr�tica.

Refer�ncias

https://github.com/otaviojava/Easy-Cassandra/wiki/Builders

https://github.com/otaviojava/Easy-Cassandra/wiki

Java Cassandra: novidades da vers�o 2.0.1 do Easy-Cassandra

Descubra as novidades da nova versão do framework ORM Easy-Cassandra 2.0.1. Dentre as suas novidades podemos destacar maior suporte ao uso do Spring Data, o uso de queryBuilder, além de realizar todas as interações de forma assíncrona.

Artigos relacionados