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

Anúncios

Sobre Mastigado
Sou um daqueles que precisa mudar o mundo.

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

  1. zf says:

    Bom dia, estou com dúvida!!!

    public abstract class GenericDao extends DataBaseHelper

    Esse se refere a que???? preciso importar e não estou encontrando…

    Curtir

    • Mastigado says:

      Olá meu caro.
      DataBaseHelper é a sua classe que irá sobrescrever os métodos onCreate, onUpgrade, Close (e outros que desejar) da classe OrmLiteSqliteOpenHelper contida na biblioteca do ORMLite. Ao importá-la no arquivo gradle automaticamente você poderá herdá-la deste jeito aí.

      Curtir

  2. zf says:

    DataBaseHelper… ai tem Menor que – E – maior que
    esse é entre menor e maior pertence a que????

    Curtir

    • Mastigado says:

      Este “” quer dizer que você pode passar para ele qualquer objeto que tenha sido mapeado para o ORMLite. Um exemplo é a classe ClientesDAO que herda de GenericDao, só que informando GenericDao. Repare que “” é uma classe que foi mapeada, seus campos foram mapeados um a um para o ORMLite, por isso você deve entender que a partir do momento que ela foi mapeada será tratada como um objeto genérico para o ORMLite.

      Curtir

  3. RAMON SILVA SANTOS says:

    Olá boa noite, como eu poderia estar criando outros métodos mais específicos para uma determinada entidade, ao invés de usar os métodos do GenericDao. Seria dentro do proprio ClienteDao?

    Curtir

    • Mastigado says:

      Meu caro a resposta é bem simples.

      A gente geralmente usa Generic DAO quando precisamos abstrair operações em semelhança com outras entidades, como aqueles do tipo apagar tudo, trazer tudo, buscar um registro em específico por um id, entre outras que estão aí listadas na classe genérica. Por isso é bom que você entenda e importância de uma classe genérica para não ficar repetindo código. Portanto sempre quando precisar usar uma entidade com uma consulta mais específica, nunca deixe de herdar as características da classe genérica. Lembre-se disso.

      No exemplo abaixo coloquei um código referente uma entidade chamada de MunicipioDao que herda de GenericDao e que trabalha com a classe Municipio que supomos aqui que tenha apenas os atributos codigo e descricao. Ficaria deste jeito uma classe como métodos mais específicos:

      public class MunicipioDao extends GenericDao<Municipio> {
      
          public MunicipioDao(Context context) {
              super(context, Municipio.class);
          }
      
          public List<Municipio> TrazerTodosOsMunicipioPorCodigo(int codigo) {
      
              List<Municipio> municipioList = new ArrayList<Municipio>();
      
              try{
                  QueryBuilder<Municipio, Integer> queryBuilder = dao.queryBuilder();
                  queryBuilder.where().eq("codigo", codigo);
                  queryBuilder.orderBy("codigo", false);
                  municipioList = dao.query(queryBuilder.prepare());
              }catch(Exception e){
                  e.printStackTrace();
              }
      
              return municipioList;
          }
      }
      

      MunicipioDao == ClienteDao.

      Tá aí, mastigado.

      Curtir

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair /  Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair /  Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair /  Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair /  Alterar )

w

Conectando a %s

%d blogueiros gostam disto: