Banco de dados avançado fácil e rápido com ORM no Android

Olá pessoal!

Bem, dando continuidade ao trabalho do blog Mobsource, darei continuidade ao seu trabalho (re) publicando o post referente a banco de dados avançado.

Olá amigos, vamos a mais um artigo sobre como trabalhar com Android e banco de dados.
Caso você não tenha lido a primeira parte, sobre como criar a camada de acesso a dados, aí vai o link http://blog.mobsource.com.br/2014/07/banco-de-dados-facil-e-rapido-com-orm.html.
Nessa segunda postagem, vamos falar sobre conceitos mais avançados a respeito da ferramenta ORMLite.
Se você fez o exemplo do primeiro artigo, imagino que você tenha se perguntado: “OK, mas como uso uma clausula ‘where’, ‘order’ ou ‘join’?”.
Sem dúvida, essa é uma pergunta muito pertinente !
Na maioria das ferramentas ORM é possível executar todos esses comandos sem escrever nenhuma linha de código sql, no ORMLite não é diferente.
Para exemplificar, usaremos o projeto do artigo anterior, ok?
Vamos fazer mais exemplos?

Passo 1. Usando WHERE para filtrar suas consultas

Abra o arquivo ClientesDAO no package dao. (no meu caso está no package br.com.exemplo.db.dao)
Vamos escrever um método que filtre os resultados apenas dos clientes com sobrenome iguais a “Silva”.
Faça a implementação como no exemplo.


public List<Clientes> getBySobreNomeSilva() {
   List<Clientes> clientes = new ArrayList<Clientes>();

     try{
         QueryBuilder<Clientes, Integer> queryBuilder = dao.queryBuilder();
         queryBuilder.where().eq("sobrenome", "Silva");
         clientes = dao.query(queryBuilder.prepare());
      }catch(Exception e){
         e.printStackTrace();
      }

      return clientes;
}

Nesse método retornamos uma lista de Clientes.
Criamos um objeto do tipo QueryBuilder onde trabalharemos com o tipo Clientes e a PK dele é do tipo integer.
Este objeto é responsável pela clausula ‘where sobrenome seja igual (eq) “Silva”‘.
O último passo é enviar essas informações para a classe dao do ORMLite processar a query.
Simples, não é? Nenhuma linha SQL. 🙂 Próximoooooo…..

Passo 2. Ordenando a sua consulta

No próximo exemplo vamos ordenar o resultado da nossa consulta trazendo todos os registros de clientes ordenando pelo primeiro nome.

public List<Clientes> getByNome() {
   List<Clientes> clientes = new ArrayList<Clientes>();

   try{
      QueryBuilder<Clientes, Integer> queryBuilder = dao.queryBuilder();
      queryBuilder.orderBy("nome", false);
      clientes = dao.query(queryBuilder.prepare());
   }catch(Exception e){
      e.printStackTrace();
   }

   return clientes;
}

A única coisa que muda nesse caso é que chamamos o método “orderBy” que recebe os parâmetros do campo que será ordenado e se ele será “asc” ou “desc”. (crescente ou decrescente).

Passo 3. Misturando as coisas

Digamos agora que eu quero o último registro da tabela clientes, como faço?
Notem a facilidade.

public Clientes getLast() {
   Clientes cliente = new Clientes();

   try{
      QueryBuilder<Clientes, Integer> queryBuilder = dao.queryBuilder();
      queryBuilder.orderBy("id", true);
      cliente = dao.queryForFirst(queryBuilder.prepare());
   }catch(Exception e){
      e.printStackTrace();
   }

   return cliente;
}

Fazemos uma query que ordena pelo campo id de forma invertida(trazendo o último até o primeiro) e por fim pegamos o primeiro registro disponível que seria o último inserido.
Pouco código e tudo o que precisamos na mão.

Passo 4. Criando a classe para fazer o join

Vamos supôr que nosso cliente tenha vários endereços que estão armazenados em outra tabela.
Crie no seu package entities a classe Enderecos. (no meu caso, br.com.exemplo.db.entities)

@Entity(name="enderecos")
public class Enderecos {

   @Id @GeneratedValue
   private int id;

   @Column(name="endereco", nullable=false)
   private String endereco;

   @Column(name="cep", nullable=false)
   private String cep;

   @DatabaseField(foreign=true)
   private Clientes clientes;

   public Enderecos() {}

   public int getId() {
      return id;
   }

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

   public String getCep() {
      return cep;
   }

   public void setCep(String cep) {
      this.cep = cep;
   }

   public Clientes getClientes() {
      return clientes;
   }

   public void setClientes(Clientes clientes) {
      this.clientes = clientes;
   }

   public String getEndereco() {
      return endereco;
   }

   public void setEndereco(String endereco) {
      this.endereco = endereco;
   }
}

