Desenvolvimento com soluções livres

Dicas e considerações iniciais ao usar o Cassandra

2014-04-07T20:40:00.002-03:00

Ao se pensar em um banco de dados a primeira coisa que um desenvolvedor de software pensa é em realizar buscas, queries, realizar a normalização. Mesmo depois de tanto tempo com várias discussões com NOSQL, muitas pessoas ainda acreditam que o NOSQL, mas vale lembrar que muitas coisas mudaram no mundo do desenvolvimento de software e isso inclui os bancos de dados, existem muitas soluções além da convencional para armazenar informações. O objetivo desse artigo é discutir é ajudar aquelas pessoas que pretendem ao utilizam o Cassandra em pouco tempo fornecendo algumas dicas.

Saber quando utilizar a tecnologia: Antes de escolher uma tecnologia é muito importante entender bem o seu problema e em seguida entender o motivo no qual a tecnologia escolhida será útil em seu projeto. Com o Cassandra não é diferente, ele é um banco NOSQL é interessante seu uso quando se precisa de uma alta disponibilidade e tolerância a falhas (seria o A e o P no teorema do CAP). Possui uma escalabilidade linear, ou seja, quanto mais nós em seu datacenter maior será o número de requisições por segundo.

O Cassandra não é relacional: Uma coisa muito comum das pessoas ao aprender uma nova tecnologia é tentar realizar relações com a técnologia já conhecida, o problema é que em alguns casos os estudantes ultrapassam o estudo e tentam simular o SQL dentro do Cassandra. O Cassandra foi feito em cima de um outro “paradigma” de persistência o BASE é muito importante entender que ao tentar realizar emulações de ACID dentro de um BASE, não se conseguirá atingir nenhum dos objetivos (O erro ficará oculto com uma massa pequena, mas quando for para produção com uma grande massa o erro será desastroso).

Não existe normalização no Cassandra: Um erro muito comum dentro do Cassandra é tentar realizar a normalização. Como já dito anteriormente o Cassandra foi feito em cima de outro paradigma. O fato é que a normalização se tornou muito popular em 1970, quando o armazenamento era muito caro, assim o desafio era conter a informação de forma econômica, dessa forma não repeti-la. Atualmente o armazenamento está ficando cada vez mais barato e o desafio mudou: É lidar, por exemplo, com um número de requisição cada vez maior (milhões, talvez bilhões).

Hierarquia dentro do Cassandra: A hierarquia dos bancos relacionais segue o seguinte fluxo: banco, tabela e coluna. No Cassandra acontece de forma semelhante no topo temos o KeySpace, família de colunas, e a coluna, esse por sua vez é composto por um bloco com três informações: O nome do tampo, o valor do campo e o timestamp.

No Cassandra não existe transação: O Cassandra foi feito para trabalhar com uma alta taxa de disponibilidade, desse modo, é inviável que exista transação, é possível enviar vários registros em uma mesma família de coluna ao mesmo tempo. Para saber qual versão é a mais recente ele utiliza o timestamp existente no campo, acontece que quando um campo é inserido, ele recebe o timestamp do momento que foi inserido.

Nível de Consistência: O Cassandra trabalha em cima da replicação da informação para ter sua característica tolerante a falhas. Ao se criar um keyspace setta o fator de réplica, que define a quantidade de nós na qual a informação será duplicada. Após isso toda requisição, tanto escrita quanto leitura, é feita em cima do fator de réplica ao enviar uma informação para o Cassandra é importante entender a diferença entre disponibilidade e consistência. Se ao realizar uma requisição for definido uma consistência alta, por exemplo, o ALL que é o número de fator de réplica defina no momento da criação/alteração do keyspace, o processo só será finalizado quando enviar para todos os nós definido. Diferente de um nível baixo, como o ONE que enviará a solicitação para apenas um nó, deixando os outros nós prontos para trabalharem em outras requisições, realizando a réplica em background elevando assim o nível de disponibilidade.

Não existe relacionamento: Uma boa prática de para usar o Cassandra é desnormalizando sua base, desse modo, não existem relacionamentos. Se, por exemplo, você tem duas tabelas, pessoa e endereço em uma relação um para um, no Cassandra o mais correto seria uma família de coluna contendo as duas tabelas, mesmo que existam duas possas que tenham o mesmo endereço, replicando o endereço.

Busque informações pela chave: O uso de um campo auto-increment como chave no Banco de dados deve ser evitado. Dentro do Cassandra, por padrão, o único campo no qual se pode buscar informações é a chave, caso você queria adicionar mais campos “buscáveis” basta defini-lo como índice, mas se deve evitar por questão de performance. No caso de uma tabela pessoa a chave poderia ser o cpf ou o nickname.

O único campo obrigatório é a chave: No Cassandra o único campo obrigatório é a chave, desse modo, podem existir registros com 10, 20, 100, ou nenhuma coluna, desde que o mesmo possua uma chave. Os campos são criados por demanda, se um registro não tiver o campo “telefone”, por exemplo, ele de fato não existirá, diferente do banco relacional em que a coluna existe para todos os registros com o valor null.

Não existe Constraints: O constraints muito utilizado para regras dos seus dados não existem dentro do Cassandra, pode parecer estranho para alguns, mas atualmente tal recurso não se torna desnecessário. Não é muito comum, por exemplo, colocar para o usuário a mesma mensagem de erro que o banco retornou como o: “there is no unique constraint matching given keys for referenced table "tec_configurations"” ou “null value in column "pessoa_nome" violates not-null constraint” e sim “nickname já cadastrado” e “campo nome obrigatório”, ou seja, as regras já estão dentro do seu software. Outro exemplo, caso se insira, utilizando um insert, a mesma informação duas vezes, vai funcionar normalmente já que a informação é apenas colocada lá, caso ela já exista será sobrescrita.

Views materializadas: Em alguns momentos precisamos realizar cálculos em uma aplicação (somatório, média, etc.). Imaginando um sistema que mede a temperatura de uma determinada cidade e os sensores enviam informação a cada milissegundo pode-se deixar essa informação preprocessada em uma família de colunas, muito semelhante as view materializadas nos bancos relacionais. Esse recurso é muito utilizado, é muito comum se ter várias famílias de colunas como estas, o ideal é que sua modelagem seja feita de acordo com sua busca. No caso do sistema de temperatura se pode ter uma família de colunas para média por dia, mês e ano, para acompanhar o histórico de temperatura de uma cidade.

Sua aplicação também precisa escalar: Não adianta ter um banco escalável preparado para receber mil requisições por segundo, se sua aplicação envia apenas 1 requisição por segundo. Desse modo é importante entender que sua aplicação também precisa escalar.

Cassandra Query Language: Para facilitar a vida do desenvolvedor existe o Cassandra Query Language, o CQL. Com ele é possível criar e modificar estruturas e realizar manipulações de dados de uma maneira mais tranquila e muito mais fácil. O interessante é que esse recurso possui uma sintaxe muito semelhante ao SQL. Para executar e verificar os CQLs se pode usar o DataStax DevCenter que possui sua interface baseada no eclipse.

Coleções muitos grandes: Um recurso que entrou recentemente no banco é o uso de três coleções: o list (uma lista de informações), o set (uma lsita sem valor duplicado), e um map (um dicionário de dados, possui um valor para uma chave correspondente). Esse recurso é muito interessante e é importante utilizado, mas tome cuidado para que essas coleções não sejam muito grandes. O interessante é que ela no geral não ultrapassagem 260KB ou 75KB.

Acompanhe seus nós: É interessante acompanhar a performance, topologia do seu datacenter. Na configuração o recomendado é que o commitlog e o sstable estejam em discos diferentes e que esses discos sejam SSDs. Outra dica importante é ter cuidado com o tamanho do heap na maioria dos casos o padrão resolverá (é feito um calculo de heap baseado em memória disponível), caso modifique o recomendado é que não ultrapasse os 8GB. Uma solução para acompanhar seus nós é o DataStax OpsCenter.

Concluindo, nesse pequeno artigo foi demonstrado algumas dicas inicias para os usuários do Cassandra, demonstrando que é muito comum tentar simular o SQL dentro do Cassandra, tenderá a ter consequências desastrosas.

Links:

http://techblog.netflix.com/2011/11/benchmarking-cassandra-scalability-on.html

http://www.slideshare.net/mattdennis

http://www.datastax.com/download

http://cassandra.apache.org/doc/cql3/CQL.html

Easy-Cassandra, a versão 2.0.1

2014-02-13T19:33:00.000-03:00

Lançada a nova versão do Easy-Cassandra, a versão 2.0.1, dentre as novidades podemos citar;

Refatoração nos contrutores 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

Um ponto importante é que para facilitar a configuração foi criada uma classe que é passada no parâmetro, a classe ClusterInformation, dessa maneira fica mais simples (além do código mais limpo, afinal sobrecarga de construtores não é uma boa prática) de se criar simples configurações para a fábrica. Como, por exemplo:

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

Criando configuração para a fábrica de conexão
Dessa forma a configuração para usar o Spring no Cassandra também mudou para:






 
 
  
   localhost
  
 



 
 
  
   org.easycassandra.persistence.cassandra.spring.entity.Contact
            org.easycassandra.bean.model.Step
            org.easycassandra.bean.model.Weight

Nova configuração do Spring no Easy-Cassandra
Talvez a melhoria mais marcante nessa versão são os recursos dos QueryBuilders, os queryBuilders são maneiras muito mais fácil de fazer interações com o Cassandra com configurações adversas de uma maneira mais simples, com ele é possível definir o nível de consistência, definir o timeStamp, quais campos serão manipulados.

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

Simples exemplo inserindo valores a partir da chave

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

criando toda a query de atualização

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

executando uma atualização assincronamente

InsertBuilder insert= persistence.updateBuilder(SimpleQueryBuilder.class);
Set set = new HashSet<>();
set.add("Linda");
Map 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();

