quinta-feira, 24 de julho de 2014

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












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.

Até a próxima. :)