Notem que temos um campo diferente dessa vez !
O campo DataBaseField indica uma FK para a tabela Clientes.
Atenção, a notação DataBaseField é do componente ORMLite e não da JPA.
Se você me perguntar o por que, tenho uma boa resposta.
Nem todas as notações JPA estão disponíveis na ferramenta ORMLite. =(

Passo 5. Inserindo a tabela na criação da database

Abra o arquivo DataBaseHelper no package connection. (no meu caso br.com.exemplo.db.connection).
Iremos acrescentar a tabela Enderecos como mostrado abaixo.

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);
         TableUtils.createTable(src, Enderecos.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);
         TableUtils.dropTable(src, Enderecos.class, true);
         onCreate(db, src);
      }catch(Exception e){
         e.printStackTrace();
      }
   }

   @Override
   public void close() {
      super.close();
   }
}

Inserimos uma linha para Create e outra para Upgrade. Nenhum segredo. 🙂
Passo 6. Criando um DAO para Enderecos

Crie uma classe chamada EnderecosDAO no seu package dao (no meu caso, br.com.exemplo.db.dao)
Faça a implementação como exemplificado.


public class EnderecosDAO extends GenericDao<Enderecos> {

   public EnderecosDAO(Context context) {
      super(context, Enderecos.class);
   }

}

Segue o mesmo modelo de implementação que fizemos no artigo anterior.

Passo 7. Inserindo a referência em Clientes

Precisamos agora inserir a referência no objeto Clientes, ou seja, quando carregarmos um cliente, automaticamente ele deverá carregar uma lista de enderecos. (join)
Abra o arquivo Clientes na pasta entities (no meu caso, br.com.exemplo.db.entities) e faça a modificação conforme demonstrado.

@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;

   @ForeignCollectionField(eager=false)
   private Collection<Enderecos> enderecos;

   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;
   }

   public Collection<Enderecos> getEnderecos() {
      return enderecos;
   }

   public void setEnderecos(Collection<Enderecos> enderecos) {
      this.enderecos = enderecos;
   }
}

A notação ForeignCollectionField (também da ORMLite e não JPA) faz todo o trabalho.
Ela indica que uma coleção de Enderecos será carregado de forma síncrona(eager=false) toda vez que o objeto Clientes for carregado.
Passo 8. Testando tudo

Antes de testar esse exemplo, remova completamente o aplicativo usado no artigo anterior, ok?
Abra a sua Activity e crie um método como o demonstrado.

private void testarDB() {
ClientesDAO daoCli = new ClientesDAO(getApplicationContext());
Clientes cliente = new Clientes();
cliente.setNome("StrangerDroid");
cliente.setSobrenome("Blog");
cliente.setEmail("strangerdroid@gmail.com");

daoCli.insert(cliente);
cliente = daoCli.getById(1);

EnderecosDAO daoEnd = new EnderecosDAO(getApplicationContext());
Enderecos endereco1 = new Enderecos();
endereco1.setEndereco("Rua da casa");
endereco1.setCep("234324");
endereco1.setClientes(cliente);

Enderecos endereco2 = new Enderecos();
endereco2.setEndereco("Rua da outra casa");
endereco2.setCep("454545");
endereco2.setClientes(cliente);

daoEnd.insert(endereco1);
daoEnd.insert(endereco2);

Clientes clientes = daoCli.getLast();

if (clientes.getEnderecos() != null) {
   Toast.makeText(getApplicationContext(), Integer.toString(clientes.getEnderecos().size()), Toast.LENGTH_LONG).show();
}

Esse método é responsável por:
– Inserir um cliente chamado “StrangerDroid”
– Inserir dois endereços para esse cliente
– Carregar novamente esse cliente.

E por último ele exibe o número de endereços do usuário.
Se tudo correu bem, ele deve exibir o numero 2 ! 🙂 (dois endereços para o cliente “StrangerDroid”)
Quando carregamos o cliente, ele trouxe os endereços. (join)
Talvez você esteja se perguntando: “Legal, mas como uso uma Collection?”.
Muito simples, List<Enderecos> enderecos = new ArrayList<SuaCollection>() ;

fonte: https://mastigado.wordpress.com

fonte: http://blog.mobsource.com.br/2014/07/banco-de-dados-avancado-facil-e-rapido.html

Anúncios

Banco de dados fácil e rápido com ORM no Android

Olá pessoal!

Hoje irei reproduzir um post na íntegra de um blog  que me ajudou muito chamado “mobsource”, mas que saiu do ar recentemente. E para compartilhar o conhecimento, vou deixar o post que fala sobre ORM Lite aqui (porém ainda assim deixarei o link no final da página).

fonte: https://mastigado.wordpress.com

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.

fonte: https://mastigado.wordpress.com

fonte: http://blog.mobsource.com.br/2014/07/banco-de-dados-avancado-facil-e-rapido.html

%d blogueiros gostam disto: