Trabalhando com múltiplos nós na nova versão do Easy-Cassandra

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

Veja neste artigo como trabalhar com uma estrutura multi-node (múltiplos nós) na nova versão do framework Easy-Cassandra, bem como alguns recursos do Google Guice.

Recentemente foi lançada a mais nova versão do Easy-Cassandra, que trouxe novidades no gerenciamento de múltiplos nós. O uso de muitos nós é interessante para o Cassandra, já que evita gargalos, garante a tolerância a falhas, elasticidade além do fato. Um grande número de nós faz com que o Cassandra distribua as requisições, salientando que esse tipo de banco possui uma arquitetura distribuída, ou seja, vale a pena utilizar um grande número de nós.

Tão logo se tenha múltiplos nós do Cassandra o próximo passo é estar dividindo as tarefas entre os mesmos, não adianta se possuir dez nós, por exemplo, se todas as requisições vão sempre para um. Feito isso, o banco tratará todo resto (replicar informação entre os nós, ler e escrever a partir do nível de consistência, etc.). A estratégia utilizada no Easy para aproveitar o máximo dos múltiplos nós, é fazer com que cada requisição use um cliente diferente, para isso ele terá duas formas:

Sequencial: cada nó recebe um número de ordem crescente que vai de 0 até N-1, em que N é o número instâncias do Cassandra. Feita essa numeração, para cada solicitação ao Cassandra (atualizar, criar, deletar) é usado um cliente diferente seguindo em ordem crescente, por exemplo:

  • Primeira requisição cliente 0
  • Segunda requisição cliente 1

Uma vez acabado o número de nós, essa ordem recomeça a partir do cliente de índice 0.

Randômico: de forma semelhante ao sequencial, é dado um número para cada cliente que vai de 0 até N-1. Após essa numeração, para cada requisição é criado um número aleatório que representa uma instância do Cassandra.

Para usar uma das duas estratégias no ORM, o processo é bastante simples:

O primeiro passo é criar instâncias do Cassandra. Depois, adicionar esses nós no Easy-Cassandra. Em seguida, criar uma das duas Estratégias informando o nome do keyspace. Caso não exista, o keyspace será criado.

Para demonstrar esse novo recurso será usado um simples exemplo: o seu objetivo será apenas recolher uma resposta de qualquer usuário para a seguinte pergunta: “O que você acha do Cassandra?”.

Para fazer esse exemplo utilizaremos o Tomcat como servidor, JSF (Java Server Faces) na visão e o Google Guice como injeção de dependência.

A injeção de dependência é um padrão de desenvolvimento muito conhecido no mundo Java, é ideal principalmente para manter baixo acoplamento entre diferentes camadas do sistema. Nesse modo o responsável por injetar esse recurso será o container de injeção, fazendo que algumas vezes o programador não saiba de onde vem tal recurso. O Google apresenta um framework open source para injeção de dependência, o Google Guice que atualmente está na versão 3.0.

O principal objetivo do Guice é ser bem leve em comparação ao Spring, além de não precisar de um grande número de XMLs (você consegue injetar dependência sem usar nenhum!). Outra informação bastante interessante é que nessa versão ele implementa a JSR 330. O Guice também trabalha na injeção de dependência em OSGI, Struts, Swing, JPA e também em Servlets. Trata-se de um kit completo de injeção de dependência para o desenvolvimento nas plataformas JEE, JSE e também Android com o RoboGuice (http://code.google.com/p/roboguice/).

Como o objetivo é estar apenas armazenando o usuário e sua pergunta, modelamos o objeto a ser salvo, que ficará do seguinte modo:

Listagem 1: Modelagem de objeto a ser salvo

@Entity
public class Post implements Serializable;
   @Id
    private String nickName;
    
    @Column
    private String text;
public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

Nele se encontram dois atributos: o primeiro representa o nome do usuário, que será a chave para o Cassandra, e o segundo será a sua resposta.

Estaremos usando os qualificadores do Google Guice, a ideia é que a partir da anotação seja definido o tipo de persistência sequencial e randômico. Conforme mostra a Listagem 2.

Listagem 2: Definição dos qualificadores

@BindingAnnotation @Target({ FIELD, PARAMETER, METHOD }) @Retention(RUNTIME)
public @interface Random {}
@BindingAnnotation @Target({ FIELD, PARAMETER, METHOD }) @Retention(RUNTIME)
public @interface Sequencial {}

Dessa maneira torna-se fácil definir qual é o tipo de persistência a ser utilizado. Os qualificadores são feitos a partir de uma anotação.

Listagem 3: Injetando os serviços e definido a implementação de cada persistência

public class PersistenceService {

    @Inject @Sequencial
    private ServiceClient sequencialClient;
    
    @Inject @Random
    private ServiceClient randomClient;
    
    public ServiceClient getRandom(){
    	return randomClient;
    }
    public ServiceClient getSequencial(){
    	return sequencialClient;
    }
}

A criação dos dois tipos é bastante semelhante, o primeiro é adicionando os hosts, feito isso já se pode chamar qualquer uma das formas de estratégia de persistência conforme mostra a Listagem 3.

Listagem 4: Adicionando nodes

  EasyCassandraManager.getPersistence("javabahia", "localhost", 9160);
        EasyCassandraManager.getPersistence("javabahia", "node2", 9160);
        EasyCassandraManager.getPersistence("javabahia", "node3", 9160);
        EasyCassandraManager.addFamilyObject(Post.class);

Na Listagem 4 estamos adicionando nodes para que o Easy-cassandra consiga gerenciar as instâncias do banco e, em seguida, adicionando a classe para que essa possa ser gerenciada a partir de JPQL (Java Persistence Query Language).

O código desenvolvido fornece duas opções de inserir sua resposta: uma sequencial e uma randômica e tão logo é inserida a informação, ela é recuperada e lançada em forma de lista das duas formas.

Nesse pequeno artigo foram apresentadas duas estratégias para a persistência com multi-nodes usando o Easy-Cassandra. A ideia principal foi demonstrar a importância de compartilhar os trabalhos com as outras instâncias, já que não adianta possuir muitos nós e todas as requisições ficarem apenas em um deles, gerando todo o gargalo. Além disso, foi demonstrado um pouco dos recursos do Google Guice e sua integração com o framework.

Para maiores informações sobre o Easy-Casandra e o Google Guice, acesse os links:

Espero que as informações apresentadas possam ser úteis. Até a próxima.

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?