Realizando inserção

  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 insert2 = persistence.updateBuilder(simpleBean);
    insert2.executeAsync((new ResultAsyncCallBack() {
    @Override
    public void result(Boolean bean) {
        // do some action
    }
    });

realizando inserção de modo assíncrono

  DeleteBuilder delete = persistence.deleteBuilder(SimpleQueryBuilder.class); 
    delete.whereEq(Constant.INDEX, ONE_HUNDRED_TWO).whereEq(Constant.KEY, ONE_HUNDRED_TWO).execute();

    DeleteBuilder 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();

primeira query remove todas as colunas a partir da chave, na segunda query remove apenas os campos map, list e set.

 SimpleID id = new SimpleID();
    id.setIndex(ONE_HUNDRED_TWO);
    id.setKey(ONE_HUNDRED_TWO);

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

remoção assíncrona

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

Realizando o select em que o campo nome é igual a nome e o indice está em um, dois e três.

SelectBuilder select = persistence.selectBuilder(SimpleQueryBuilder.class);
select.eq(NAME, NAME).gt("index", THREE).asc(INDEX).executeAsync(new ResultAsyncCallBack>() {

        @Override
        public void result(List beans) {
          // do some thing
        }
    });

Executando query assincronamente em que o indece seja mais que três e seja ordenado de forma descendente no índice.
O Batch é um recurso no cassandra que permite que se execute alterações no banco (inserção, atualização e remoção) de forma atômica, desse forma se pode enviar insert, updates e deletes como se fosse apenas uma requisição.

DeleteBuilder delete = dao.deleteBuilder();
    delete.whereEq(Constant.INDEX, Constant.ONE_HUNDRED_TWO)
            .whereEq(Constant.KEY, Constant.ONE_HUNDRED_TWO);

    InsertBuilder 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 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() {
        @Override
        public void result(Boolean bean) {
            // do some action
        }
    });

Executando processo de inserção, remoção e atualização de forma atômica com o BatchBuilder.
Vale lembrar que recurso do Batch deve ser usados em casos específicos, já que distribuir as requisições entre os nós, no cassandra, sempre será sua melhor amiga.
Esse artigo tem como objetivo ilustrar as mudanças dentro do Easy-Cassandra, se demonstrou dos recursos e da sua melhoria na velocidade a expectativa é que muitos mais recursos estejam por vir.

Como compilar código Java dinâmicamente

2014-01-29T19:56:00.001-03:00

O Java é uma plataforma que se multiplicou exponencialmente, uma de sua grande vantagem é o fato de que você consegue com o mesmo código executar em diferentes plataformas, com isso se pode programar para servidor, dispositivos embarcados, desktop, etc. com a mesma linguagem. Além disso a JVM possui suporte para diversas linguagens, das quais possuem, diversas características e recursos interessantes. Um mito que existe é que o Java não compila em tempo de execução, o que faz muitas pessoas utilizem uma linguagem dinâmica, apenas por esse objetivo, mas será que isso é verdade?

Possuir uma linguagem dinâmica é muito interessante para alguns projetos específicos, por exemplo, quando se faz um projeto que realiza calculo tributário, como essa fórmula mudam muito ao ano e variam de município para município, nesse caso é melhor que o código fonte esteja em um banco de dados, por exemplo, para quando for necessário modificar o calculo não seja necessário compilar todo o código fonte e fazer o deploy, correndo o risco do sistema ficar fora do ar mesmo que por alguns instantes.

Sim é possível em Java compilar códigos dinamicamente. Na verdade isso é muito comum do que imaginamos! Por exemplo, o Hibernate para gerenciar das entidades, para facilitar ainda o seu uso a partir da versão 1.6 com a JSR 199 foi criada um API com essa finalidade.

Para demonstrar essa funcionalidade será usado a solução para o problema acima, fazer com que haja troca de fórmula, para facilitar a demonstração e focar na solução serão as 4 operações básicas, sendo que esse código fonte estará no banco de dados, no caso será simulado com arquivos dentro de um txt. Como não podemos referenciar uma classe não compilada, criaremos uma interface Operação, ela será implementada por nossas classes que estarão em nosso “banco de dados”.

public interface Calculo { 

 Double calcular(Number valorA, Number valorB);  
  
}

Interface na qual será utilizada como referencias as classes compiladas dinamicamente.

Explicando o processo de compilação passo a passo: A classe JavaCompiler, que tem a responsabilidade de fazer a compilação do código-fonte. A chamada ToolProvider.getSystemJavaCompiler() retorna este objeto. Se um compilador Java não estiver disponível, o retorno será null. Ele conta com o método getTask(), que retorna um objeto CompilationTask. De posse desse objeto, a chamada call() efetua a compilação do código e retorna um booleano indicando se ela foi feita com sucesso (true) ou se houve falha (false).

public class JavaDinamicoCompilador { 
 
  private JavaCompiler compiler; 

  private JavaDinamicoManager javaDinamicoManager; 

  private JavaDinamicoClassLoader classLoader; 

  private DiagnosticCollector diagnostics; 

  public JavaDinamicoCompilador() throws JavaDinamicoException { 
    compiler = ToolProvider.getSystemJavaCompiler(); 
    if (compiler == null) { 
     throw new JavaDinamicoException("Compilador não encontrado"); 
    } 

    classLoader = new JavaDinamicoClassLoader(getClass().getClassLoader()); 
    diagnostics = new DiagnosticCollector(); 

    StandardJavaFileManager standardFileManager = compiler 
        .getStandardFileManager(diagnostics, null, null); 
    javaDinamicoManager = new JavaDinamicoManager(standardFileManager, classLoader); 
  } 

  @SuppressWarnings("unchecked") 
  public synchronized Class compile(String packageName, String className, 
      String javaSource) throws JavaDinamicoException 
  { 
    try { 
      String qualifiedClassName = JavaDinamicoUtils.INSTANCE.getQualifiedClassName( 
          packageName, className); 
      JavaDinamicoBean sourceObj = new JavaDinamicoBean(className, javaSource); 
      JavaDinamicoBean compiledObj = new JavaDinamicoBean(qualifiedClassName); 
      javaDinamicoManager.setSources(sourceObj, compiledObj); 

      CompilationTask task = compiler.getTask(null, javaDinamicoManager, diagnostics, 
          null, null, Arrays.asList(sourceObj)); 
      boolean result = task.call(); 

      if (!result) { 
       throw new JavaDinamicoException("A compilação falhou", diagnostics); 
    } 

      Class newClass = (Class) classLoader.loadClass(qualifiedClassName); 
      return newClass; 

    } 
    catch (Exception exception) { 
      throw new JavaDinamicoException(exception, diagnostics); 
    } 
  } 
}

Classe responsável pela compilação

O processo de compilação envolve dois tipos de arquivos: os códigos-fonte escritos em Java e os arquivos compilados (bytecodes). Na Compiler API estes arquivos são representados por objetos de uma única interface, chamada JavaFileObject. Felizmente a API disponibiliza uma classe que implementa esta interface, chamada SimpleJavaFileObject e, na escrita de código de compilação dinâmica, deve-se criar uma subclasse de SimpleJavaFileObject e sobrescrever os métodos necessários.

public class JavaDinamicoBean extends SimpleJavaFileObject { 

  private String source; 

  private ByteArrayOutputStream byteCode = new ByteArrayOutputStream(); 

 
  public JavaDinamicoBean(String baseName, String source) { 
    super(JavaDinamicoUtils.INSTANCE.createURI(JavaDinamicoUtils.INSTANCE.getClassNameWithExt(baseName)), 
        Kind.SOURCE); 
    this.source = source; 
  } 
  
  public JavaDinamicoBean(String name) { 
    super(JavaDinamicoUtils.INSTANCE.createURI(name), Kind.CLASS); 
  } 

  @Override 
  public String getCharContent(boolean ignoreEncodingErrors) { 
    return source; 
  } 

  @Override 
  public OutputStream openOutputStream() { 
    return byteCode; 
  } 

  public byte[] getBytes() { 
    return byteCode.toByteArray(); 
  } 
}

Estrutura de dados que contem o codigo fonte e a classe compilada

Para representar os arquivos envolvidos será utilizado o ForwardingJavaFileManager que implementa a interface JavaFileManager.

public class JavaDinamicoManager extends ForwardingJavaFileManager { 
  private JavaDinamicoClassLoader classLoader; 
  
 
  private JavaDinamicoBean codigoFonte; 
 
  private JavaDinamicoBean arquivoCompilado; 
  
  public JavaDinamicoManager(JavaFileManager fileManager, JavaDinamicoClassLoader classLoader) 
  { 
    super(fileManager); 
    this.classLoader = classLoader; 
  } 

  public void setSources(JavaDinamicoBean sourceObject, JavaDinamicoBean compiledObject) { 
    this.codigoFonte = sourceObject; 
    this.arquivoCompilado = compiledObject; 
    this.classLoader.addClass(compiledObject); 
  } 

  @Override 
  public FileObject getFileForInput(Location location, String packageName, 
      String relativeName) throws IOException 
  { 
    return codigoFonte; 
  } 

  @Override 
  public JavaFileObject getJavaFileForOutput(Location location, 
      String qualifiedName, Kind kind, FileObject outputFile) 
      throws IOException 
  { 
    return arquivoCompilado; 
  } 

  @Override 
  public ClassLoader getClassLoader(Location location) { 
    return classLoader; 
  } 
}

Classe responsável por gerenciar as classes compiladas e não compiladas

Para que ela possa ser utilizada, a JVM deve ser capaz de reconhecê-la como uma classe da aplicação, a fim de que possa carregá-la quando chegar o momento. O componente responsável pelo carregamento das classes das aplicações Java durante a execução é o Class Loader.
Portanto, para que a JVM saiba da existência das novas classes compiladas, é necessário implementar um class loader customizado, que fica atrelado ao gerenciador de arquivos.
Ele deve estender a classe ClassLoader (do pacote java.lang) e tem a responsabilidade de carregar as classes recém-criadas.
Com isso foi discutido um pouco sobre a compilação dinâmica do Java no Java, objetivo aqui foi apenas de demonstrar o seu funcionamento básico além de uma pequena explicação do uso da API. Pela sua complexidade o ideal é que ela esteja encapsulado a ponto de ser utilizadas várias vezes em diversos projetos. O objetivo aqui não foi desmerecer em nenhum momento as outras linguagens de programação rodando ou não em cima da JVM, afinal todas elas têm sua importância. O objetivo foi demonstrar que não existe a necessidade de mudar de linguagem caso seu problema seja ter um código que seja compilado dinamicamente.

Referências:

https://www.jcp.org/en/jsr/detail?id=199
Carlos Eduardo Gusso Tosin, Compilação Dinâmica no Java 6 - Revista Java Magazine 94
Código: https://github.com/otaviojava/java_dinamico

Cassandra Trip Brasil [Agradecimentos]

2013-10-02T23:55:00.000-03:00

O evento Cassandra aconteceu entre os dias 2 e 6 de setembro com o objetivo de falar dos conceitos de nosql, bigdata, do cassandra e da sua arquitetura além das novidades com a nova versão, o Cassandra 2.0. O evento foi um sucesso, com isso, gostaríamos de agradecer todos que participaram e ajudaram o evento de alguma forma.
Para saber mais sobre o Cassandra, trocar experiência e tirar dúvidas técnicas ou conceituais foi criado o grupo Cassandra Trip Brasil, para mais informações aqui.
Slides utilizados no evento:

http://www.slideshare.net/bcoverston/tutorial-session
http://www.slideshare.net/edwardribeiro/cassandra-tripbrasil
http://www.slideshare.net/otagonsan/cassandra-trip

Fotos da Trip: http://goo.gl/mFVDsl
Existirá uma próxima atividade para o Cassandra que é o um mini-curso gratuito de Cassandra. No dia 10 de outubro, quinta-feira, na Global Code.
Título: Primeiros passos com o Cassandra
Descrição: O Cassandra é um banco de dados NOSQL orientado à família de coluna que nasceu para resolver problemas com aplicações que precisam operar com gigantescas cargas de dados além de poder escalar com grande facilidade. Ele nasceu no facebook e hoje vem sendo usado intensamente por empresas dos mais variados portes, tais como Netflix, Twitter, Instagram, HP, IBM, dentre muitas outras. Um fator importante que vale ser citado é a sua adoção crescente inclusive em mercados mais conversadores tais como, instituições financeiras e agências governamentais como a NASA.
Público alvo: Desenvolvedores, DBAs, entusiastas com curiosidade de conhecer mais sobre bancos de dados nosql e o banco Cassandra.
Ementa:

Conceito Data Science
Conceito BigData
NOSQL
Histórico
Tipos de Bancos
Comparação com o Modelo relacional
Cassandra
Arquitetura Cassandra
Configurações Básica do Cassandra
Configuração de multi-nodes no Cassandra
Conhecendo o DevOpsCenter
Instalando os Agentes

Para aqueles que não são de São Paulo:
Link : https://globalcode.webex.com/globalcode/onstage/g.php?t=a&d=662489296
Pass: cassandra
Mais informações: http://goo.gl/S3LQBm

JavaBahia e Linguágil no Cassandra Trip Brasil

2013-08-31T12:05:00.000-03:00

O Cassandra é um banco de dados NOSQL orientado à família de coluna que nasceu para resolver problemas com aplicações que precisam operar com gigantescas cargas de dados além de poder escalar com grande facilidade. Ele nasceu no facebook e hoje vem sendo usado intensamente por empresas dos mais variados portes, tais como Netflix, Twitter, Instagram, HP, IBM, dentre muitas outras. Um fator importante que vale ser citado é a sua adoção crescente inclusive em mercados mais conversadores tais como, instituições financeiras e agências governamentais como a NASA.
Com o intuito de divulgar essa idéia aqui no Brasil foi criado o Cassandra Trip Brasil, um evento com duração de uma semana, entre os dias 2 até 6 de setembro, sendo que cada dia será apresentado em uma cidade diferente. As cidades que sediarão esse evento serão:

2 de Setembro, segunda-feira, Campinas
3 de setembro, terça-feira, São Paulo
3 de setembro, terça-feira, Online para todo o Brasil
4 de setembro, quarta-feira, Florianópolis
5 de setembro, quinta-feira, Brasília
6 de setembro, sexta-feira, Salvador

O evento contará com o palestrante internacional Ben Covertson que hoje faz parte do time da DataStax, empresa que mantém o banco de dados Cassandra.
O JavaBahia e o Linguágil farão parte desse evento aqui no Brasil, fazendo o encontro técnico dos grupos como parte do circuito. O encontro acontecerá na Estácio/FIB.

Data: 6 de setembro, Serça-Feira
Horário: 18:30
Cidade: Salvador
Local: Estácio/FIB Auditório do Andar G1
Endereço: Rua Xingu, nº 179 - Jardim Atalaia/STIEP CEP: 41770-130

Para saber mais do evento e os endereços das outras cidades que também farão parte do Trip e inscrições: http://otaviojava.github.io/cassandra-trip-brasil/

Apoio:

Usando Cassandra com Spring Data no Easy-Cassandra

2013-08-25T07:57:00.000-03:00

O Spring é um framework open source cujo o objetivo sempre foi facilitar a vida do desenvolvedor Java, começou com os recursos para injeção de dependência e hoje atua em diversas atividades triviais para um programador. Entre elas podemos citar a parte social com o Spring social no twitter, facebook, segurança com o Spring security além do já inversão de controle e inversão de dependência. O foco desse pequeno post é falar sobre o Spring Data e seu trabalho com o banco não relacional Cassandra.

O Spring-data é um pequeno módulo ou plugin do Spring e tem como objetivo auxiliar nos processos triviais de persistência criando uma camada entre a base onde se encontra as informações e o seu código java. Dessa maneira é possível, efetuar ações na base, usando como estrutura para as informações, o POJO (simples e velho objetos em java). Dentro do Spring Data já existem diversos tipo de base de informações.

Bancos Relacionais com JPA e JDBC
BigData com Apache Hadoop
Data-Grid com GermFire
HTTP com Rest
NOSQL com MongoDB, Neo4J, Redis e Hbase

Uma das grandes vantagem do Spring Data é ser filho do Spring. Ele não precisa de um servidor Java EE, ou seja, ele pode rodar em um simples contêiner como o tomcat ou mesmo rodar sem o auxílio do servidor. Sua injeção funciona com auxílio de um arquivo xml, mas não necessariamente toda configuração é feita por lá, existem várias anotações que podem ajudar o desenvolvedor, no entanto, cabe apenas ao mesmo saber em qual momento é mais adequado usar cada um deles.

Com esse foco o Spring Data Cassandra tem o foco de criar uma camada de alto nível para o nosql Cassandra, assim é possível com estruturas de POJOs estabelecer uma conexão no banco e realizar as operações CRUD, tudo isso sem abrir mão da estrutura de dados já conhecida pelo desenvolvedor Java. O Spring Data Cassandra ainda não foi fechada, mas o Easy-Cassandra já possui integração com Spring, agora é possível utilizá-lo com a injeção de dependências do framework Java mais famoso do mundo.

A aplicação será realmente bastante simples seu objetivo será apenas criar uma informação e armazenar no banco, em seguida recuperar pelo id. O primeiro passo será a criação da entidade pessoa, ela terá os campos id, nome e ano, conforme mostra a tabela número1.


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

    @Id 
    private UUID id; 
     
    @Index 
    @Column(name = "name") 
    private String name; 
    
    @Column(name = "born") 
    private Integer year;
//getter and setter

}

Simples Pojo da Classe pessoa

Como pode ser visto os campos são anotados via JPA 2.0, o segundo passo é a criação do xml, é nele que conterá as configurações do banco de dados (host, porta, keyspace padrão, etc.). O próximo passo é a configuração e criação da fábrica de conexões para o Cassandra dentro do spring, isso é, o host, porta e o keyspace padrão, e as classes que serão mapeadas como mostra no arquivo xml abaixo.


 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">

 

 
 
 
  
   org.javabahia.cassandra.spring.entity.Person

Configuração do Spring-Data, informando as configurações do Banco (host, porta, nesse caso a padrão, e o keySpace) além de criar o Template Cassandra

Com a fábrica de conexões do cassandra é possível retornar uma sessão, a via de comunicação do Cassandra com a aplicação Java, além disso será criado o CassandraTemplate, uma api de alto nível que consegue realizar a comunicação Cassandra sua aplicação a partir de um simples POJO, desse modo é possível realizar a operação CRUD de uma maneira bastante simples, o código abaixo mostra a interface do Cassandra template.



public interface CassandraTemplate{ 
   
     <T> T save(T entity); 
     
     <T> Iterable<T> save(Iterable<T> entities); 
     
     <T> void delete(T entity); 
     
     <T> void delete(Iterable<T> entities); 
     
     <K> void delete(K key, Class<?> entity); 
     
     <K,T> void delete(Iterable<K>  keys, Class<T> entity); 

     <T> void deleteAll(Class<T> entity); 
     
     <T> T update(T entity); 
     
     <T> Iterable<T> update(Iterable<T> entities); 
     
     <T,K> T findOne(K key, Class<T> entity); 
     
     <T,K> List<T> findAll(Iterable<K> keys, Class<T> entity); 
     
     <T> List<T> findAll(Class<T> entity); 
     
     <T,I> List<T> findByIndex(String columnName,I index,Class<T> entity); 
     
     <K,T>boolean exist(K key, Class<T> entity); 

     void executeUpdate(String query);

Operações que podem ser realizadas com o seu Objeto

Além do CassandraTemplate existe o CassandraRepository, essa classe abstrata implementa o CrudRepository do SpringData, com ela é necessário apenas implementar o método que retornará o CassandraTemplate, conforme mostra a tabela abaixo.


@Repository("personRepository")
public class PersonRepository extends CassandraRepository<Person, UUID>{

 
 @Autowired
 private CassandraTemplate cassandraTemplate;
 
 @Override
 protected CassandraTemplate getCassandraTemplate() {
  return cassandraTemplate;
 }

}

Criando o repositório para a classe Person

Como o CassandraReporitory implementa a classe base de operações do Spring todas as suas operações estarão disponíveis para serem utilizadas com o Cassandra.


public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> { 
 <S extends T> S save(S entity); 

 <S extends T> Iterable<S> save(Iterable<S> entities); 

 T findOne(ID id); 

 boolean exists(ID id); 

 Iterable<T> findAll(); 

 Iterable<T> findAll(Iterable<ID> ids); 

 long count(); 

 void delete(ID id); 

 void delete(T entity); 
 void delete(Iterable<? extends T> entities); 

 void deleteAll(); 
}

Interface CrudRepository do Spring Data que é implementada pela classe abstrata CassandraRepository

Realizado as configurações o próximo passo é executar o projeto como mostra o código a seguir:


public class App 
{
    public static void main( String[] args )
    {
     @SuppressWarnings("resource")
  ApplicationContext ctx = new GenericXmlApplicationContext("SpringConfig.xml");
     
     PersonRepository personService=ctx.getBean(PersonRepository.class);
     
     UUID uuid=UUID.randomUUID();
     Person person=new Person();
     person.setId(uuid);
     person.setName("Otávio Santana");
     person.setYear(25);
     
     personService.save(person);
     
     
     Person otavio=personService.findOne(uuid);
     System.out.println(otavio.getName());
     
     
    }
}

Rodando o Simples Projeto, salvando e recuperando a informação

Com isso foi demonstrado o conceito do Spring Data e o seu funcionamento com o Cassandra utilizando o Easy-Cassandra, o intuito criar uma interface padrão para que todos os modelos de persistência a utilizem dentro do Spring é um grande e importante passo para utilizar uma nova base ou modelo de dados não haja impacto dentro do Spring, mas é muito importante salientar que mesmo que vários bancos utilizem essa interface é importante considerar uma nova modelagem, já que diferente dos bancos relacionais, a mudança de um banco NOSQL pode significar a mudança estrutura de armazenamento.

Cassandra Trip Brasil

2013-08-13T19:07:00.002-03:00

Com o intuito de divulgar essa idéia aqui no Brasil foi criado o Cassandra Trip Brasil, um evento com duração de uma semana, entre os dias 2 até 6 de setembro, sendo que cada dia será apresentado em uma cidade diferente. As cidades que sediarão esse evento serão:

2 de Setembro, segunda-feira, Campinas
3 de setembro, terça-feira, São Paulo
3 de setembro, terça-feira, Online para todo o Brasil
4 de setembro, quarta-feira, Florianópolis
5 de setembro, quinta-feira, Brasília
6 de setembro, sexta-feira, Salvador

Na terça-feira também acontecerá o web-cast aberto para todo o Brasil.

O evento contará com o palestrante internacional Ben Covertson que hoje faz parte do time da DataStax, empresa que mantém o banco de dados Cassandra.

Para saber mais: http://otaviojava.github.io/cassandra-trip-brasil/

Com o intuito de compartilhar experiência, tirar dúvidas, ajudar a divulgação do banco Cassandra aqui no Brasil, foi criado o Grupo Cassandra Brasil via Google Groups.

Informações: https://groups.google.com/forum/#!forum/cassandra-brasil

Cassandra Trip Brasil

2013-08-13T19:06:00.007-03:00

2 de Setembro, segunda-feira, São Paulo
3 de setembro, terça-feira, Campinas
4 de setembro, quarta-feira, Florianópolis
5 de setembro, quinta-feira, Brasília
6 de setembro, sexta-feira, Salvador

O evento contará com o palestrante internacional Ben Covertson que hoje faz parte do time da DataStax, empresa que mantém o banco de dados Cassandra.

Para saber mais: http://otaviojava.github.io/cassandra-trip-brasil/

Com o intuito de compartilhar experiência, tirar dúvidas, ajudar a divulgação do banco Cassandra aqui no Brasil, foi criado o Grupo Cassandra Brasil via Google Groups.

Informações: https://groups.google.com/forum/#!forum/cassandra-brasil

Cassandra Trip Brasil

2013-08-13T19:06:00.005-03:00

2 de Setembro, segunda-feira, São Paulo
3 de setembro, terça-feira, Campinas
4 de setembro, quarta-feira, Florianópolis
5 de setembro, quinta-feira, Brasília
6 de setembro, sexta-feira, Salvador

O evento contará com o palestrante internacional Ben Covertson que hoje faz parte do time da DataStax, empresa que mantém o banco de dados Cassandra.

Para saber mais: http://otaviojava.github.io/cassandra-trip-brasil/

Com o intuito de compartilhar experiência, tirar dúvidas, ajudar a divulgação do banco Cassandra aqui no Brasil, foi criado o Grupo Cassandra Brasil via Google Groups.

Informações: https://groups.google.com/forum/#!forum/cassandra-brasil

Cassandra Trip Brasil

2013-08-13T19:06:00.003-03:00

2 de Setembro, segunda-feira, São Paulo
3 de setembro, terça-feira, Campinas
4 de setembro, quarta-feira, Florianópolis
5 de setembro, quinta-feira, Brasília
6 de setembro, sexta-feira, Salvador

O evento contará com o palestrante internacional Ben Covertson que hoje faz parte do time da DataStax, empresa que mantém o banco de dados Cassandra.

Para saber mais: http://otaviojava.github.io/cassandra-trip-brasil/

Com o intuito de compartilhar experiência, tirar dúvidas, ajudar a divulgação do banco Cassandra aqui no Brasil, foi criado o Grupo Cassandra Brasil via Google Groups.

Informações: https://groups.google.com/forum/#!forum/cassandra-brasil

Cassandra Trip Brasil

2013-08-07T20:10:00.000-03:00

Com o intuito de evangelizar essa ideia aqui no Brasil foi criado o Cassandra Trip Brasil, o evento terá duração de uma semana, entre os dias 2 até 6 de setembro, sendo que cada dia será apresentado em uma cidade diferente. As cidades que sediarão esse evento serão:

2 de setembro, segunda-feira: Campinas
3 de setembro, terça-feira: São Paulo
4 de setembro, quarta-feira: Florianópolis
5 de setembro, quinta-feira: Brasília
6 de setembro, sexta-feira: Salvador

Sendo que no dia 3 de setembro o evento será transmitido para todo o Brasil a partir do link:

LINK : https://globalcode.webex.com/globalcode/onstage/g.php?t=p&d=662489296

PASS : cassandra

O evento começará a partir das 18:30 e contará com duas palestras e uma mesa redonda.

Palestra: Visão do NOSQL introdução do Cassandra

Tópicos:

O que é NOSQL?
Tipos de bancos NOSQL?
O que é Cassandra? Quem usa, quando usar e como?
Comunidade
Como fazer parte da comunidade

Palestra: Cassandra

Tópicos: Integração entre as linguagens de programação como python, Java, etc.

O que é CQL novidades na versão 3.0
Ferramentas para administrar Cassandra
DataStax Enterprise
Demonstrações

No Fishbowl será um local aberto para trocar experiências, esclarecer dúvidas, dicas de como começar. O grande legal dessa palestra é que quem define o andamento será o público.

Entrada: Gratuíta

Inscrições: http://goo.gl/hzijyz

Endereços:

Cidade: Campinas

Data: 2 de setembro, segunda-feira

Horário: 18:30

Local: Global Code

Endereço: Av. Bernardino de Campos, 327, São Paulo, 04004-050

Cidade: São Paulo

Data: 3 de setembro, terça-feira

Horário: 18:30

Local: Global Code

Endereço: R. José Paulino, 2236, Campinas, 13023-102

Cidade: Online

Data: 3 de setembro, terça-feira

Horário: 18:30

Local: Online

Endereço: https://globalcode.webex.com/globalcode/onstage/g.php?t=p&d=662489296

PASS : cassandra

Cidade: Florianópolis

Data: 4 de setembro, quarta-feira

Horário: 18:30

Local: ACATE (Associação Catarinense de Empresas de Tecnologia)

Endereço: R. Lauro Linhares, 589 - 3º andar - Trindade - Florianópolis, SC - 88036-001‎

Cidade: Brasília

Data: 5 de setembro, quinta-feira

Horário: 15:00

Local: Instituto Federal de Educação, Ciência e Tecnologia de Brasília

Endereço: SGAN 610, Módulos D, E, F e G, Brasília/DF, CEP 70860-100. Auditório 111 BC (120 pessoas) - Campus Brasília

Cidade: Brasília

Data: 5 de setembro, quinta-feira

Horário: 19:00

Local: Instituto Federal de Brasília (Asa Norte)

Endereço: Auditório do Bloco 2 (subsolo do bloco da Biblioteca). Uniceub SEPN 707/907 - Asa Norte CEP 70790-075

Cidade: Salvador

Local: Estácio/FIB

Endereço: Rua Xingu, nº 179-Jardim Atalaia/STIEPCEP: 41770-130

Mais informações sobe o casandra: http://cassandra.apache.org/

http://www.planetcassandra.org/

Palestrantes:

Ben Covertson

Director of Operations, DataStax

Coverston is Director of Operations at DataStax, a provider of software, support, services, training, resources and help for Cassandra. He has been involved in enterprise software his entire career. Working in the airline industry, he helped to build some of the highest volume online booking sites in the world, and saw first-hand the consequences of trying to solve real-world scalability problems at the limit of what traditional relational databases are capable of. @bcoverston

Otávio Santana

SouJava, JavaBahia

Desenvolvedor entusiasta do mundo Open-Source. Praticante da filosofia ágil e do desenvolvimento
poliglota na Bahia, JUG Leader do JavaBahia, membro do SouJava, um dos fomentadores do grupo
LinguÁgil. Presente nos maiores eventos Java e ágil em nível nacional, contribui para o projeto
openjdk e a plataforma JSE, criador do Apache Easy-Cassandra, presente na comunidade Java
mundial além de escrever artigos para DevMedia, revista espírito livre e java.net

Edward Ribeiro

SERPRO

Universidade de Brasília (UnB). Lecionou em faculdades particulares do DF entre 2002 e 2008 e como professor substituto na UnB nas áreas de bancos de dados, sistemas distribuídos e sistemas operacionais. Trabalhou como servidor concursado no SERPRO, Superior Tribunal Militar (STM), TSE (eleições 2008), Câmara Legislativa do DF (CL-DF). Atualmente é servidor concursado do Senado Federal onde desenvolve sistemas web em Java.

Novo Easy-Cassandra 2.0.0 Beta

2013-07-21T18:00:00.001-03:00

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

JustJava 2013

2013-06-01T12:03:00.002-03:00

Desde 2000, o JustJava é o principal evento independente sobre a tecnologia Java no Brasil. Organizado pelo grupo de usuários SouJava, com realização da Sucesu-SP, o JustJava traz os últimos acontecimentos e tendências da tecnologia Java. O evento inclui conteúdo e palestrantes nacionais e internacionais, visando oferecer para o profissional Java informações práticas e relevantes para seus projetos. Tem entre seus principais objetivos demonstrar a qualidade dos projetos brasileiros relacionados à tecnologia Java, oferecendo espaço para casos de sucesso de grandes e pequenas empresas nacionais.

Nesta edição, o o evento foi dividido em 4 salas. O auditório 1, será focado no desenvolvimento do Java para a Web e Servidor, incluindo em HTML 5, frameworks MVC integração com redes sociais, a plataforma JEE. Palestras como Aplicações desktop nativas com HTML5, CSS3 e JS com backend usando Servlets 3, Implementando aplicações sociais com OpenAM, Desenvolvimento Agil com Java usando Play, Novas Soluções Baseadas no JBoss Middleware farão parte dessa sala.

Na segunda sala terá a objetivo de falar do grande potencial que existe dentro da JVM e na plataforma JSE, se pode citar tópicos como pesquisa fonética com Java, dicas de performance no HotSpot, plugins para o compilador no Java 8, os novos recursos do Java 8(Lambda, JavaFX, dentre outros recursos), como migrar sua aplicação para o Java 8, linguagens que rodam dentro da JVM, além do funcionamento interno da máquina virtual mais utilizada no planeta.

A engenharia de software apesar de ser a mais nova é que mais vem sofrendo alterações, constantes quebras de paradigmas e novas ciências como NOSQL, BigData, Cloud, ALM, Raspberry Pi, tornam-se cada vez mais triviais ao conhecimento do desenvolvedor. Palestras como Neo4 o quê? Uma visão prática de banco de dados orientado a grafos, Ecossistema de APIs do Cloud Computing, Data Science para desenvolvedores Java, Drools Expert e ALM compõem essa terceira sala.

Na quarta e última sala haverão mini-cursos e workshop com duração média de 2 horas os temas serão OpenJFX na prática, Framework Demoiselle, Java EE 7, técnicas de otimização e performance com Java serão apresentados nessa sala.

No evento haverá palestrantes internacionais, como Stephen Chin da Oracle e Anil Kumar da Intel e palestrantes brazucas com reconhecimento internacional como o Bruno Souza, Fabiane Nardon, Loiane Groner, Michel Nascimento, dentre outros. Com um conteúdo tão legal como esse não tem como ficar de fora! Sem falar do networking tão importante na carreira de todos. Mais informações: http://soujava.org.br/justjava-2013/

Você pode ganhar uma cortesia fazendo parte da promoção dos chorões: http://goo.gl/4dEGK

Para os participantes dos encontros técnicos do SouJava, foi preparada uma promoção específica.

25% de caso você tenha ido uma vez
50% de caso você tenha ido duas vezes
75% de caso você tenha ido três vezes
100% de caso você tenha ido quatro vezes

Grade do FLISOL SSA[2013] Fechada

2013-04-06T10:22:00.002-03:00

O FLISOL Salvador será um evento recheado de palestras voltadas para as novidades do mercado. O evento terá quatro salas, três contendo palestras e uma com atividade a ser anunciada. Uma novidade que será trazida esse ano ao evento, é que dentro dele haverá um congresso de Javascript, o JS-BA, que tende a ser o primeiro do ramo aqui na Bahia. O evento acontecerá dia 27 de abril, na Faculdade AREA1.

Evento: FLISOL 2013
Data: 27 de abril, sábado
horário: 8:00-18:00
Local: Faculdade AREA1
Inscrições:http://javabahia.blogspot.com.br/p/proximos-eventos.html
Para mais informações:http://softwarelivre.org/flisol-ssa

Sala de BahiaJS

Horário	Descrição	Responsável
08:30 às 09:00	Abertura	Organização
09:00 às 10:00	Comunicação entre janelas em domínios diferentes utilizando postMessage	Caio Almeida (CaioSBA)
10:10 às 11:00	DESENVOLVIMENTO DE EXTENSÕES PARA O GOOGLE CHROME	Marlon Carvalho
11:10 às 12:00	Mapeando o mundo com o Google Maps API	Antonio Fernando Santos Ladeia
12:00 às 13:00	Almoço
13:00 às 14:00	Desenvolvendo plugins com o jQuery UI e testando com o jasmine	Alexandre Magno Teles Zimerer
14:10 às 15:00	Arquitetura de SPA (Single Page Application) utilizando ExtJs MVC e outros padrões	Victor Cardins
15:10 às 16:00	melonJS: Uma alternativa Livre para o desenvolvimento de jogos em HTML5	Luis Gustavo de Jesus Araujo
16:10 às 16:50	Criando aplicações com Angularjs	Wilson Mendes Neto
17:00 às 17:50	Addicted to coffee(script)	Aurélio A. Heckert
18:00 às 18:30	Encerramento e sorteios	Organização

Sala de Desenvolvimento

Horário	Descrição	Responsável
08:30 às 09:00	Abertura	Organização
09:00 às 10:00	nodeNES - Construindo uma IDE para Nintendo 8 bits no Navegador.	Guto Maia
10:10 às 11:00	Introdução Prototipagem com Microcontrolador Arduino	Fernando Moreira (Mestre dos Magos))
11:10 às 12:00	As principais novidades do Java EE 7	Bruno Borges
12:00 às 13:00	Almoço
13:00 às 14:00	Integrando Python e JavaScript	Luiz Claudio
14:10 às 15:00	Design on the Browser	Tassia Pellegrini
15:10 às 16:00	Responsive Design, usar um framework ou não?	Fernando
16:10 às 16:50	Iniciando sua Jornada com Mule ESB	Jean Donato / Claudio Escobar
17:00 às 17:50	Arquitetura e padrões 2.0	Otávio Santana
18:00 as 18:30	Encerramento e sorteios

Sala de Infra Estrutura

Horário	Descrição	Responsável
08:30 às 09:00	Abertura	Organização
09:00 às 10:00	Criando um appliance Open Source para mitigar vulnerabilidades de serviços e aplicações	Alexandro 'Alexos' Silva
10:10 às 11:00	Software livre como diferencial no mercado de trabalho	Cristiano Furtado
11:10 às 12:00	Criptografia assimétrica com GnuPG	Antonio Terceiro
12:00 às 13:00	Almoço
13:00 às 14:00	Mainframes	Fabio Fonseca Barbosa Gomes
14:10 às 15:00	Balanceando alto tráfego de Proxy Squid	Rafael Gomes
15:10 às 16:00
16:10 às 16:50	Criatividade e Software Livre: como uni-los em um novo modelo de desenvolvimento	Alexandre Teles
17:00 às 17:50	Novas Idéias, Negócios e Perspectiva no Trabalhar com Java	Felipe Mateus
18:00 as 18:30	Encerramento e sorteios	Organização

Grade Sujeita a alteração

Mais detalhes das Palestras e palestrantes:

Sala BahiaJS: http://goo.gl/Whl3Q
Sala de Infraestrutura: http://goo.gl/B3SX1
Sala de Desenvolvimento: http://goo.gl/5PyK0

Inscrições para FLISOL SSA 2013 Abertas

2013-03-14T22:09:00.000-03:00

As inscrições para o FLISOL 2013 estão abertas, esse evento mais uma vez conta com a ajuda da comunidade brasileira, com profissionais com reconhecidos em todo mundo.
Umas das novidades desse evento é o primeiro encontro de javaScript da Bahia.

Guarde em sua agenda:

Evento: FLISOL 2013
Data: 27 de abril, sábado
horário: 8:00-18:00
Local: Faculdade AREA1
Inscrições: http://javabahia.blogspot.com.br/p/proximos-eventos.html
Grade: http://softwarelivre.org/flisol-ssa/programacao-2013
Palestras Desenvovlimento: http://softwarelivre.org/flisol-ssa/palestra-desenvolvimento
Palestras BahiaJS: http://softwarelivre.org/flisol-ssa/palestra-bahiajs
Palestra infraestrutura; http://softwarelivre.org/flisol-ssa/palestra-infraestrutura

Novidade: FLISOL com o BahiaJS

2013-02-14T12:59:00.000-03:00

O Festival Latino Americano de Instalação de Software Livre, FLISOL, sempre foi palco de novidades, com palestras de infraestrutura, empreendedorismo, desenvolvimento, dentre outros quando o assunto é software livre. O objetivo do evento é sempre mostrar que a tecnologia de código aberto vem evoluindo através do tempo e muito tende a crescer. Esse ano a sala de desenvolvimento traz uma grande novidade:

Em conjunto com o FLISOL, acontece o primeiro encontro de JavaScript na Bahia, o BahiaJS. A linguagem JavaScript, que vem era tratada como mero coadjuvante para aplicação web, tem se tornado uma peça preponderante não somente para a usabilidade da aplicação e estética, mas também para performance e economia de recursos do servidor. Assim como o FLISOL, esse é um evento que depende e muito da participação de todos! Ajude-nos a divulgar o evento, submeta palestras e principalmente: venha prestigiar o evento!

Contamos com sua participação no BahiaJS junto com o FLISOL que acontecerá no dia 27 de abril, sábado, na faculdade AREA1.

Você tem interesse em palestrar no BahiaJS? Então submeta sua palestra em: http://goo.gl/od1TY

Você ou sua empresa tem interesse em em patrocinar o evento: Proposta do evento

Introdução ao BigData

2013-01-18T23:53:00.000-03:00

Demorou, mas finalmente conseguir um tempo para falar um pouco da minha apresentação no JavaOne 2012 que foi BigData. Com a evolução das aplicações e a necessidade do ser humano pela informações, mais e mais aplicações vem surgindo, deixando o homem cada vez mais refém da informação. Para isso basta lembra-nos da evolução do homem em que num passado existia muitas pessoas para uma máquina ( como o mainframe), em seguida uma pessoa por máquina ( o caso do computador pessoal) e nos tempos atuais em que para cada pessoa possue várias máquinas ( notebook, ultrabook, PC, tablet, smartphone, no futuro óculos, geladores, etc.). Com tantos aplicativos surgindo as informações são geradas exponencialmente, com isso a capacidade de gerenciar tantas informações se torna primordial para as aplicações atuais. Esse mesmo crescimento de dados acontece nos aplicativos empresariais com crescimento anual de 60%, se estima que uma empresa com mil funcionários gera anualmente 1000 terabytes sem falar que essa quantidade tende a aumentar cinquenta vezes até 2020.

