Banco de dados fácil e rápido com ORM no Android
abril 3, 2016 6 Comentários
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:
- 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).
- 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)
- 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
Mastigado 
Comentários