SQLite – Banco de dados no Android!

Para fazer download do código apresentando neste artigo clique no link abaixo:
https://github.com/leonvian/cadastroVeiculo

Introdução

Já imaginou se você tivesse que começar aquele seu jogo favorito do início todas as vezes que desligar o celular.
Ou tivesse que se cadastrar novamente no facebook todas as vezes que entrasse neste aplicativo.

Seria muito ruim não é mesmo!?

É por isso que a persistência de dados é um pilar muito importante em programação para dispositivos móveis. Sem isso as funcionalidades acima não seriam alcançadas assim como diversas outras.

Para atender a necessidade de persistir dados o Android oferece suporte nativo ao banco de dados SQLite.

O SQLite, é uma base de dados leve e poderosa, que vem ficando cada vez mais popular na comunidade de TI. Principalmente entre os desenvolvedores que trabalham com Android e/ou iOS uma vez que as duas tecnologias possuem suporte nativo para o SQLite.

É importante ressaltar que o SQLite não é a única forma de persistência que o desenvolvedor pode adotar em um projeto Android.

Existem outras tecnologias como por exemplo: o DB4O ou o NeoDatis que são banco de dados que utilizam o paradigma da Programação Orientados a Objetos e que também conseguem atender bem a necessidade de persistência.

Neste artigo trabalharemos com o SQLite, mas vale a pena ficar por dentro dessas outras abordagens por serem muito interessantes.

Direto para a prática.

A partir de agora exemplificaremos o uso do SQLite vamos criar um Cadastro de veículos onde o usuário conseguirá salvar, editar, deletar e recuperar um veículo.
Para atender esse cenário, a primeira classe que precisaremos é a entidade Veiculo, que representará os dados que serão manipulados pelo nosso banco de dados.

O código dessa entidade se encontra logo abaixo:

public class Veiculo {

	private int id;
	private String marca;
	private String modelo;
	private String placa;

	public Veiculo() {

	}
	
	public Veiculo(int id, String marca, String modelo, String placa) {
		super();
		this.id = id;
		this.marca = marca;
		this.modelo = modelo;
		this.placa = placa;
	}



	public String getMarca() {
		return marca;
	}

	public void setMarca(String marca) {
		this.marca = marca;
	}

	public String getModelo() {
		return modelo;
	}

	public void setModelo(String modelo) {
		this.modelo = modelo;
	}

	public String getPlaca() {
		return placa;
	}

	public void setPlaca(String placa) {
		this.placa = placa;
	}
	
	public int getId() {
		return id;
	}
	
	public void setId(int id) {
		this.id = id;
	}
	
	@Override
	public String toString() {
		return placa + " " +  modelo + " " + marca;
	}
} 

Veja que se trata de uma classe POJO bem simples com apenas 3 atributos do tipo String (Placa, Marca e Modelo) e um atributo int de nome id que será o identificador único de cada registro no banco de dados (Primary Key da nossa tabela).

Agora que temos a classe que representa os dados que serão persistidos, vamos criar uma classe que sabe como persistir um Veiculo.

Para isso utilizaremos o padrão de projeto DAO (Data Access Object). Este padrão de projeto consiste no encapsulamento da parte de persistência de uma determinada entidade de negócio (no nosso exemplo esta entidade de negócio esta representada na classe Veiculo).
Para saber mais sobre esse padrão clique neste link.

Basicamente, criaremos uma classe que se chamará VeiculoDAO, e terá métodos que acessam o banco de dados, dentre esses métodos podemos destacar:

salvar(Veiculo veiculo), editar(Veiculo veiculo), deletar(Veiculo veiculo) e recuperarTodos().

Acompanhe o código da classe VeiculoDAO logo abaixo:

public class VeiculoDAO {


	public static final String NOME_TABELA = "Veiculo";
	public static final String COLUNA_ID = "id";
	public static final String COLUNA_MARCA = "marca";
	public static final String COLUNA_MODELO = "modelo";
	public static final String COLUNA_PLACA = "placa";


	public static final String SCRIPT_CRIACAO_TABELA_VEICULOS = "CREATE TABLE " + NOME_TABELA + "("
			+ COLUNA_ID + " INTEGER PRIMARY KEY," + COLUNA_MARCA + " TEXT," + COLUNA_PLACA + " TEXT,"
			+ COLUNA_MODELO + " TEXT" + ")";

	public static final String SCRIPT_DELECAO_TABELA =  "DROP TABLE IF EXISTS " + NOME_TABELA;


	private SQLiteDatabase dataBase = null;


	private static VeiculoDAO instance;
	
	public static VeiculoDAO getInstance(Context context) {
		if(instance == null)
			instance = new VeiculoDAO(context);
		return instance;
	}

	private VeiculoDAO(Context context) {
		PersistenceHelper persistenceHelper = PersistenceHelper.getInstance(context);
		dataBase = persistenceHelper.getWritableDatabase();
	}

	public void salvar(Veiculo veiculo) {
		ContentValues values = gerarContentValeuesVeiculo(veiculo);
		dataBase.insert(NOME_TABELA, null, values);
	}

	public List<Veiculo> recuperarTodos() {
		String queryReturnAll = "SELECT * FROM " + NOME_TABELA;
		Cursor cursor = dataBase.rawQuery(queryReturnAll, null);
		List<Veiculo> veiculos = construirVeiculoPorCursor(cursor);

		return veiculos;
	}

	public void deletar(Veiculo veiculo) {

		String[] valoresParaSubstituir = {
				String.valueOf(veiculo.getId())
		};

		dataBase.delete(NOME_TABELA, COLUNA_ID + " =  ?", valoresParaSubstituir);
	}

	public void editar(Veiculo veiculo) {
		ContentValues valores = gerarContentValeuesVeiculo(veiculo);

		String[] valoresParaSubstituir = {
				String.valueOf(veiculo.getId())
		};

		dataBase.update(NOME_TABELA, valores, COLUNA_ID + " = ?", valoresParaSubstituir);
	}

	public void fecharConexao() {
		if(dataBase != null && dataBase.isOpen())
			dataBase.close(); 
	}


	private List<Veiculo> construirVeiculoPorCursor(Cursor cursor) {
		List<Veiculo> veiculos = new ArrayList<Veiculo>();
		if(cursor == null)
			return veiculos;
		
		try {

			if (cursor.moveToFirst()) {
				do {

					int indexID = cursor.getColumnIndex(COLUNA_ID);
					int indexMarca = cursor.getColumnIndex(COLUNA_MARCA);
					int indexModelo = cursor.getColumnIndex(COLUNA_MODELO);
					int indexPlaca = cursor.getColumnIndex(COLUNA_PLACA);

					int id = cursor.getInt(indexID);
					String marca = cursor.getString(indexMarca);
					String modelo = cursor.getString(indexModelo);
					String placa = cursor.getString(indexPlaca);

					Veiculo veiculo = new Veiculo(id, marca, modelo, placa);

					veiculos.add(veiculo);

				} while (cursor.moveToNext());
			}
			
		} finally {
			cursor.close();
		}
		return veiculos;
	}

	private ContentValues gerarContentValeuesVeiculo(Veiculo veiculo) {
		ContentValues values = new ContentValues();
		values.put(COLUNA_MARCA, veiculo.getMarca());
		values.put(COLUNA_MODELO, veiculo.getModelo());
		values.put(COLUNA_PLACA, veiculo.getPlaca());

		return values;
	}
}

Antes de iniciar as explicações da classe VeiculoDAO, podemos identificar que ela faz referência a uma classe chamada PersistenceHelper.

Mas o que é essa tal de PersistenceHelper?

A classe PersistenceHelper é uma classe criada por nós que herda funcionalidades da classe SQLiteOpenHelper da API do Android e é responsável pela criação e o versionamento do banco de dados.
Então é nessa classe que iremos definir o nome do banco de dados, a versão do banco de dados e todas as tabelas que o banco terá.

Pra que serve essa versão?

Para que você consiga evoluir o banco de dados, quando o seu aplicativo sofrer alterações.

Imaginando um cenário onde você criou um aplicativo que tenha um cadastro de Veiculo. Depois de duas semanas nasceu a necessidade de colocar mais um cadastro agora de Pessoa.

Os usuários da primeira versão irão precisar sofrer uma modificação no banco de dados uma vez que uma nova tabela terá que ser criada.

Para que ele consiga criar essa nova tabela sem perder os veículos já cadastrados no momento da re-criação do banco com a tabela Pessoa ele muda a versão do banco de dados e faz uma lógica para salvar os veículos antes de deletar e criar novamente o banco.

Logo abaixo o código da PersistenceHelper:

public class PersistenceHelper extends SQLiteOpenHelper {

	public static final String NOME_BANCO =  "ExemploVeiculo";
	public static final int VERSAO =  1;
	
	private static PersistenceHelper instance;
	
	private PersistenceHelper(Context context) {
		super(context, NOME_BANCO, null, VERSAO);
	}
	
	public static PersistenceHelper getInstance(Context context) {
		if(instance == null)
			instance = new PersistenceHelper(context);
		
		return instance;
	}

	@Override
	public void onCreate(SQLiteDatabase db) {
		db.execSQL(VeiculoDAO.SCRIPT_CRIACAO_TABELA_VEICULOS);
	}

	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
		db.execSQL(VeiculoDAO.SCRIPT_DELECAO_TABELA);
		onCreate(db);
	}

}

Logo no começo da classe podemos notar a presença das constantes que representam o nome da tabela e as suas colunas.

Estão presentes ai como constantes públicas pois precisaremos dessas informações em vários pontos em nosso sistema.

Também podemos destacar outras duas constantes que representam o script de criação e de alteração da base dados.

O script de criação irá criar a tabela de veículo enquanto o script de alteração irá deleta-la.
Vamos identificar onde esses scripts serão acionados.

Ao extender a classe SQLiteOpenHelper, somos forçados a implementar um construtor e dois métodos abstratos (onCreate e onUpdate) conforme foi explicado anteriormente esses métodos serão acionados caso haja alteração na versão da base de dados ou em caso de criação da mesma. Podemos ver a implementação desses métodos na listagem de código referente a classe PersistenceHelper que esta logo acima.