Com o recém surgimento do bigdata, a primeira dificuldade é encontrar o seu conceito, é possível vê-los de maneiras totalmente divergentes em cada blog que se lê, ou seja, se você ler 10 materiais sobre bigdata, provavelmente cada um trará conceitos diferentes. Dentre as matérias ao se tirar um mínimo comum se verá que o bigdata na sua raiz se fala em tratar um grande volume de dados com grande velocidade. No entanto se repara que essa definição é bastante abstrata pelo simples fato de que para uma pessoa A, por exemplo, um grande volume seja um gigabyte e para uma pessoa B um grande volume seja um terabyte e o mesmo pode acontecer ao se referenciar a velocidade e o tempo de resposta de uma requisição.

Assim o grande desafio do bigData é estar administrando um grande volume de dados e minerando informações em um menor tempo de requisição. Com o grande volume de dados fazer com que a aplicação cresça a medida que é necessário é uma ótima estratégia assim uma escalabilidade vertical ( em que se aumenta o poder do hardware como aumento de memória e de processamento de uma única máquina) ou horizontal ( em que se aumenta a quantidade de máquina) deve ser analisada. Apesar de ser mais complexa a escalabilidade horizontal acaba sendo muito barata sem falar de ser mais fácil de crescer ou diminuir os recursos por demanda.

Para armazenar as informações com a escalabilidade horizontal os bancos NOSQL são uma ótima estratégia, vale lembrar que o banco NOSQL significa não apenas, not only, e não sql, no sql. Uma diferença entre os bancos NOSQL e o SQL é que o primeiro possui uma grande variedade de bancos e cada um com características diferentes. Em termo de arquitetura os bancos NOSQL podem ser distribuídos ou não, embora sejam mais populares do tipo distribuído. Sua forma de armazenamento pode ser apenas memória ou apenas disco rígido ou configurável( vale apena lembrar que banco apenas na memória são muito rápidos, no entanto são volúveis, já os somente no HD tem informações permanentes, porém o I/O é muito alto). Outra características divergentes entre os bancos NOSQL está na forma do armazenamento que são: chave-valor, documento, família de coluna e grafos. Os bancos NOSQL costumam ser muito rápido na leitura e na escrita, no entanto, possui uma grande deficiência por parte das buscas, normalmente são dadas apenas pela chave, para isso usar um serviço para terceirizar o serviço pode ser uma boa ideia, como o framework Lucene.

Mesmo realizando estratégias de buscas terceirizadas ou buscando pelo id, se a informação não estiver na memória principal pode haver uma demora para recuperar essa informação, assim, ter um dispositivos de acesso rápido pode ser uma melhor opção, com isso o uso do cache. Ao se optar pelo cache deve-se levar em conta os dois maiores desafios:

Ter informação: O ato de esquentar a informação é extremamente importante para esse mecanismos, já que não adianta existir um cache se o mesmo não tenha nenhuma informação. Para isso ele pode ser esquentado de várias formas (ao iniciar uma aplicação, por demanda, por sessão do usuário) que desse ser definido com o aplicativo em questão não existindo uma bala de prata.
Matar o cache: Para o cache é necessário que exista apenas informações atuais, assim é importante que os dados atuais sejam mortos e trocado por informações mais atuais.

Um outro aspecto no bigdata, que não é muito tratado, está relacionado na velocidade da modelagem além da velocidade no desenvolvimento de software. Um exemplo muito interessante é o twitter que viu muito usuários usando a hashtag ( o '#' adicionado com uma palavra) e em pouco tempo teve que realizar pesquisas através dos mesmos.

Assim podemos verificar que o bigdata não apenas está relacionado apenas na velocidade de requisição, mas também em desenvolvimento, assim conhecer bem o negócio além de várias ferramentas poderá ser extremamente importante. Na linguagem Java conhecer o Java EE 6, muito em breve o java 7, além do JDK 7 trará velocidade de desenvolvimento, produtividade e um melhor gerenciamento de memória.

Assim pode-se concluir que o conceito do BigData é relativamente muito fácil, mesmo sendo divergente em várias fontes, que é gerenciar um grande volume de memória em alta velocidade. O mais difícil certamente é chegar nesse objetivo já que para isso é necessário conhecer uma gama de ferramentas, frameworks, metologias, tipos de bancos como NOSQL, SQL e NewSQL, cache, serviço de indexação de buscas, tipos de escalabilidades, etc. Apesar de ainda ser muito discutida nas universidades a normalização foi desenvolvida em 1970 ( vale lembrar que os servidores da época possuíam 16kb de memória principal e 800kb de armazenamento e os celulares são muitas vezes mais rápido que estes servidores) ou seja não é certo afirmar que os aplicativos, os hardwares, as necessidades de hoje são os mesmos daquela época, assim é entender que esse padrão nem sempre é válido.

Bigdata from Otávio Gonçalves de Santana

Código: https://github.com/otaviojava/introBigData

Conhecendo o tio da senha

2012-11-16T20:50:00.000-03:00

A divisão do software em camadas, atualmente, é certamente uma das formas mais eficiente de estar se organizando a sua aplicação. Facilitando a manutenção, reaproveitamento de código, etc. Vale salientar que camada no inglês tem duas palavras: Tier, a camada física e Layer, camada lógica. No entanto, criar um grande número de camadas além de desnecessário acaba deteriorando a desempenho do seu software. Assim surgiram as chamadas delay layer, camadas lógicas que apenas servem para passar à informação a diante, gerando atraso na reposta e consumo desnecessário na memória. Esses atrasos em alguns casos acontecem fora da parte lógica da aplicação. Acontecem no processo de desenvolvimento (fora do código), pessoas ou profissionais que acabam gerando um atraso na resposta, delay tier, conhecido carinhosamente como os tios da senha.

Exemplificando como eles funcionam, falarei do funcionário que aperta o botão no elevador, não estou desmerecendo nenhuma profissão. O elevador possui uma interface super simples e basta se pressionar o botão com o andar desejado. Você precisa informar o andar desejado e ele por sua vez apertará o botão. Essa chamada gerará um atraso natural até você informar o andar desejado e ação desse profissional, quando entrar 10 pessoas simultaneamente essa demora será “gritante”.

As empresas não o contratam diretamente, os preferem chamar de Arquitetos, gestores de aplicação ou DBAs, são profissionais que centralizam alguns até mesmo todos os processos de software de uma empresa. Essa ação gera uma pseudo controle para a empresa, porém, acaba gerando atraso tanto nas escolhas de tecnologias quanto na execução de um script, alteração no banco de dados etc. e esses atrasos impactam diretamente a entrega desse projeto.

O fato é que as tecnologias, requisitos, metodologias, etc. surgem muito rápidos, assim nascem várias siglas (UX, DDD, TDD, BDD NOSQL, NewSQL, bid data, integração contínua, etc.) e deixar essa responsabilidade na mão de apenas uma pessoa ou uma pequena equipe se torna um erro. Por alguns motivos:

Caso os detentores das senhas, se desmotivarem e parem de se atualizar profissionalmente. O parque tecnológico da empresa em pouco tempo vivará artefato de museu.

Centralizar decisões tecnologias para todos os projetos é um grande erro! Ninguém melhor que um membro da equipe para decidir qual ferramenta é a mais interessante para um requisito específico. Sem falar que pode gerar uma padronização equivocada, ou seja para todos os problemas a mesma solução. Dizer que para todos os problemas precisamos de um martelo é dizer que os parafusos também são pregos.

O aumento demasiado do ego, isso mesmo, um técnico com um ego muito grande faz com que toda a empresa use tecnologias do seu “mundinho” para que assim seja o maioral.

Atraso na resposta, fazer com que muitos processos passem na mão de uma pessoa, quando existir muitas requisições de várias pessoas em algum momento gerará um atraso, é o caso do elevador quando entram dez pessoas ao mesmo tempo.

Mal aproveitamento de um profissional, se queremos executar um simples script ou renomear um campo de uma tabela para que precisamos de um DBA para uma atividade tão trivial ? Seria mais interessante que ele estivesse ajudando em atividades como: trabalhar para dar maior desempenho e diminuir o tempo de resposta no banco, definir índices, ajudar na escalabilidade do banco, uma mudança de estratégia para um banco NOSQL ou NewSQL, bigdata, ajudar na criação de querys com mais desempenho ou talvez criação de views, etc.

Abandono na qualidade do projeto, o software que usa ferramentas muito antigas será a janela quebrada do seu projeto.

Desmotivar a refatoração do projeto, o fato mais comum para os requisitos é que eles mudam com uma grande facilidade, desse modo, a refatoração é importante tanto para um código e banco mais limpo tanto para um bom desempenho para a aplicação. Quando para realizar tal atividade precisa passar por um processo demorado, essa atividade acaba sendo muito custosa para o projeto e em alguns casos sendo descartável.

Ou o que eles precisam fazer ?

Acredito que o primeiro passo é entender que engenharia de software não é comparável com outras áreas, assim, possuem características e metodologias próprias. Em seguida a área evolui muito rápida e precisamos evoluir junto com ela simplesmente “parar no tempo”.

Em relação das ações, o que eles precisam fazer é o processo totalmente inverso, ou seja, o de não centralizar informação e ser o facilitar o acesso ao conhecimento. Descentralizar é fazer com as informações circulem de maneira mais “livre” e que as soluções partem de qualquer parte da empresa. Estimular atividades como codingdojos, participação de eventos, wiki na empresa, etc. Uma equipe autogerenciável deve ser o sonho de qualquer gestor de TI que esteja em 2012.

Remover os atrasos do processo software é crucial para manter um ciclo saudável no desenvolvimento. Conhecer a filosofia “toyotismo”, que se tornaram base para as metodologias ágeis, e dizer adeus ao “Taylorismo”, filosofia de Taylor que visa centralizar as decisões, é um pequeno passo para isso. Desconcentrar processos e decisões de software é muito mais do que apenas remover uma camada física desnecessária, delay tier, também é criar uma equipe auto-gerenciável, impedir que a empresa vire um museu, permitir que exista opções para solucionar um problema e que a mais adequada seja utilizada, deixar fluir a informação e fazer com que o profissionais se atualizem e utilizem tal conhecimento. Sobre tudo demonstrar que gosta do que faz e passar esse prazer para os outros membros da equipe, estimular para que eles também façam o mesmo.

