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.

Anúncios

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s