No método onCreate, executaremos o script de criação do banco de dados uma vez que o Android identificou que aquele dispositivo não possui versões anteriores do banco de dados do nosso aplicativo.
Já no método onUpdate executaremos o script de alteração, pois o Android identificou uma versão anterior do banco de dados do aplicativo e precisará apenas atualiza-lo.

Esses scripts serão executados de acordo com a versão da base de dados. Caso a versão seja 1 assim que o aplicativo for iniciado pela primeira vez o script de criação será acionado. Caso o desenvolvedor mude a versão da base de dados para 2 (em função de alguma mudança, provavelmente na entidade que será persistida) o script de alteração será acionado, a intenção é que ele delete a tabela antiga para em seguida chamar o script de criação com as mudanças já realizadas.

Este versionamento que mencionamos e outros detalhes da criação da base de dados da sua aplicação ficam a cargo da nossa classe PersistenceHelper esta classe por sua vez herda funcionalidades da classe SQLiteOpenHelper presente na API do Android.

Parâmetros exigidos pelo construtor do SQLiteOpenHelper

É importante ressaltar que o construtor da classe PersistenceHelper nos obriga a informar, um Context (uma classe do Android que esta presente nas Activitys, Services e outras classes primordias dessa tecnologia), o nome do banco de dados, a versão, e um CursorFactory (Esse objeto é utilizado quando queremos fazer uso de um tipo diferente de Cursor, como não é o nosso caso passamos null) – O objeto Cursor também será explicado mais a frente nesse artigo.

A outra função do SQLiteOpenHelper

A classe PersistenceHelper não cuidará apenas da criação e possíveis alterações da base. É através dela que conseguiremos recuperar um objeto da classe SQLiteDatabase, esse objeto é de fundamental importância para a manipulação de dados no SQLite.

É nessa classe que esta contido a maioria dos métodos de manuseamento de registros na base de dados como:

insert, update, delete, rawQuery, execSql

Veja na classe VeiculoDAO, que fazemos muito uso desses métodos.

Vamos as explicações de cada método utilizado

Começaremos pelo método insert é o comando para inserir um novo registro na base de dados.
Recebe como parâmetro o nome da tabela que o registro será inserido e os dados que serão inseridos. Esses dados serão representados pelo ContentValues falaremos mais dessa estrutura futuramente neste artigo, no entanto basta entender que o ContentValues é uma estrutura de chave e valor, onde a chave representa determinada coluna de uma tabela e o valor é o registro que deverá ser inserido nesta coluna.

O método update, é responsável pela alteração de registros.
Recebe como parâmetro o nome da tabela do registro que iremos editar.
A condição de identificação de registro, ou seja, uma query para sabermos quais registos serão editados.
E como último parâmetro novamente um ContentValues que representam os dados atualizados.

O método delete por sua vez deletará registros.
E receberá os mesmos parâmetros do método update, com excessão do ContentValues pois estamos deletando e não precisamos de registro algum para salvar ou editar.

O método rawQuery, recebe como parâmetro uma String que representará uma consulta na base de dados (um select), esse método retorna um objeto do tipo Cursor.

O Cursor, é o objeto que será encarregado de armazenar o retorno de uma determinada consulta. Então sempre que realizar uma consulta na tabela, o resultado desta consulta será representado pelo Cursor.

Por isso, o desenvolvedor terá que desenvolver uma função para pegar esses dados do Cursor e construir um Objeto de negócio a partir dele.
É exatamente o que fazemos no método construirVeiculoPorCursor, da classe VeiculoDAO. Recebemos um cursor como resultado de uma consulta na tabela veiculo e construímos um objeto Veículo a partir dele.

Por sua vez, o método execSQL também recebe como paramêtro uma String que representará uma ação na base de dados. No entanto, não retornará valor algum. Isso implica que este método não é ideal para realizar consultas e sim ações tais como Insert ou Update.

Ou seja, se os métodos insert, update ou delete não te agradaram, você poderá utilizar esse método para escrever o você mesmo o SQL que deseja executar.

OBS: A classe DataBaseHelper faz uso deste método para criar nossas tabelas.

Por fim, não podemos esquecer do método close.
Este método, deve ser chamado quando o banco de dados não for mais utilizado. E serve para liberar a memória destinada ao mesmo.

Agora que temos a classe Veiculo que representa os dados que serão armazenados, e a classe VeiculoDAO que sabe como armazenar um Veiculo. Nos resta apenas testar toda essa estrutura.

Para isso, vamos criar um projeto de Teste do nosso aplicativo.
Não ha mistério na criação de um projeto de Test no eclipse. Vamos aos passos:

No menu superior pressione o item File em seguida clique em New e posteriormente Other.
Um Wizard aparecerá, procure e selecione a opção Android Test Project e clique no botão Next.
Aparecerá uma tela onde você deve informar o nome do projeto, iremos chama-lo de VeiculoTest após o preenchimento do seu nome pressione Next novamente.
Em seguida aparecerá uma lista de todos os projetos disponiveis no Workspace do seu eclipse.
Selecione o projeto que deseja testar (no nosso caso o Cadastro de Veiculo) e pressione o botão Finish.

Agora vamos criar a classe TestCRUDVeiculo dentro desse projeto. Essa classe irá extender funcionalidades da classe AndroidTestCase e terá um método que chamaremos de testCRUD();
Este método testara todas as principais funcionalidades da nossa classe VeiculoDAO (Salvar, delatar, alterar e recuperar).

É importante ressaltar que o ideal é que seja criado um método para testar cada ação da classe VeiculoDAO. No entanto creio que desse modo fica mais fácil para realizar uma demonstração. Futuramente neste mesmo artigo melhoraremos nosso código de teste.

Confira a classe de teste logo abaixo.

public class TestCRUDVeiculo extends AndroidTestCase {

	public void testCRUD() {
		
		Veiculo veiculo = new Veiculo(0, "Fiat", "Palio", "1666");
		VeiculoDAO veiculoDAO =  VeiculoDAO.getInstance(getContext());
		
		veiculoDAO.salvar(veiculo);
		
		List<Veiculo> veiculosNaBase = veiculoDAO.recuperarTodos();
		assertFalse(veiculosNaBase.isEmpty());
		
		Veiculo veiculoRecuperado = veiculosNaBase.get(0);
		veiculoRecuperado.setModelo("Stilo");
		
		veiculoDAO.editar(veiculoRecuperado);
		
		Veiculo veiculoEditado = veiculoDAO.recuperarTodos().get(0);
		
		assertSame(veiculoRecuperado.getId(), veiculoEditado.getId());
		assertNotSame(veiculo.getModelo(), veiculoEditado.getModelo());
		
		veiculoDAO.deletar(veiculoEditado);
		
		assertTrue(veiculoDAO.recuperarTodos().isEmpty());
		
		veiculoDAO.fecharConexao();
		
	}

}

Após a construção do projeto, clique com o botão direito do mouse sobre ele e selecione a opção Run Android Junit Test.

E pronto, o teste será executado.

E se tivermos que adicionar uma segunda entidade!?

Por menor que seja a aplicação é raro encontrar um cenário onde o aplicativo terá que persistir somente uma entidade de negócio, ou seja, teria apenas uma tabela no banco de dados.

Nesse nosso aplicativo já aprendemos como persistir uma entidade de negócio, o Veículo. Agora vamos adicionar uma segunda entidade para deixar o exemplo mais completo, esta entidade chamaremos de Pessoa, uma vez que todo Veículo esta vinculado a uma Pessoa.

O código da nossa entidade Pessoa ficará assim:

public class Pessoa implements EntidadePersistivel {
	
	private int id;
	private String nome;
	private int idade;
	
	public Pessoa() {
	}
	 
	public Pessoa(int id, String nome, int idade) {
		super();
		this.id = id;
		this.nome = nome;
		this.idade = idade;
	}
 
	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 int getIdade() {
		return idade;
	}

	public void setIdade(int idade) {
		this.idade = idade;
	}

}

Observando o código podemos constatar que se trata de um POJO assim como a nossa entidade Veiculo, possuindo apenas três atributos ID, Idade, e nome. No entanto podemos reparar em uma mudança, a classe Pessoa esta implementando a interface EntidadePersistivel o que seria isso!?

Antes de persistirmos a entidade Pessoa, devemos preparar a arquitetura do sistema para suportar a persistência múltiplas entidades. A interface EntidadePersistivel é uma dessas mudanças.

Fazemos isso para evitar a duplicação de código. Se pegarmos o código do VeiculoDAO copiarmos e colarmos em uma nova classe, mudando o nome pra PessoaDAO e persistindo um objeto do tipo Pessoa ao invés de Veiculo nossa mudança estaria praticamente finalizada não é mesmo?

Mas muito código duplicado estaria presente no sistema e não conseguiríamos compartilhar funcionalidades entre os DAO’s.

Daí a necessidade de alguns ajustes na nossa camada de persistência, a primeira delas é a inserção da interface EntidadePersistivel vejamos o código desta interface logo abaixo:

public interface EntidadePersistivel {
	
	public int getId();
	public void setId(int id);

}

Esta interface obriga a implementação dos métodos setId e getId. O que na prática implica na criação de um atributo ID.
Todas as entidades que serão persistidas no nosso sistema (Veiculo e Pessoa) deverão implementar esta interface.

Mais a frente neste artigo veremos essa interface sendo utilizada na prática.

Criação do DAOBasico

A mudança mais crucial que fizemos foi criar a classe abstrata que chamamos de DAOBasico.

Sabemos que tanto o DAO de Veiculo quanto o DAO de Pessoa, devem saber como salvar, deletar, editar e recuperar objetos de sua respectiva entidade.

A única coisa que muda é qual entidade ela salvará, ou seja, os dados que ela irá manipular, uma será a entidade Pessoa e a outra a entidade Veículo.

O DAOBasico usa o conceito de Generics, isso implica que ele esperará um TIPO quando alguma classe for herdar funcionalidades dele.
Com essa estratégia poderemos criar métodos genéricos como os abaixo:

public void salvar(T entidade);

public void deletar(T entidade);

public void editar(T entidade);

public List<T> recuperarTudo(String consulta);

Onde o T será substituído pela entidade alvo seja ela Veiculo ou Pessoa.
No caso do DAOBasico colocamos uma restrição no nosso tipo genérico. Definimos que O tipo (T) seria qualquer classe que implemente a interface EntidadePersistivel.

Fazemos isso acrescentando o seguinte código após a declaração do nome da classe:

<T extends EntidadePersistivel>

Vejamos o código completo do nosso DAOBasico para um melhor entendimento:

public abstract class DAOBasico<T extends EntidadePersistivel> {

	protected SQLiteDatabase dataBase = null;

	public DAOBasico(Context context) {
		DataBaseHelper persistenceHelper = DataBaseHelper.getInstance(context);
		dataBase = persistenceHelper.getWritableDatabase();
	}

	public abstract String getNomeColunaPrimaryKey();
	public abstract String getNomeTabela();

	public abstract ContentValues entidadeParacontentValues(T entidade);
	public abstract T contentValuesParaEntidade(ContentValues contentValues); 


	public void salvar(T entidade) {
		ContentValues values = entidadeParacontentValues(entidade);
		dataBase.insert(getNomeTabela(), null, values);
	}

	public void deletar(T t) {

		String[] valoresParaSubstituir = {
				String.valueOf(t.getId())
		};

		dataBase.delete(getNomeTabela(), getNomeColunaPrimaryKey() + " =  ?", valoresParaSubstituir);
	}

	public void deletarTodos() {
		dataBase.execSQL("DELETE FROM " + getNomeTabela());
	}

	public void editar(T t) {
		ContentValues valores = entidadeParacontentValues(t);

		String[] valoresParaSubstituir = {
				String.valueOf(t.getId())
		};

		dataBase.update(getNomeTabela(), valores, getNomeColunaPrimaryKey() + " = ?", valoresParaSubstituir);
	}

	public List<T> recuperarTodos() {
		String queryReturnAll = "SELECT * FROM " + getNomeTabela();
		List<T> result = recuperarPorQuery(queryReturnAll);

		return result; 

	} 

	public T recuperarPorID(int id) {
		String queryOne = "SELECT * FROM " + getNomeTabela() + " where " + getNomeColunaPrimaryKey() + " = " + id;
		List<T> result = recuperarPorQuery(queryOne);
		if(result.isEmpty()) {
			return null;
		} else {
			return result.get(0);	
		}
	}

	public List<T> recuperarPorQuery(String query) {

		Cursor cursor = dataBase.rawQuery(query, null);

		List<T> result = new ArrayList<T>();
		if (cursor.moveToFirst()) {
			do { 
				ContentValues contentValues = new ContentValues();
				DatabaseUtils.cursorRowToContentValues(cursor, contentValues);
				T t = contentValuesParaEntidade(contentValues);
				result.add(t);
			} while (cursor.moveToNext());
		}
		return result; 

	}

	public void fecharConexao() {
		if(dataBase != null && dataBase.isOpen())
			dataBase.close(); 
	}

}

Veja que quem herdar desta classe já terá implementados os métodos salvar, editar, deletar e recuperarTodos.

Porém será obrigado a implementar os métodos abstratos:

public abstract String getNomeColunaPrimaryKey(); : Apesar das colunas PrimaryKey tanto do Veiculo quanto da entidade Pessoa se chamarem id. Pode ser que alguma entidade no futuro tenha um nome diferente para a sua coluna Primary Key e por isso esse método existe.

public abstract String getNomeTabela(); : Este método é pedido como parâmetro nos métodos de insert, update, delete, e query. E é uma das informações que variam entre os DAO’s, o DAO da entidade Pessoa possui um nome de tabela diferente do DAO da entidade Veículo.

public abstract ContentValues entidadeParacontentValues(T entidade); : Este método é utilizado na hora de salvar e editar um registro. Veja que ele recebe como parâmetro uma entidade e retorna um ContentValues. Conforme já foi falado, o ContentValues é uma estrutura de chave e valor, onde neste caso a chave representa a coluna da tabela e o valor representa o valor que será inserido nessa coluna.

Exemplo de utilização:
placa:gxw1666.
placa seria a coluna da tabela veículo
gxw1666 é o valor que vai ser armazenado nessa coluna.

public abstract T contentValuesParaEntidade(ContentValues contentValues); : Este método é utilizado na hora de recuperar dados, e é o inverso do método entidadeParacontentValues que explicamos mais acima.
Neste caso, receberemos como parâmetro um ContentValues e devemos transforma-lo em uma entidade.

Os métodos acima representam as únicas informações que realmente podem variar de uma implementacão de DAO para a outra, por isso são abstratos, cada implementação de DAO deve informar as suas particularidades.

Vejamos então como ficaram os nossos novos DAO’s que agora vão herdar funcionalidades do DAOBasico.

public class PessoaDAO  extends DAOBasico<Pessoa> {

	private static final String NOME_TABELA = "PESSOA";
	public static final String SCRIPT_CRIACAO_TABELA = "CREATE TABLE  PESSOA ( id INTEGER PRIMARY KEY autoincrement, nome TEXT,idade INTEGER)";
	public static final String SCRIPT_DELECAO_TABELA =  "DROP TABLE IF EXISTS " + NOME_TABELA;

	private static final String COLUNA_ID = "id";
	private static final String COLUMA_NOME = "nome";
	private static final String COLUNA_IDADE = "idade";

	public PessoaDAO(Context context) {
		super(context); 
	}

	@Override
	public String getNomeColunaPrimaryKey() {
		return COLUNA_ID;
	}

	@Override
	public String getNomeTabela() {
		return NOME_TABELA;
	}

	public ContentValues entidadeParacontentValues(Pessoa pessoa) {
		ContentValues contentValues = new ContentValues();
                 if(pessoa.getId() > 0) {
		   contentValues.put(COLUNA_ID, pessoa.getId());
                }
		contentValues.put(COLUNA_IDADE, pessoa.getIdade());
		contentValues.put(COLUMA_NOME, pessoa.getNome());
		return contentValues;
	}

	@Override
	public Pessoa contentValuesParaEntidade(ContentValues contentValues) {
		Pessoa pessoa = new Pessoa();
		pessoa.setId(contentValues.getAsInteger(COLUNA_ID));
		pessoa.setIdade(contentValues.getAsInteger(COLUNA_IDADE));
		pessoa.setNome(contentValues.getAsString(COLUMA_NOME));
		return pessoa;
	}

}

Repare que logo no início da classe usamos a palavra reservada extends para declarar a herança da classe DAOBasico. Logo em seguida passamos o tipo que iremos manipular no caso acima a entidade Pessoa.

OBS: Se você tiver dúvidas em utilizar a estrutura Generics do Java, talvez este artigo possa te ajudar.
http://www.tiexpert.net/programacao/java/generics.php
é bem importante saber essa estrutura, pois é utilizada amplamente.

Os métodos salvar,editar,deletar e recuperarTodos, estão devidamente implementados na classe mãe DAOBasico. Tivemos apenas que implementar os métodos abstratos que foram explicados acima.

Pare um segundo para contemplar tudo que foi feito.
Veja como a nossa estrutura ficou bem mais robusta e flexível do que a anterior criada para persistir somente uma entidade.
Se futuramente tivermos que acrescentar uma terceira entidade no nosso sistema, tal como Imovel, você já sabe os passos que deve fazer para persistir essa nova entidade?

Basta criarmos a entidade Imovel com o seus atributos e fazer com que ela implemente a interface EntidadePersistivel, posteriormente deve ser criado a classe ImovelDAO fazendo ela herdar da classe DAOBasico.
E pronto.

Para concluir vamos ver como ficou o novo DAO da entidade Veiculo:

public class VeiculoDAO extends DAOBasico<Veiculo> {

	public static final String NOME_TABELA = "Veiculo";
	public static final String COLUNA_ID = "id";
	public static final String COLUNA_ID_PESSOA = "id_pessoa";
	public static final String COLUNA_MARCA = "marca";
	public static final String COLUNA_MODELO = "modelo";
	public static final String COLUNA_PLACA = "placa";


	public static final String SCRIPT_CRIACAO_TABELA_VEICULOS = "CREATE TABLE " + NOME_TABELA + "("
			+ COLUNA_ID + " INTEGER PRIMARY KEY autoincrement,"
			+ COLUNA_ID_PESSOA + " INTEGER,"
			+ COLUNA_MARCA + " TEXT," 
			+ COLUNA_PLACA + " TEXT,"
			+ COLUNA_MODELO + " TEXT" 
			+ ")";

	public static final String SCRIPT_DELECAO_TABELA =  "DROP TABLE IF EXISTS " + NOME_TABELA;

	private static VeiculoDAO instance;

	public static VeiculoDAO getInstance(Context context) {
		if(instance == null)
			instance = new VeiculoDAO(context);
		return instance;
	}

	public VeiculoDAO(Context context) {
		super(context);
	}

	@Override
	public String getNomeTabela() {  
		return NOME_TABELA;
	}

	@Override
	public String getNomeColunaPrimaryKey() {
		return COLUNA_ID;
	}

	public ContentValues entidadeParacontentValues(Veiculo veiculo) {
		ContentValues values = new ContentValues();
		if(veiculo.getId() > 0) {
			values.put(COLUNA_ID, veiculo.getId());
		}
		values.put(COLUNA_ID_PESSOA, veiculo.getIdPessoa());
		values.put(COLUNA_MARCA, veiculo.getMarca());
		values.put(COLUNA_MODELO, veiculo.getModelo());
		values.put(COLUNA_PLACA, veiculo.getPlaca());

		return values;
	}


	@Override
	public Veiculo contentValuesParaEntidade(ContentValues contentValues) {
		Veiculo veiculo = new Veiculo();
		veiculo.setId(contentValues.getAsInteger(COLUNA_ID));
		veiculo.setIdPessoa(contentValues.getAsInteger(COLUNA_ID_PESSOA));
		veiculo.setMarca(contentValues.getAsString(COLUNA_MARCA));
		veiculo.setModelo(contentValues.getAsString(COLUNA_MODELO));
		veiculo.setPlaca(contentValues.getAsString(COLUNA_PLACA));
		return veiculo;
	}
}

Outra pequena mudança que fizemos foi colocar, os scripts de criação e deleção de uma determinada tabela em seus respectivos DAO’s. Anteriormente esses scripts ficavam na classe DataBaseHelper onde eles são utilizados, só que imaginando um sistema que contenha 10 entidades, imagina o tamanho que ficaria a classe DataBaseHelper e o quão difícil seria dar manutenção na mesma.
Por isso a mudança.

Por falar nisso vamos ver como ficou o novo código da classe DataBaseHelper:

public class DataBaseHelper extends SQLiteOpenHelper {
 

	private static final String NOME_BANCO_DADOS = "CadastroVeiculo";
	private static final int VERSAO_BANCO_DADOS = 1;

	private static DataBaseHelper instance;

	public static DataBaseHelper getInstance(Context context) {
		if(instance == null)
			instance = new DataBaseHelper(context);

		return instance;
	}

	public DataBaseHelper(Context context) {
		super(context, NOME_BANCO_DADOS, null, VERSAO_BANCO_DADOS);
	}

	@Override
	public void onCreate(SQLiteDatabase db) {
		db.execSQL(PessoaDAO.SCRIPT_CRIACAO_TABELA);
		db.execSQL(VeiculoDAO.SCRIPT_CRIACAO_TABELA_VEICULOS);
		Log.i("DATABASE", "CRIANDO TABELA");
	}

	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
		Log.i("DATABASE", "ATUALIZANDO TABELA");
		db.execSQL(VeiculoDAO.SCRIPT_DELECAO_TABELA);
		db.execSQL(PessoaDAO.SCRIPT_DELECAO_TABELA);
		onCreate(db);
	}

}

Também tivemos uma mudança na entidade Veículo:

public class Veiculo implements EntidadePersistivel {
 
    private int id;
    private int idPessoa;
    private String marca;
    private String modelo;
    private String placa;
 
    public Veiculo() {
    }
     
    public Veiculo(int id, int idPessoa, String marca, String modelo, String placa) {
        super();
        this.id = id;
        this.marca = marca;
        this.modelo = modelo;
        this.placa = placa;
        this.idPessoa = idPessoa;
    }
 
 
    public int getIdPessoa() {
		return idPessoa;
	}
    
    public void setIdPessoa(int idPessoa) {
		this.idPessoa = idPessoa;
	}
 
    public String getMarca() {
        return marca;
    }
 
    public void setMarca(String marca) {
        this.marca = marca;
    }
 
    public String getModelo() {
        return modelo;
    }
 
    public void setModelo(String modelo) {
        this.modelo = modelo;
    }
 
    public String getPlaca() {
        return placa;
    }
 
    public void setPlaca(String placa) {
        this.placa = placa;
    }
     
    public int getId() {
        return id;
    }
     
    public void setId(int id) {
        this.id = id;
    }
     
    @Override
    public String toString() {
        return placa + " " +  modelo + " " + marca;
    }
} 

Foi criado um novo atributo nesta entidade, o chamamos de idPessoa do tipo int.

É neste atributo ficará armazenado o ID de uma entidade Pessoa. Assim poderemos recuperarmos sempre que necessário uma pessoa Passando o idPessoa presente no veículo.

Vamos ver esse cenário funcionando e testar tudo que foi feito com os nossos testes de unidade.

Logo abaixo segue o código da classe que irá testar a classe PessoaDAO, o nome dela é PessoaDAOTest.

public class PessoaDAOTest extends AndroidTestCase {

	public void testSalvar() {
		PessoaDAO pessoaDAO = new PessoaDAO(getContext());
		
		int primeiroSize = pessoaDAO.recuperarTodos().size();
		
		Pessoa pessoa = criarPessoaExemplo();
		pessoaDAO.salvar(pessoa);
		
		assertTrue(pessoaDAO.recuperarTodos().size() > primeiroSize);
		pessoaDAO.fecharConexao();
	}
	
	
	public void testDeletar() {
		testSalvar();
		
		PessoaDAO pessoaDAO = new PessoaDAO(getContext());
		
		List<Pessoa> todasPessoas = pessoaDAO.recuperarTodos();
		assertNotNull(todasPessoas);
		assertFalse(todasPessoas.isEmpty());
		
		Pessoa pessoaRecuperada  = todasPessoas.get(0);
		assertNotNull(pessoaRecuperada);
		
		int primeiroSize = pessoaDAO.recuperarTodos().size();
		
		pessoaDAO.deletar(pessoaRecuperada);
		
		assertTrue(pessoaDAO.recuperarTodos().size() < primeiroSize);
		pessoaDAO.fecharConexao();
	}
	
	public void testRecuperar() {
		PessoaDAO pessoaDAO = new PessoaDAO(getContext());
		pessoaDAO.deletarTodos();
		
		Pessoa pessoa = criarPessoaExemplo();
		pessoaDAO.salvar(pessoa);
		
		List<Pessoa> todasPessoasRecuperadas = pessoaDAO.recuperarTodos();
		assertTrue(todasPessoasRecuperadas.size()  == 1);
		
		Pessoa pessoaRecuperada = todasPessoasRecuperadas.get(0);
		Pessoa pessoaCriada = criarPessoaExemplo();
		
		assertEquals(pessoaCriada.getNome(), pessoaRecuperada.getNome());
		assertEquals(pessoaCriada.getIdade(), pessoaRecuperada.getIdade());
		pessoaDAO.fecharConexao();
	}
	