Ultimo Encotro javaBahia 2012

2012-10-31T20:33:00.001-03:00

Local: Estácio FIB

Data: 10 de novembro

Horário: 8:30

Inscrições: http://goo.gl/feCAz

valor: Gratuíto

8:30 palestra GDG
DescriçãoOs GDGs (Google Developer Groups) são peças muito importantes na estratégia do Google de divulgar e popularizar as tecnologias e produtos da empresa. Além disso, nada melhor que promover a troca de conhecimento e experiências entre a própria comunidade, e o Google quer ajudar os grupos a fazerem isso. Nessa palestra, vamos falar um pouco sobre a estratégia, os benefícios e como o Google pretende ajudar os GDGs no Brasil, e claro, a importância de novos grupos como o GDG SSA.
9:00Palestra: Google Maps API
Descrição: Google Maps API é um serviço gratuito que possui várias APIs que permitem incorporar as funcionalidades do Google Maps em seus aplicativos. Nessa palestra, iremos ver na prática como usar alguns desses recursos.

9:30 Palestra: Android 4 UX e Design – O que muda?
Descrição: Plataforma. Algumas regras mudaram. Novos padrões surgiram. Se você estava acostumado à forma de construir aplicativos para Android com as versões pré-ICS, venha conhecer essas mudanças e como elas vão afetar, para melhor, sua forma de criar aplicativos.

10:00 Palestra Utilizando as APIs de dados do Google.
DescriçãoAngularJS é uma biblioteca JavaScript para desenvolvimento de
aplicações Web que implementa o modelo MVC do lado do navegador e
recupera dados do servidor em formato JSON. Sua principal
característica é desacoplar a manipulação do DOM da lógica da
aplicação, o que facilita muito o uso de testes.
11:00 PalestraPrimeiros passos com GAE em Java
Descrição: Conheça um pouco das vantagens que o GAE pode te proporcionar.

Novo Easy-Cassadran 1.1.0: Unindo com o Google Guice

2012-09-23T15:58:00.000-03:00

Lançada a mais nova versão do Easy-Cassandra, essa nova versão trouxe novidade no gerenciamento de muitos nós. O uso de muito 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:

Seqüencial: 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, feito 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 0.

Randômico: De forma semelhante ao seqüencial, é dado um número para cada cliente onde começa 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 é bastante simples: O primeiro passo é criar instâncias do Cassandra Adicionar esses nós no Easy-Cassandra Criar uma das duas Estratégias informando o nome do keyspace, caso não existe 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 na visão e o Google Guice como injeção de dependência. Como o objetivo é estar apenas armazenando o usuário e sua pergunta, modelando o objeto a ser salvo ficará do seguinte modo:

  
@Entity
public class Post implements Serializable;
   @Id
    private String nickName;
    
    @Column
    private String text;

Estaremos usando os qualificadores do Google Guice, a idéia é que a partir da anotação seja definido o tipo de persistência seqüencial e randômico. Conforme mostra a tabela 2.

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

  

 @Inject @Sequencial
    private ServiceClient sequencialClient;
    
    @Inject @Random
    private ServiceClient randomClient;

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

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

O código desenvolvido permite duas opções de inserir sua resposta: uma seqüencial e uma randômica e tão logo é inserido a informação é recuperada e lançada em forma de lista das duas formas.

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

Exemplo: http://softwarelivre.org/otagonsan/codigofonte/guicecassandra.zip
Easy-Cassandra: https://github.com/otaviojava/Easy-Cassandra
Google Guice: http://code.google.com/p/google-guice/

Palestras Desenvolimento no SFD 2012

2012-09-16T13:32:00.001-03:00

O Software Freedom Day (SFD) é uma celebração mundial do Software Livre e do Código Aberto (Free and Open Source Software – FOSS). Para esse evento na grade de desenvolvimento teve uma sala voltada para os desenvolvedores de software, entusiastas ou profissionais, o objetivo foi demonstrar ferramentas livres, além das mais recentes tecnologias lançadas no mercado. Temas como Cloud Computing, Html 5, GitHub e dispositivos móveis fizeram parte dos temas abordados nessa sala.

Confiram as apresentações que fizeram parte dessas seletas palestra para o evento.

Encontro Técnico SouJava

2012-09-16T07:38:00.002-03:00

No dia 20 de setembro o SouJava estará promovendo um encontro técnico com o objetivo de estar disseminando a cultura de desenvolvimento na plataforma Java. Nesse encontrado será abordado o tema de cloud computing e Big Data, além da conversa no final em que todos poderão estar tirando dúvidas e compartilhando experiências.

Data: 20 de setembro, quinta-feira.

Horário: 19:30

Local: Global Code

Título: BlahBlah Cloud: Introdução a Cloud Computing para empresas e startups startups

Descrição: Cloud Computing não é só uma plataforma para grandes corporações é principalmente um ambiente perfeito para pequenas empresas e profissionais que sabem utilizar o que de melhor proporcionam em seu favor.

Palestrante: Bruno Souza

Bruno Souza é Presidente do SouJava. Conhecido como o "JavaMan", é evengelista Java e open source, e trabalhou na criação e fortalecimento de comunidades em toda sua carreira.

Foi diretor mundial de Comunidades Open Source, coordenou importantes comunidades como NetBeans e OpenSolaris e ajudou a criar a Comunidade Mundial de Grupos de Usuários Java.

Desenvolvedor Java desde os primórdios da tecnologia, participou de alguns dos maiores projetos Java do país, e realizou centenas de apresentações em todo o mundo.

Bruno é também Diretor da Open Source Initiative (OSI), onde discute a evolução do movimento open source.

Quando não está em um computador, Bruno curte o seu tempo com a família em um pequeno esconderijo próximo a São Paulo. Amador em varias atividades -- fotografia, fantoches, pai -- ele tenta ter sucesso em algumas delas.

Título: Introdução de BIG data com Java

Descrição: A necessidade de ligar com um grande volume de dados, responder com velocidade e se manter altamente disponível. É atualmente é o maior desafio do desenvolvedor Java para as novas aplicações. Conheça o caminho das pedras para sua aplicação não morrer na praia.

Palestrante: Otávio Santana

Otávio Santana, o otaviojava, é desenvolvedor entusiasta do mundo Open-Source. Praticante da filosofia ágil e do desenvolvimento poliglota na Bahia, JUG Leader do JavaBahia, um dos fomentadores do grupo LinguÁgil. Presente nos maiores eventos Java e ágil em nível nacional, presente na comunidade java mundial além de escrever artigos para DevMedia, revista espírito livre e java.net

Título: FishBowl

Descrição: O momento onde qualquer um pode ser o palestrante compartilhando suas idéias, experiências, tirando dúvidas com interação total do público.

Palestrante: Todos!

inscrições: http://goo.gl/Dzmwk

Código Elegante no Linguágil 2012

2012-08-24T07:47:00.000-03:00

O Linguagil está chegando!

Talvez um dos cursos que mais vão interessar para nós da comunidade Java. Seja o Clean Como programadores, a primeira prioridade é criar código que funciona. Mas Infelizmente, código que simplesmente “funciona” não é suficiente. Ele precisa ser legível para outros programadores e até para vocês mesmo no futuro, desse modo é necessário fazer um código limpo.

Apesar de o conceito variar de acordo com o pensamento do programador, podemos resumir um código limpo em:

· Simplicidade

· Ausência de duplicação

· Facilidade de leitura

· Elegância

Código com estas qualidades é fácil de manter, quebra o ciclo de decaimento / reescrita e nos dá valor verdadeiro e duradouro.

O objetivo do curso é estar esclarecendo um pouco sobre esse tema, com o Rogério Fontes.

Abaixo veja mais detalhes do curso:

Descrição do curso: Código Java Elegante (Rogério Fontes) As vezes deixamos os curtos espaços de tempo nos levar a criar códigos para ser entregues, baseado em pressão, estresses e demais situações. O que pode deixar o nosso código bastante ruim, e até mesmo pode fazer perdemos o nosso projeto, com infindáveis acertos no códigos e difíceis leituras para os mantenedores desses projetos. Com algumas técnicas simples podemos deixar nosso código limpo e pensar em que fazer para que os outros programadores possam entender nosso código e saber o que queríamos "expressar" nele. Temos que pensar como "nós autores de códigos escrevemos e o que as pessoas ao lerem nossos programas entendam e o façam como se estivessem lendo um livro" (Uncle Blob - Clean Code: A Handbook of Agile Software Craftsmanship).

Vamos falar e dar exemplos: Como deixar seu código mais limpo e significativo. Como criar melhores funções. Se seu código é significativo e auto explicativo, porque comentários que não significam muito? Melhorando os tratamentos de erros no seu código. Usando TDD (Test Driven Development) e testes limpos para melhoria e refatoração do seu código limpo. Evolução do seu código para lermos como um livro (código limpo).

Mais informações em: WWW.linguagil.com.br

Cassandra + Lucene

2012-08-11T12:10:00.000-03:00

Atualmente existem diversas características dos bancos NOSQL, em diferentes arquiteturas, formas de armazenamento de informação e estruturas de dados. No entanto apesar dessa grande variedade no número e variedades eles compartilham uma coisa em comum. Eles normalmente buscam pela chave primária. Apesar de conseguir-se manter altamente disponível, inserir e recuperar informações de forma bastante rápida, o fato de que a maioria dos bancos NOSQL somente recuperem pela chave, torna um pouco difícil adaptar a aplicação para o seu uso, já que nem sempre você consegue buscar apenas pela chave no banco. Para não abrir mão da alta disponibilidade e recuperar informações não apenas em chave, uma boa opção certamente é “terceirizar” esse serviço. Por esse motivo será apresentado o Lucene trabalhando em conjunto com um banco nosql, mais precisamente o Cassandra, juntando o bom de dois mundos em sua aplicação.

