Novo Easy-Cassandra 2.0.0 Beta

    O Cassandra, o banco de dados não relacional orientados à família de colunas, é um banco feito para trabalhos de alta performance, alta escalabilidade horizontal além de ser tolerante a falhas. Uma das grandes vantagens de sua arquitetura de escalabilidade horizontal é que se pode fazer com que cresça o número de nós a partir de uma alta demanda e diminuir em períodos de pouco processamento, ideal para a plataforma nas nuvens tão comumente discutido. Em sua nova versão trouxe o novo Cassandra Query Language, CQL, a versão 3.0, que dentre suas melhorias está no trabalho de coleções, chaves compostas.

    Com tantas melhorias o único problema é a maneira de tirar proveito de maneira eficiente desses novos recursos, afinal o foco do desenvolvedor Java deve ser solução em OO e sobre tudo no objetivo da aplicação, regras de negócio, a ponto de que esse parser entre banco e negócio seja o menor possível. Com esse objetivo surgiu o Easy-Cassandra, seu foco é facilitar o desenvolver Java utilizar esses recurso sem em nenhum momento desfocar no objetivo e no negócio da aplicação. Nessa nova versão o framework ORM trouce as seguintes melhorias:

•  Chave Composta
• Mapeamento de coleções( java.util.List, java.util.Set, java.util.Map)
• Reconhecimento automático dos demais cluters na conexão e trabalho de autobalanceamento.
• Melhorias no levantamento da aplicação.

Criação do Schema, para o uso de keyspace diferente do passado.

    Nessa nova versão houve algumas quebras de retrocompatibilidades, isso deve ao uso do java Driver e de suas consultas totalmente focadas no CQL 3. Essa pequena quebra está apenas no modo em que é criado a classe ponte entre o cassandra e o seu objeto java já que as anotações de mapeamento continuam tendo como base as anotações do JPA 2.0.

     Como a ideia no futuro é que exista o banco MongoDB, foi criada a interface org.easycassandra.persistence.Persistence, assim os novos bancos de dados e o Cassandra terão esse contrato, assim será possível, trocando apenas a implementação, mudando o banco de dados não relacional.

  
public interface Persistence {

    boolean insert(Object bean);

    boolean delete(Object bean);

    boolean update(Object bean);

     List findAll(Class bean);

     T findByKey(Object key, Class bean);

    boolean deleteByKey(Object key, Class bean);

    boolean executeUpdate(String query);

}

A interface do cassandra org.easycassandra.persistence.cassandra.PersistenceCassandra, como todos os novos bancos compatíveis herda do Persistence e adiciona alguns pequenos recursos.

  
public interface PersistenceCassandra extends Persistence {

     List findByIndex(Object index, Class bean);

    Long count(Class bean);
}

    A classe responsável por gerar a implementação continua sendo a org.easycassandra.persistence.cassandra.EasyCassandraManager, mas ela se tornou um enum, sim isso mesmo um enum!, já que o objetivo é que ele seja único nada mais natural que o singleton natural cedido pela própria JVM. Só é necessário passar o host e o keyspace, caso não existe ele se responsabilizará por você. Para adicionar objetos mapeados no Cassandra basta usar o método addFamilyObject passando o .class, assim como no caso do keyspace, caso ele não existe ele se responsabilizará em criar ou alterar a column family, para o seu objeto.

Como base nisso o DAO base poderia ficar da seguinte maneira:

  
public class PersistenceDao {

    private static final String KEY_SPACE = "javabahia";
    private static final String HOST = "localhost";
    private PersistenceCassandra persistence;
    private Class baseClass;
    

    public PersistenceDao(Class baseClass) {
        this.baseClass = baseClass;
        persistence = EasyCassandraManager.INSTANCE.getPersistence(HOST, KEY_SPACE);
        EasyCassandraManager.INSTANCE.addFamilyObject(baseClass, KEY_SPACE);
        
    }

    public boolean insert(T bean) {
        return persistence.insert(bean);
    }

    public boolean remove(T bean) {
        return persistence.delete(bean);
    }

    public boolean removeFromRowKey(K rowKey) {
        return persistence.deleteByKey(rowKey, baseClass);
    }

    public boolean update(T bean) {
        return persistence.update(bean);
    }

    public T retrieve(Object id) {
     
        return   persistence.findByKey(id, baseClass);
    }

    public List listAll() {
        return persistence.findAll(baseClass);
    }

    public List listByIndex(Object index) {
        return persistence.findByIndex(index, baseClass);
    }

    public Long count() {
        return persistence.count(baseClass);
    }

    public boolean executeUpdateCql(String string) {
        return persistence.executeUpdate(string);
    }

}

    Uma outra estratégia seria a mudança de interface para a persistence, assim esse DAO seria para todos os bancos de dados nosql que o framework for sendo compatível. Uma vez pronto o nosso projeto base, vamos falar um pouco sobre o mapeamento dos objetos. Os desenvolvedores java que conhecem o JPA já estarão familiarizado como o modelo de mapeamento.

  
@Entity(name = "person")
public class Person implements Serializable {

    private static final long serialVersionUID = 3L;
    
    @Id
    private Long id;
    
    @Index
    @Column(name = "name")
    private String name;
    
    @Column(name = "born")
    private Integer year;
    
    
    @Enumerated
    private Sex sex;
    
    
    @Embedded
    private Address address;

//getter and setter
}

Assim os campos são:

•  @Id serve para indicar que esse campo será a chave da linha.
• @Enumerated indica que o campo é um enum.
• @Embedded indica que existe um objeto complexo e este será embitudio na mesma linha.
• @Index indica o índice, funciona como um segundo ID, assim será possível realizar busca a partir desse campo.
• @Table ou @Entity indica que o objeto é mapeado e pega o nome da column family
• @EmbeddedId indica que esse campo é um objeto complexo e nele está embutido as chaves da column family.
  
  

  

@Entity(name="linux")
public class LinuxDistribuition {

    @EmbeddedId
    private IdLinux id;
    
    @Column
    private String guy;
    
    @Column
    private String version;
    
    @Column(name="descriptions")
    private String descriptions;
//getter and setter
}

public class IdLinux {
    
    
    @Column
    private String name;
    
    @Column
    private String kernelVersion;
//getter and setter
}

Além desses campos essa nova versão trouxe novas anotações para se poder trabalhar com listas dentro do cassandra que são:

• SetData indica que o campo é uma interface java.util.Set, é necessário informar o classeData na qual indica o tipo do objeto que terá no set.
• ListData indica que o campo é uma interface java.util.List, é necessário informar o classeData na qual indica o tipo do objeto que terá na lista.
• MapData indica que o campo é uma interface java.util.Map, é necessário informar a chave e o valor do map informando o classkey e classValue respectivamente.

Exemplos do uso dessa interação abaixo:

  
@Entity(name="resumebook")
public class Book {

    @Id
    @Column(name="booksname")
    private String name;
    
    @MapData(classKey=Long.class,classValue=String.class)
    private Map chapterResume;
//getter and setter
}


@Entity(name="shopping")
public class ShoppingList {

    @Id
    private String name;
    
    @Column(name="day")
    private Date day;
    
    @ListData(classData=String.class)
    @Column(name="frutis")
    private List fruits;
    
    @Column(name="storeName")
    private String storeName;
//getter and setter
}

@Entity(name="contact")
public class Contact implements Serializable {

    @Id
    @Column(name="id")
    private String name;
    
    
    @Column(name="emails")
    @SetData(classData=String.class)
    private Set emails;
//getter and setter
}

 Uma vez mapeado e com o DAO pronto o seu uso se torna muito fácil, já que as buscas são semelhantes a única diferença está no objeto mapeado e o retorno.

  
public class BookDAOTest {

 private PersistenceDao persistence=new PersistenceDao(Book.class);
    
    
    @Test
        public void insertTest() {
        Book book = getBook();
        Assert.assertTrue(persistence.insert(book));
    }


    private Book getBook() {
        Book book = new Book();
        book.setName("Cassandra Guide ");
        Map resumeChapter=new HashMap();
        resumeChapter.put(1l, "this chapter describes new resources in cassandra and improvements with CQL");
        resumeChapter.put(2l, "Understanding the architecture");
        resumeChapter.put(3l, "Installing DataStax Community");
        resumeChapter.put(4l, "Upgrading Cassandra");
        resumeChapter.put(5l, "Initializing a cluster");
        resumeChapter.put(6l, "Security");
        resumeChapter.put(7l, "Database design");
        resumeChapter.put(8l, "Using the database");
        resumeChapter.put(9l, "Database internals");
        resumeChapter.put(10l, "Configuration");
        resumeChapter.put(11l, "Operations");
        resumeChapter.put(12l, "Backing up and restoring data");
        resumeChapter.put(13l, "Cassandra tools");
        resumeChapter.put(14l, "Troubleshooting");
        resumeChapter.put(14l, "Troubleshooting");
        resumeChapter.put(15l, "References");
        book.setChapterResume(resumeChapter);
        return book;
    }
    
    
    @Test
    public void retrieveTest() {
        Book book=persistence.retrieve(getBook().getName());
        Assert.assertNotNull(book);
     
    }
    
    @Test
    public void removeTest() {
        persistence.remove(getBook());
        Assert.assertNull(persistence.retrieve(getBook().getName()));
        persistence.insert(getBook());
    }
    
}


public class ContactsDAOTest {
 private PersistenceDao persistence=new PersistenceDao(Contact.class);
    
    
    @Test
        public void insertTest() {
        Contact contacts = getContact();
        Assert.assertTrue(persistence.insert(contacts));
    }


    private Contact getContact() {
        Contact contacts = new Contact();
        contacts.setName("Shrek ");
        contacts.setCyte("far far away");
        contacts.setEmails(new HashSet());
        contacts.getEmails().add("shreck@shrek.org");
        contacts.getEmails().add("shreck@farfaraway.far");
        return contacts;
    }
    
    
    @Test
    public void retrieveTest() {
     Contact contact=persistence.retrieve(getContact().getName());
     Assert.assertNotNull(contact);
     
    }
    @Test
    public void removeTest() {
        persistence.remove(getContact());
        Assert.assertNull(persistence.retrieve(getContact().getName()));   
    }
    
}



public class ShoppingListDAOTest {

    private PersistenceDao persistence=new PersistenceDao(ShoppingList.class);
    
    
    @Test
    public void insertTest() {
        
        Assert.assertTrue(persistence.insert(getPolianaShoppingList()));
    }
    private ShoppingList getPolianaShoppingList() {
        ShoppingList shopping=new ShoppingList();
        shopping.setDay(new Date());
        shopping.setName("Poliana");
        shopping.setFruits(new LinkedList());
        shopping.getFruits().add("Orange");
        shopping.getFruits().add("beans");
        shopping.getFruits().add("rice");
        return shopping;
    }
    
    @Test
    public void retrieveTest() {
     ShoppingList list=persistence.retrieve(getPolianaShoppingList().getName());
     Assert.assertNotNull(list);
    }
    @Test
    public void removeTest() {
        ShoppingList list=persistence.retrieve(getPolianaShoppingList().getName());
        persistence.remove(list);
        list=persistence.retrieve(getPolianaShoppingList().getName());
        Assert.assertNull(list);
    }
    
}

    Outro recuso importante é que foi solicitado pela comunidade, abraços ao pessoal da Bern na Suiça, é a possibilidade de usar outro keyspace diferente do definido no persistence. Para isso basta usar o schema na anotação @Table como mostra o exemplo abaixo:

  
@Table(name="drink",schema="schemaA")
public class Drink implements Serializable {

     @Id
     private Long id;
     
     @Index
     @Column(name = "name")
     private String name;
     
     @Column(name = "flavor")
     private String flavor;

   A nova versão do Easy-Cassandra, 2.0.0, ainda está em fase beta, assim é necessário realizar mais testes, mas com isso tem noção do que vem está por vir. Uma das coisas legais do framework é pioneirismos do projeto, até então ele é o primeiro ORM do cassandra que utiliza os recursos do 100% CQL 3.0. Isso graças ao grande trabalho por parte da comunidade.

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