	public Pessoa criarPessoaExemplo() {
		Pessoa pessoa = new Pessoa(0,"Leonardo",24);
		return pessoa;
	}

}

Veja que existe um método de teste para cada método da nossa classe PessoaDAO, fique a vontade pra criar outros métodos de teste achar necessário.

Agora só falta os testes da classe VeiculoDAO, para seguir o padrão chamamos a classe de teste de VeiculoDAOTest.

public class VeiculoDAOTest extends AndroidTestCase {
	
	public void testSalvar() {
		VeiculoDAO veiculoDAO = new VeiculoDAO(getContext());
		
		int primeiroSize = veiculoDAO.recuperarTodos().size();
		
		Veiculo veiculo = criarVeiculoExemplo(0);
		veiculoDAO.salvar(veiculo);
		
		assertTrue(veiculoDAO.recuperarTodos().size() > primeiroSize);
		veiculoDAO.fecharConexao();
	}
	
	
	public void testDeletar() {
		testSalvar();
		
		VeiculoDAO veiculoDAO = new VeiculoDAO(getContext());
		
		List<Veiculo> todasVeiculos = veiculoDAO.recuperarTodos();
		assertNotNull(todasVeiculos);
		assertFalse(todasVeiculos.isEmpty());
		
		Veiculo veiculoRecuperada  = todasVeiculos.get(0);
		assertNotNull(veiculoRecuperada);
		
		int primeiroSize = veiculoDAO.recuperarTodos().size();
		
		veiculoDAO.deletar(veiculoRecuperada);
		
		assertTrue(veiculoDAO.recuperarTodos().size() < primeiroSize);
		veiculoDAO.fecharConexao();
	}
	
	public void testRecuperar() {
		PessoaDAO pessoaDAO = new PessoaDAO(getContext());
		pessoaDAO.salvar(criarPessoaExemplo());
		Pessoa pessoa = pessoaDAO.recuperarTodos().get(0);
		
		VeiculoDAO veiculoDAO = new VeiculoDAO(getContext());
		veiculoDAO.deletarTodos();
		
		Veiculo veiculo = criarVeiculoExemplo(pessoa.getId());
		veiculoDAO.salvar(veiculo);
		
		List<Veiculo> todasVeiculosRecuperadas = veiculoDAO.recuperarTodos();
		assertTrue(todasVeiculosRecuperadas.size()  == 1);
		
		Veiculo veiculoRecuperada = todasVeiculosRecuperadas.get(0);
		
		Pessoa pessoaRecuperada = pessoaDAO.recuperarPorID(veiculoRecuperada.getIdPessoa());
	    Pessoa pessoaCriada = criarPessoaExemplo();
		
		assertEquals(pessoaCriada.getNome(), pessoaRecuperada.getNome());
		assertEquals(pessoaCriada.getIdade(), pessoaRecuperada.getIdade());
		
		Veiculo veiculoCriada = criarVeiculoExemplo(pessoa.getId());
		
		assertEquals(veiculoCriada.getModelo(), veiculoRecuperada.getModelo());
		assertEquals(veiculoCriada.getMarca(), veiculoRecuperada.getMarca());
		assertEquals(veiculoCriada.getIdPessoa(), veiculoRecuperada.getIdPessoa());
		veiculoDAO.fecharConexao();
	}
	
	public Veiculo criarVeiculoExemplo(int idPessoa) {
		Veiculo veiculo = new Veiculo(0, idPessoa, "Fiat", "Palio", "MNR4167");
		return veiculo;
	}
	
	public Pessoa criarPessoaExemplo() {
		Pessoa pessoa = new Pessoa(0,"Leonardo",24);
		return pessoa;
	}

}

Esta classe ficou mais extensa do que a classe PessoaDAO. Pois tivemos que estar o caso onde salvamos um Veiculo com um id Pessoa vinculado.
Depois recuperamos esse Veiculo da base e através do campo idPessoa recuperamos também uma Pessoa da base.

Todos os testes listados aqui simulam situações que iriam acontecer na mão de um cliente utilizando o seu aplicativo. Quanto mais testes de unidade, maior a qualidade do seu software, maior a confiança que um desenvolvedor tem de realizar manutenções nesse software e menor é a quantidade de horas gasta para achar e corrigir bugs.

A imagem abaixo mostra todos os testes exibidos aqui executados com sucesso.

Testes de unidade executados no eclipse.

Agora que temos uma classe de teste e o nosso projeto esta bem estruturado, por que não finalizamos ele completamente criando uma interface gráfica para que ele fique bem funcional.
Representando uma tela de cadastro e uma lista de itens para que o aplicativo “tome vida” de vez. Bom, essa tarefa eu deixo como desafio para o leitor. =]

Observação final – Você não precisa fazer tudo na mão

Hoje em dia existem diversos frameworks de persistência que utilizam o SQLite internamente.
Como por exemplo o ORMLite e o GreenDAO ambos visam encapsular o SQLite e oferecer funções simples de recuperação, deleção, edição e persistência dos dados. Experimente-os e veja se eles conseguem atender as suas necessidades.

Até o próximo post!