O Apache Lucene é uma API de busca e indexação de documentos, escrito em Java. Ele é composto por basicamente duas etapas: indexação e pesquisa. Dado o texto primeiro passo é a indexação que processa os dados originais e gera uma estrutura que facilita a busca e gera palavras-chaves, em seguida vem à busca que visa estar buscando a partir das palavras-chaves indexadas e retorna pela semelhança do texto com a consulta. A vantagem é que o Lucene abstrai ao ponto que não é necessário que o desenvolvedor saiba algoritmo de indexação. Os índices podem ser criados em ambientes distribuídos, aumentando o desempenho e a escalabilidade da ferramenta.

Apresentado um pouco da ferramenta o objetivo agora será apresentar uma prática envolvendo os dois mundos: banco nosql e o Lucene. Para essa parte prática será feita uma aplicação com o objetivo de estar cadastrando currículos. A idéia é bastante simples:

O usuário estará cadastrando o currículo com suas informações.
A partir dessas informações a analista de recursos humanos estará buscando o profissional.
O profissional poderá ser buscado pela palavra chave de uma qualificação técnica, localização, Profissão.

Como o objetivo da aplicação será web, estaremos utilizando a plataforma Java EE em sua versão mais recente, a versão 6.0.

No Lucene os índices são armazenados a partir da interface Direcoty que no momento que eu escrevo possui basicamente duas implementações: Uma para armazenar na memória RAM e para armazenar no disco rígido. Como o objetivo é garantir uma alta disponibilidade estaremos utilizando a opção de estar trabalhando com os índices na memória RAM, mas para não perdemos tais índices estaremos fazendo um backup no disco rígido. Para fazer tal procedimento, usaremos o recurso schedule do EJB 3.1 para de tempos em temos, jogar o que está na memória para o HD.

@Schedule(minute = "*/1", hour = "*")
  public void reindex() {
   
    try {   
      Directory disco = FSDirectory.open(new File(Constantes.getIndexDirectory()));
      luceneManager.backup(directory, disco);
      
    }
    catch (Exception e) {
     Logger.getLogger(ScheduleService.class.getName()).log(Level.SEVERE,
                null, e);
    }

  }

Desse modo quando a aplicação cair e levantar novamente basta estar carregando as informações do disco para a memória principal novamente. Vale salientar que o diretório precisar único para toda a aplicação.

 
@ApplicationScoped
public class LuceneManager implements Serializable{

 private static final long serialVersionUID = -8280220793266559394L;
 
  @Produces
        private Directory directory;
    

    @Inject
    public void init() {
        directory = new RAMDirectory();
        try {
            levantarServico();
        } catch (IOException e) {
         Logger.getLogger(LuceneManager.class.getName()).log(Level.SEVERE,
                    null, e);
        }
    }

    public void levantarServico() throws IOException {
        Directory disco = FSDirectory.open(new File(Constantes.getIndexDirectory()));
        backup(disco, directory);
    }

    public void backup(Directory deDiretorio, Directory paraDiretoria) throws IOException {

        for (String file : deDiretorio.listAll()) {
            deDiretorio.copy(paraDiretoria, file, file); // newFile can be either file, or a new name
        }
    }

}

Uma vez criado o diretório e definido onde estarão as informações o próximo passo é criar os índices, conforme falado anteriormente ele será a chave tanto para a inserção quando a busca das informações. Agora o que falta é a criação do Document que representa para a troca de informações entre o Lucene e sua aplicação. Ele é composto por campos que por sua vez por informações. A relação entre o Lucene e a aplicação se dará da seguinte forma:

A chave será armazenada e não indexada.
O estado não armazenado e não indexado.
O conteúdo do currículo será não armazenado e indexado.

  
  
  private Document criarDocumento(Pessoa pessoa) throws IOException {
    Document document = new Document();

    document.add(new Field(Constantes.ESTADO_INDICE,pessoa.getEndereco().getEstado(), Store.YES,
        Index.NOT_ANALYZED_NO_NORMS));
    document.add(new Field(Constantes.ID_INDICE,pessoa.getNickName(), Store.YES,
            Index.NOT_ANALYZED_NO_NORMS,TermVector.WITH_POSITIONS_OFFSETS));

    document.add(new Field(Constantes.TUDO, getConteudoCurriculo(pessoa), Store.NO,
        Index.ANALYZED));

    return document;
  }

Uma vez essa informação armazenada no Cassandra e indexada no Lucene, o ciclo da aplicação se dará da seguinte forma:

A seqüência segue um processo simples:
O usuário adiciona as informações e envia ao servidor
A informação é persistida no Cassandra
A informação é indexada e é armazenado o id no Lucene
Quando o analista de RH fizer a busca é recuperado um Document que por sua vez retorna a informação da chave, assim poderá se recuperada todas as informações no Cassandra.

Pronto! Dessa forma quanto a inserção quanto a busca serão feitas de maneiras rápidas, o Cassandra possui o recurso de índices secundários que permite que existam campos de busca além da chave, mas isso faz com que o banco perca velocidade com o crescimento desses campos especiais. Uma outra forma de deixar a busca ainda mais rápida seria deixar os resultados dessa busca em um cachê, mas isso serão cenas para um próximo capítulo.

Falando um pouco mais sobre o Lucene existem alguns frameworks que já se integram com o Lucene. É o caso do hibernate search que é o hiberante, para banco relacional, utilizando o Lucene, solr é um servidor de busca que usa o Lucene como motor de busca e o solandra que é um solr para o Cassandra.

Nesse artigo foi apresentado um problema existente na maioria dos bancos NOSQL, a busca de campos além da chave. Para resolver tal problema foi demonstrado um trabalho em conjunto com o Lucene, ferramenta de indexação de documentos, além de apresentar alguns conceitos da ferramenta.

Referências:

Referências: Pamplona, Vitor. http://vitorpamplona.com/wiki/Introdu%C3%A7%C3%A3o%20ao%20Apache%20Lucene

Solr: http://lucene.apache.org/solr/

Hibernate Search: http://www.hibernate.org/subprojects/search.html

Conhecendo o Lucene, PAULO SIGRIST e WILSON AKIO HIGASHINO, java Magazine 104, devmedia.

Código Fonte: http://softwarelivre.org/otagonsan/codigofonte/cassandra-lucene.rar

Introdução para JSF 2.0

2012-07-09T09:36:00.000-03:00

Com o decorrer dos tempos vieram muitos conceitos, novas técnicas, tecnologias, metodologias, etc. Mas apesar de tantas mudanças uma coisa não mudou, a importação da interação do sistema com o seu usuário. Não tem jeito, o usuário final mesmo sendo visto como o inimigo número um do programador. é o púbico alvo do sistema. Fazer um sistema amigável, user friendly, é um grande diferencial para um sistema, ou seja, é o que faz ganhar um cliente, ganhar um usuário, ganha pão, etc. Afinal é pela tela que o usuário se interage com o sistema é na janela que o usuário vai “gostar” de usar-lo ou não. É muito semelhante, por exemplo, aos carros da figura 1. Qual você usuária ? Provavelmente será o mais bonito, mesmo se eu disser que o carro feio possui o motor mais rápido do mundo. E isso acontece de forma similar a tela do seu sistema, o cliente não quer saber quão rápido é o seu sistema ou qual tecnologia você está utilizando, mas se é belo ou não. No entanto não adianta fazer um sistema muito bonito se ele não funciona corretamente, dai a necessidade de dividir e conquistar o seu sistema, ou seja, separar a parte lógica da parte visual do seu sistema e é para isso que suja o padrão MVC que basicamente tem o objetivo de dividir a parte lógica do visual.

Figura 1: Você escolheria o carro da direita porque é mais rápido ?

E com esse objetivo eis que surge o Java Server Faces, o jsf, o seu objetivo é estar desenvolvendo aplicações web, vale citar que ele é um framework MVC, ou seja, é uma ferramenta que divide a parte lógica do visual do seu sistema. Para a parte visual ele consegue integrar com diversas tecnologias existentes no mercado é o caso do css, ajax, html 5, jquery etc.

Para parte lógica realizar uma chamada em java acontece de maneira bem simples, observando a figura 2 se verifica que nada mais é do que chamadas para atributos e métodos de um objeto java. Se observa que a classe possui duas anotações:

@ManageBean: Essa anotação indica que essa classe é um bean gerenciado

@ApplicationScopped: Essa anotação indica o escopo do seu objeto em jsf.

Figura 2: Codigo java e JSF

Falando em escopo, o escopo nada mais é do que o tempo de vida e morte do seu objeto, ou seja quando ele será criado e destruído pelo jsf, dentre esses escopo podemos destacar:

Escopo de Aplicação: Seu tempo de vida é igual a da aplicação, em outras palavras, inicia quando a aplicação inicia e morre junto com a aplicação.
Escopo de Sessão: Inicia e morre junto com a sessão criada pelo usuário
Escopo de visão: Seu tempo de vida é igual de uma página
Escopo de Request: Criado quando é feita uma requisição e morre após ter respondida.

Como nas suas páginas não vão objetos java diretamente, indo apenas texto, é importante que você informe qual texto vai para a tela (html, xhtml, jsp, etc.) e como recuperá-lo como objeto java. Uma prática muito comum é somente enviar o id e quando reconstruir o objeto a partir do banco de dados.

Em uma interação com o usuário é importante que você impeça que o usuário realize atividades perigosas em seu sistema. É o caso de um usuário colocar letras no campo idade ou mesmo que ele coloque apenas número coloque 1500 anos já que ele não terá essa idade. No JSF você consegue fazer isso de algumas formas duas delas é a partir do bean validator ou criar uma classe que implemente validador.

Uma informação útil na parte de visão é que o jsf te ajuda a economizar tempo, manutenção rápida além de prevenir futuras dores de cabeça. É o caso do faclets e do composite components.

Nessa apresentação foi falado que tanto a interface quanto o seu funcionamento é importante para o software e nós como desenvolvedores precisamos estar atentos para isso. Com isso foi apresentando o Java Server Faces que é um framework java com MVC, te ajudando a separar a interface com da regra de negócios.

Implementando aplicativos Web com JSF

View more presentations from Otávio Gonçalves de Santana

Link:

Apresentação: http://www.slideshare.net/otagonsan/implementando-aplicativos-web-com-jsf

Código exemplo do JSF: https://github.com/otaviojava/jsftdc2012/