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
