AndOrm – Explicando parte 1

Como no primeiro post expliquei apenas as funcionalidades básicas do AndOrm, este post serve para começar uma série de posts sobre algumas de suas funcionalidades.

Hoje vamos falar sobre as configuraçõese individuais para cada entidade.

No post anterior, adicionamos nossas entidades ao AndOrm da seguinte forma:


AndOrmConfiguration conf = new AndOrmConfiguration("path_do_banco");

conf.addEntity(Cliente.class);

Dessa maneira, funciona tranquilamente, mas seguindo as convenções do AndOrm. Mas o método ‘addEntity’ aceita um objeto EntityConfiguration como parâmetro, então vamos à esse objeto.

O construtor pode receber os seguintes parâmetros:

– entityClass = informa a classe da sua entidade, nada a mais do que fizemos até agora;

– nameTypes = informa o modo como o framework deve considerar o nome da tabela e dos campos, baseado na classe e nos atributos.

Temos aqui duas opções, NameTypes.Underscored (convenção do AndOrm, explicado no primeiro post), e NameTypes.Original (mantém o nome da tabela exatamente igual ao nome da classe, e o nome dos campos exatamente igual ao nome dos atributos). Lembrando que, quando a anotação @Table ou a anotação @Column estiver presente na classe/atributo, o nome ali informado que será considerado pelo framework. PS: Não achei um nome adequado para este NameTypes, por isso, fiquem a vontade para opinar;

– verifyOperationMethods = O AndOrm possui as anotações @BeforePersist, @BeforeUpdate, @BeforeDelete, @AfterPersist, @AfterUpdate e @BeforeDelete, que servem, como o próprio nome sugere, chamar o método anotado antes ou depois da operação informada no próprio nome da anotação. Hoje o framework percorre todos os métodos da entidade para buscar por essas anotações, e se você não tiver essas anotações e não pode perder esse tempo de verificação quando a instância de PersistenceManager é criada, passe ‘false’ para esse parâmetro (verifyOperationMethods). Assim, o AndOrm não buscará por essas anotações;

– provider = Por padrão, o AndOrm usa a instância de DefaultProvider, que apenas instancia o objeto da entidade invocando um construtor sem parâmetros, mas caso você precise que o objeto seja criado de outra forma, simplesmente crie uma classe customizada que implemente a interface br.com.andorm.provider.Provider, e você deverá retornar uma instância da classe passada como parâmetro no método ‘newInstanceOf’. Pensei nessa solução, por que tenho casos aqui que uso IOC com o Guice para Android, e mantenho alguns repositórios injetados nessas entidades, assim posso realizar algumas operações básicas com a entidade.

Bom, por hoje é só, e logo teremos outros posts explicando mais algumas funcionalidades do AndOrm.

Vlw.

Anúncios

AndOrm – Framework ORM para Android

Foi dada a largada…

Depois de algumas pesquisas e sugestões da comunidade, e minha incomodação para resolver a persistência dos aplicativos Android, comecei um projeto open-source para persistência no Android, chamado AndOrm.

Para não perdermos tempo, vamos apresentando os exemplos e logo explicando o funcionamento.

Antes de tudo, crie sua entidade, aqui vamos chamá-la de cliente, como no exemplo:

@Entity
 public class Cliente {

@PrimaryKey
 private Integer id;
 private String nome;
 private String endereco;
 private String email;

//get's e set's omitidos, prém obrigatórios para o framework atribuir/pegar os valores dos atributos

}

Vamos explicar a entidade, apesar dela ser muito simples:

A anotação @Entity vai informar ao framework que aquela classe é realmente uma entidade, e ele deve cuidar dela.

A anotação @PrimaryKey vai informar, como o próprio nome sugere, qual será a chave primária da entidade.

Essas são as únicas anotações obrigatórias para a entidade, o restante é baseado em convenções, sendo assim:

Você precisará ter uma tabela chamada ‘cliente’ (nome da classe em minúscula separada por underline quando Camel Case, ou seja, a classe ClienteEspecial viraria a tabela ‘cliente_especial’). Essa conveção de nomes serve para as colunas também. Sendo assim, sua tabela ‘cliente’ deverá ter os campos ‘id, nome, endereco, email’.

As colunas poderiam sem problema nenhum, receber outro nome, bastaria anotar o atributo com @Column, e definir o atributo ‘name’ da anotação. Assim como o nome da tabela poderia ser trocado por qualquer um, usando a anotação @Table na classe entidade, e definido o valor da anotação.

Tendo a entidade criada, você precisará informar ao AndOrm que esta entidade vai ser mapeada e gerenciada por ele.

Vamos então criar uma classe chamada PMFactory. O que essa classe irá fazer? Configurar nosso framework com as entidades e devolver uma instância de PersistenceManager do AndOrm, que gerencia todas operações do banco. Segue a classe:


public class PMFactory {

private static PersistenceManager instance;

private PMFactory() {}

public static PersistenceManager get() {
 if(instance == null) {
 instance = PersistenceManagerFactory.create(configure());
 }

return instance;
 }

private static AndOrmConfiguration configure() {
 AndOrmConfiguration conf = new AndOrmConfiguration("path_do_banco");

conf.addEntity(Cliente.class);

return conf;
 }

}

AndOrmConfiguration é a classe principal de configuração do AndOrm, e no construtor será passado o caminho completo do banco de dados, incluindo sua extensão.

Depois é só adicionar a entidade à essa configuração para o framework reconhecer esta entidade. Temos mais opções de configurações individuais para cada entidade, mas isso será assunto para outro post.

Tendo esta instância de PersistenceManager, poderemos fazer as operações básicas no banco de dados. Vamos mostrar alguns exemplos:


public class ClienteDao {

private final PersistenceManager manager;

public ClienteDao(PersistenceManager manager) {
 super();
 this.manager = manager;
 }

public void save(Cliente cliente) {
 manager.save(cliente);
 }

public void update(Cliente cliente) {
 manager.update(cliente);
 }

public void remove(Cliente cliente) {
 manager.delete(cliente);
 }

public Cliente find(Integer id) {
 return manager.read(Cliente.class, id);
 }

public List<Cliente> findAll() {
 Criteria query = Criteria.from(Cliente.class);

return manager.find(Cliente.class, query);
 }

public List<Cliente> findByNome(String nome) {
 Criteria query = Criteria.from(Cliente.class).where(like("nome", nome));

return manager.find(Cliente.class, query);
 }
 }

Bom, aqui não há muito o que explicar, exceto a classe Criteria. Bom, ela faz parte do projeto AndOrm Query, que fiz especialmente para o AndOrm, para facilitar as consultas ao banco, tudo através de métodos. Em breve teremos outro post apenas explicando algumas coisas do AndOrm Query e as coisas que estão por vir nela.

No exemplo, merece uma atenção apenas para o método estático ‘like’ importado da classe Restriction do AndOrm Query.

Para finalizar esta primeira parte, vou mosrar um exemplo de como usar herança no AndOrm. Lembrando que, cada entidade, independente de super classe, será considerada uma tabela no banco, ao menos isso por enquanto.

Vamos ao típico exemplo de Pessoa Física e Jurídica:


@MappedSuperClass
 public abstract class Pessoa {

@PrimaryKey
 private Integer id;
 private String nome;
 private String email;
 private String contato;

//get's e set's omitidos
 }

@Entity
 public class PessoaFisica extends Pessoa {

private String cpf;

//get's e set's omitidos

}

@Entity
 public class PessoaJuridica extends Pessoa {

private String cnpj;

//get's e set's omitidos

}

Então no seu objeto AndOrmConfiguration, bastaria adicionar PessoaFisica e PessoaJuridica.

Bom, por hoje é só, mas logo teremos mais posts sobre o AndOrm, para explicar melhor suas funcionalidades já implementadas.

Lembrando que, tenho alguns testes escritos, mas como é o primeiro projeto que aplico o uso de testes, eles podem estar mal implementados, por isso peço ajuda dos desenvolvedores mais experientes para ajudar nessa parte, principalmente por ligar com banco de dados.

A funcionalidade que mais preciso que seja implementada, com testes também, é a geração das tabelas a partir das classes entidade. Então, se você estiver afim de contribuir, eu e provavelmente uma parte da comunidade Android, ficaríamos agradecidos.

Pra quem tiver interesse em contribuir, o projeto encontra-se hospedado no GitHub, no seguinte link, inclusive com o exemplo aqui mostrado e outros futuros exemplos:

https://github.com/jonatasdaniel/andorm

RPC failed, result=28 GitHub

Pra quem, assim como eu, se deparou com o erro

error: RPC failed; result=28, HTTP code = 0
fatal: The remote end hung up unexpectedly
fatal: The remote end hung up unexpectedly

ao dar um ‘push’ nas suas alterações do Git, segue abaixo a solução:

git config http.postbuffer=524288000

Não achei praticamente nada sobre este erro na internet ou em algum help do GitHub, mas em um comentário de um commiter de um projeto, achei um usuário com o mesmo problema, e segundo ele, é um bug do Git, e a solução foi essa configuração.

Se alguém souber o real problema e o porque disto estar ocorrendo, por favor, se manifeste 😉

Javadoc no Eclipse/Ubuntu

Resolvi deixar a preguiça de lado, e enfim colocar o Javadoc no Eclipse.

Como uso o Ubuntu 10.10, a vm padrão é o OpenJDK, que pelo menos por aqui, veio sem o JavaDoc. Mas isso não é problema, segue o tutorial.

Digite o seguinte comando no terminal:

Feito isso, vamos ao Eclipse, em Window, Preferences, Java, Installer JREs, como na foto à seguir:

 

 

 

 

 

 

 

 

 

 

Clique em Edit,

 

 

 

 

 

 

 

 

 

 

Selecione o arquivo rt.jar, clique no botão JavaDoc Location e selecione a opção JavaDoc in archive;

 

 

 

 

 

 

 

 

 

 

Clique então em Browse, e selecione o arquivo src.zip no diretório /usr/lib/jvm/seu_open_jdk.

 

 

 

 

 

 

 

 

 

 

Em vez de seu_open_jdk, coloque o diretório respectivo ao seu open-jdk, no meu caso era java-6-openjdk.

Agora é só desfrutar do Javadoc nas classes Java, espero que tenha sido útil 🙂

Até a próxima…

Iniciando com o VIM

VIM

Bom galera, este é meu primeiro post, e gostaria de ajudar alguns que assim como eu, quando foram iniciar com o VIM, ficaram um pouco perdidos.

Então segue algumas dicas básicas, que a partir daí, poderão caminhar com as próprias pernas.

Primeiramente, se você ainda não tiver ele instalado na sua máquina, digite o seguinte no terminal do Ubuntu:

sudo aptitude install vim

e proceda normalmente;

Caso queira instalar o vim com os plugins para determinada linguagem, proceda da seguinte maneira:

sudo aptitude install vim-python, por exemplo, ou ainda:

sudo aptitude install vim-rails, ou sudo aptitude install vim-ruby, e assim por diante;

Após instalado, inicie o VIM pelo terminal:

vim nome_do_arquivo.extensao

PS: Caso o arquivo não exista, o mesmo será criado no diretório corrente.

Abrirá então o querido VIM, mas neste momento, você estará apenas com a parte visual do VIM, perceba se você digitar algo, nada acontece, e porquê?

Simples, aperte a tecla i, de inserção, para então abrir o modo de inserção do VIM.

E agora, onde estão os menus de salvar?

Bom, é isso que veremos.

Aperte ESC para sair do modo de inserção, e digite algum dos comandos a seguir:

Comandos básicos de inserção de texto:

i Insere texto antes do cursor
a Insere texto depois do cursor
r Insere texto no início da linha onde se encontra o cursor
A Insere texto no final da linha onde se encontra o cursor
o Adiciona linha abaixo da linha atual
O Adiciona linha acima da linha atual
Ctrl + h Apaga o ultimo caracter

Comandos básicos de movimentação:

Ctrl+f Move o cursor para a próxima tela
Ctrl+b Move o cursor para a tela anterior
H Move o cursor para a primeira linha da tela
M Move o cursor para o meio da tela
L Move o cursor para a ultima linha da tela
h Move o cursor um caractere a esquerda
j Move o cursor para a próxima linha
k Move o cursor para linha anterior
l Move o cursor um caractere a direita
w Move o cursor para o inicio da próxima palavra (Ignora a pontuação)
W Move o cursor para o inicio da próxima palavra (Não ignora a pontuação)
b Move o cursor para o inicio da palavra anterior (Ignora a pontuação)
B Move o cursor para o inicio da palavra anterior (Não ignora a pontuação
Move o cursor para o inicio da linha atual
^ Move o cursor para o primeiro caractere não branco da linha atual
$ Move o cursor para o final da linha atual
nG Move o cursor para a linha n
G Move o cursor para a ultima linha do arquivo

Comandos básicos para localizar texto:

/palavra Busca pela palavra ou caractere em todo o texto
?palavra Move o cursor para a ocorrência anterior da palavra
n Repete o ultimo comando / ou ?
N Repete o ultimo comando / ou ? , na direção reversa
Ctrl+g Mostra o nome do arquivo, o numero da linha corrente e o total de linhas

Comandos básicos para alteração de texto:

x Deleta o caractere que esta sob o cursor
dw Deleta a palavra, da posição atual do cursor ate o final
dd Deleta a linha atual
D Deleta a linha a partir da posição atual do cursor ate o final
rx Substitui o caractere sob o cursor pelo especificado em x(é opcional indicar o caractere)
Rx Substitui a palavra sob o cursor pela palavra indicada em x
u Desfaz a ultima modificação
U Desfaz todas as modificações feitas na linha atual
J Une a linha corrente a próxima
s:/palavra1/palavra2 Substitui a primeira ocorrência de “palavra1” por “palavra2”

Comandos para salvar o texto:

:wq Salva o arquivo e sai do editor
:w nome_do_arquivo Salva o arquivo corrente com o nome especificado
:w! nome_do_arquivo Salva o arquivo corrente no arquivo especificado
:q Sai do editor
:q! Sai do editor sem salvar as alterações realizada

Bom, é isso, apesar de ser bem básico, espero que ajude muita gente a das seus primeiros passos no VIM e descobrir o quão poderosa é essa ferramenta.

Agradecimentos ao Guilherme Maba pelas dicas dos comandos.

[]s