segunda-feira, 22 de outubro de 2012

Android: Acessando banco de dados fácil e rápido com ORM !


Ainda me lembro quando comecei a desenvolver Android e me deparei com documentações informando como acessar um banco de dados. (SQLite)
A primeira impressão foi: "Uau, parece ser bem simples".
E foi ! O único problema é que toda a camada de acesso a dados fica na responsabilidade do desenvolvedor e com isso muito código precisaria ser escrito para ter uma camada de dados consistente e de fácil entendimento e manutenção.
Por conta desse tipo de situação resolvi pesquisar há algum tempo, alguma ferramenta que desse ao desenvolvedor a facilidade de programar usando ORM.... ferramentas como o Linq da linguagem C#, Hibernate (e suas muitas variações).
No fim das contas acabei encontrando uma ferramenta muito boa, com portabilidade para Android e que simplifica toda a escrita da camada de dados de um projeto.
A ferramenta que encontrei se chama ORMLite. http://ormlite.com/
Ela funciona de forma muito simples ! Em resumo são esses os passos:
1. Você cria o seu DataBaseHelper (classe responsável para criar o banco de dados, informando o nome da database, as tabelas e ações de upgrade do banco de dados).
2. Você cria suas classes (que serão as tabelas) usando anotações da própria ferramenta ou a parte mais legal da ferramenta... ELA ACEITA JPA ! (caso não saiba o que é jpa aí vai uma boa referência... http://imasters.com.br/artigo/21505/java/utilizando-hibernate-jpa-no-desenvolvimento-em-java--mysql)
3. Você cria suas classes Dao e passa a fazer todo o CRUD em poucas linhas.
E pronto é só usar ! rs

Mas bom... não vamos ficar só nisso, vamos fazer um exemplo !

Passo 1. Baixando as ferramentas

Faça o download dos arquivos ormlite-android-4.41.jar e ormlite-core-4.41.jar no site
http://ormlite.com/releases/  (se houver alguma versão mais recente não tem problemas)

Faça o download do arquivo hibernate-jpa-2.0-api-1.0.1.Final.jar que você encontra
no pacotes de instalação do hibernate para java.http://www.hibernate.org/downloads (também não tem problemas se você pegar uma versão mais nova)

Passo 2. Reconhecendo no projeto

Copie esses arquivos para a pasta libs do seu projeto e faça a referência a elas clicando com o botão  direito no seu projeto e logo após Properties.
Clique no item Java Build Path e depois clique em Libraries.
Clique no botão Add JARs...
Abra a pasta libs do seu projeto e selecione os arquivos.

Passo 3. Escrevendo as entidades

Crie um package no seu projeto para criar as entidades que serão as tabelas da database. (coloque o nome que preferir. No meu caso ficou assim: br.com.exemplo.db.entities)
Crie uma classe chamada Clientes como a descrita abaixo:

@Entity(name="clientes")
public class Clientes {
 @Id @GeneratedValue
private int id;
 @Column(name="nome", nullable=false)
private String nome;
 @Column(name="sobrenome", nullable=false)
private String sobrenome;
 @Column(name="email", nullable=false)
private String email;
public Clientes() {
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getNome() {
return nome;
}

public void setNome(String nome) {
this.nome = nome;
}

public String getSobrenome() {
return sobrenome;
}

public void setSobrenome(String sobrenome) {
this.sobrenome = sobrenome;
}

public String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}
}

Note a simplicidade na implementação da classe. Usamos:
- Entity para definir a classe como tabela.
- Id e GeneratedValue para criar a PK e dizer que ela é auto-incremento.
- Column e Nullable para dizer que se trata de uma coluna que não pode ser nula.

Simples não?

Passo 4. Escrevendo a classe helper

Crie um package para armazenar a classe responsável por criar o banco de dados. (no meu caso ficou assim... br.com.exemplo.db.connection)
Crie uma classe com o nome DataBaseHelper e faça a implementação como o exemplo.

public class DataBaseHelper<E> extends OrmLiteSqliteOpenHelper {
public DataBaseHelper(Context context) {
super(context, "sistema.db", null, 1);
}

@Override
public void onCreate(SQLiteDatabase db, ConnectionSource src) {
try{
TableUtils.createTable(src, Clientes.class);
}catch(Exception e){
e.printStackTrace();
}
}

@Override
public void onUpgrade(SQLiteDatabase db, ConnectionSource src, int oldVersion, int newVersion) {
try{
TableUtils.dropTable(src, Clientes.class, true);
onCreate(db, src);
}catch(Exception e){
e.printStackTrace();
}
}
@Override
public void close() {
super.close();
}
}


Note que criamos a classe herdando de OrmLiteSqliteOpenHelper e criamos o banco de dados("sistema.db") com a tabela Clientes. 


Passo 5. Escrevendo a classe dao

Crie um package para armazenar suas classes dao. (no meu caso ficou assim... br.com.exemplo.db.dao)
Crie uma classe chamada GenericDao que será nossa classe base e faça a implementação demonstrada.

public abstract class GenericDao<E> extends DataBaseHelper<E> {

protected Dao<E, Integer> dao;
private Class<E> type;
public GenericDao(Context context, Class<E> type) {
super(context);
this.type = type;
setDao();
}
protected void setDao() {
try{
dao = DaoManager.createDao(getConnectionSource(), type);
}catch(Exception e){
e.printStackTrace();
}
}

public List<E> getAll() {
try{
List<E> result = dao.queryForAll();
return result;
}catch(Exception e){
e.printStackTrace();
return null;
}
}

public E getById(int id) {
try{
E obj = dao.queryForId(id);
return obj;
}catch(Exception e){
e.printStackTrace();
return null;
}
}

public void insert(E obj) {
try{
dao.create(obj);
}catch(Exception e){
e.printStackTrace();
}
}

public void delete(E obj) {
try{
dao.delete(obj);
}catch(Exception e){
e.printStackTrace();
}
}

public void update(E obj) {
try{
dao.update(obj); 
}catch(Exception e){
e.printStackTrace();
}
}
}

Note que essa classe já deixa pronta todos os métodos básicos para acesso ao banco de dados. (só precisamos escrever uma vez)
Agora vamos implementar a nossa classe dao.
Crie uma classe chamada ClientesDAO e faça a implementação como demonstrado.

public class ClientesDAO extends GenericDao<Clientes> {

public ClientesDAO(Context context) {
super(context, Clientes.class);
}
}


Note a quantidade pequena de linhas que precisamos para escrever a classe dao de clientes.

Passo 6. Inserindo um cliente

Coloque um botão no seu projeto e faça a implementação demonstrada no evento de clique.

     ClientesDAO dao = new ClientesDAO(getApplicationContext());
    Clientes cliente = new Clientes();
    cliente.setEmail("strangerdroid@gmail.com");
    cliente.setNome("Stranger");
    cliente.setSobrenome("Droid");
    dao.insert(cliente);


Ao fazer isso o banco de dados é criado na pasta "databases", as tabelas são criadas e você acabou de inserir um registro.
Se você pedir o comando "dao.getAll()" ele retornará uma List<Clientes>. :)
Fora isso, agora você tem métodos para fazer delete, update, select todos prontos.

Espero que esse artigo possa ajudá-lo a iniciar o desenvolvimento com a ferramenta OrmLite.
Além do que demonstramos podemos fazer diversas outras coisas sem escrever nem uma linha sequer de código sql.
Aos que tiverem problemas me enviem emails no strangerdroid@gmail.com que terei prazer em ajudá-lo.
Até a próxima. :)

StrangerDroid


10 comentários:

  1. Cara, tenho uma aplicação aqui feita em PHP que é um simples CRUD, quero migrá-la para android e não consigo uma forma simples de fazê-la, já vi tutoriais explicando um CRUD mas até agora, nada do que vi foi tão simples assim. Até vi outro tuto mostrando como integrar php + android, na parte do php ficava a conexão com o BD e todas as funções do control do CRUD, no java ficava model e view e era algo gigante, estou meio perdido, se puder me indicar um tutorial realmente simples, agradecerei MUITO!

    ResponderExcluir
  2. Olá amigo, creio que esse mesmo tutorial possa ser de grande ajuda.
    Caso você ainda não tenha experiência com Android, você pode começar pelo mais básico
    montando uma interface.

    http://strangerdroid.blogspot.com.br/2012/08/instalando-o-android-sdk.html
    http://strangerdroid.blogspot.com.br/2012/08/hello-world.html

    E por fim siga esse tutorial que com certeza será de muita ajuda.
    Caso você tenha dificuldades para entender qualquer parte do processo entre em contato. :)

    Abs,

    StrangerDroid

    ResponderExcluir
  3. Opa, já consegui instalar e "conectar" ao Eclipse.

    Já rodei um "Olá Mundo" pra testar e tudo.

    Esse tuto parece ser bem simples mesmo, vou fazê-lo, quando terminar posto como ficou e alguma dúvida em relação ao layout. Sempre tenho dificuldade, não uso aquele "viewer" da IDE, fico alterando no código diretamente e nem sempre fica como eu quero por lá. Minhas dúvidas principais são em relação ao BD, não quero trabalhar com persistência, enfim, quando terminar o tuto reportarei.

    Att.,

    Sckt.

    ResponderExcluir
  4. Olá, no passo 3 não é necessario colocar o implements serializable?

    ResponderExcluir
    Respostas
    1. Obrigatoriamente não amigo. Seria interessante você fazer isso caso você vá transportar a classe de uma Activity para outra por exemplo. Abs.

      Excluir
  5. pq vc usou o annotation do jpa ao invés do ormlite para criar as entidades ?
    fez alguma configuracao para usar o jpa ?
    Abs

    ResponderExcluir
    Respostas
    1. Olá amigo a única razão de eu ter usado JPA foi para mostrar para usuários de Hibernate (por exemplo) que eles não precisam reaprender a sintaxe de annotation desse componente. Abs. :)

      Excluir
  6. parabéns!, muito bom o conteúdo e consegui utilizar sem problemas de compatibilidade
    att
    Rober

    ResponderExcluir
    Respostas
    1. Disponha e volte sempre amigo ! Visite também nossa página no facebook... de tempos em tempos postando um material diferenciado por lá. Abs. http://www.facebook.com/StrangerDroidBlog

      Excluir
  7. Muito bom, material excelente difícil de encontrar em pt-br.

    Parabéns.

    ResponderExcluir