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.
