sábado, 21 de março de 2009

Tagged under: , , ,

Persistência orientada a objetos com db4o (parte 2)

Continuando o post anterior, vamos agora ver mais funcionalidades do db4o.

Para recuperar os objetos, o db4o implementou três sistemas diferentes de consulta: Query By Example (QBE), Native Queries (NQ), e a SODA Query API (SODA). Vamos começar com a QBE pois é mais simples de entender.

Quando usar a QBE para recuperar os objetos no db4o, você deve criar um "protótipo" de seu objeto para usar como exemplo do que deve ser recuperado. A instância de ObjectContainer recuperará os objetos que se pareçam com o protótipo informado.

Crie uma classe chamada Passo2.java conforme o código abaixo:


package javabahia.app;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import javabahia.entidade.Contrato;

/**
* Segundo passo de execução do teste com o db4o.
* @author Alexandre
*/

public class Passo2 {

public static void main(String[] args) {
// abrindo o arquivo db4o
ObjectContainer db = Db4o.openFile("javabahia.dbo");

try {
// criando o prototipo de exemplo
Contrato proto = new Contrato(1000, null, null, null, null);

// invocando a consulta QBE
ObjectSet<Contrato> result = db.queryByExample(proto);

// listando os objetos encontrados
System.out.println(result.size() + " objetos foram encontrados.");
for (Contrato ctr : result) {
System.out.println("Contrato número " + ctr.getNumero());
}

} finally {
// fechando o arquivo db4o
db.close();
}
}
}


No código acima, recuperamos todos os objetos da classe Contrato que possuem número igual a 1000. Como só inserimos um objeto no último post deste blog, o resultado esperado ao executar essa classe deve ser:

1 objetos foram encontrados.
Contrato número 1000


Atualizar os objetos no db4o é tão fácil quanto inseri-los; basta chamar store() novamente. Crie uma classe chamada Passo3.java conforme o código abaixo para observar isso.


package javabahia.app;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import javabahia.entidade.Contrato;
import javabahia.entidade.Empresa;

/**
* Terceiro passo de execução do teste com o db4o.
* @author Alexandre
*/

public class Passo3 {

public static void main(String[] args) {
// abrindo o arquivo db4o
ObjectContainer db = Db4o.openFile("javabahia.dbo");

try {
// criando o prototipo de exemplo para recuperar a empresa
Empresa protoEmp = new Empresa("11000111000100", null, null);

// recuperando a empresa
ObjectSet<Empresa> empresas = db.queryByExample(protoEmp);
Empresa emp = empresas.next();

// atualizando os dados da empresa
emp.setNome("ACME S/A");
emp.setEmail("faleconosco@acme.com.br");

// armazenando a empresa
db.store(emp);

// invocando a consulta QBE para recuperar todos os contratos
ObjectSet<Contrato> contratos = db.queryByExample(Contrato.class);

// listando os objetos encontrados
System.out.println(contratos.size() + " objetos foram encontrados.");
for (Contrato ctr : contratos) {
System.out.println("Contrato número " + ctr.getNumero() + ", com a empresa " + ctr.getContratada().getEmpresa().getNome());
}

} finally {
// fechando o arquivo db4o
db.close();
}
}
}


No código acima, criamos um protótipo para recuperar a empresa e depois atualizamos os dados dela (nome e e-mail) no banco de dados db4o. Em seguida, recuperamos todos os contratos de uma forma diferente - bastando passar a classe de exemplo. É outra maneira de usar a QBE no db4o. O resultado esperado deve ser esse:

1 objetos foram encontrados.
Contrato número 1000, com a empresa ACME S/A


Por fim, para excluir um objeto do db4o invocamos o método delete() da instância do ObjectContainer. Crie uma classe chamada Passo4.java conforme o código abaixo:


package javabahia.app;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import javabahia.entidade.Usuario;

/**
* Quarto passo de execução do teste com o db4o.
* @author Alexandre
*/

public class Passo4 {

public static void main(String[] args) {
// abrindo o arquivo db4o
ObjectContainer db = Db4o.openFile("javabahia.dbo");

try {
// invocando a consulta QBE para recuperar todos os usuários
ObjectSet<Usuario> usuarios = db.queryByExample(Usuario.class);

// deletando todos os usuários
for (Usuario usu : usuarios) {
db.delete(usu);
}

} finally {
// fechando o arquivo db4o
db.close();
}
}
}


Nós criamos, recuperamos, atualizamos e excluimos objetos com apenas algumas linhas de código. Como podemos perceber, usar o db4o é muito mais natural para a desenvolvimento orientado a objetos do que ficar criando consultas SQL e usando a API JDBC para suportar um banco de dados relacional.

Porém, o que fizemos até agora é o trivial mais básico que pode existir nesse framework. O db4o é mais poderoso do que isso que foi mostrado. Em outros posts futuros mostrarei como fazer atualização e exclusão em cascata, como usar os outros métodos de consulta e como usar o db4o remotamente. Até lá!

3 comentários:

Anônimo disse...

Oi.
Que versão do Db4o você usa? Estou usando a 7.4.68 e não consigar dar um build (consigo executar, mas não consigo dar o build) quando uso ObjectSet< Item>, somente quando uso ObjectSet itens.

Alexandre M. Lima disse...

Oi! Eu usei a versão 7.4.57 stable.

Jean Bruno disse...

Olha rapaz...
Por favor, não demore não...
Gostei muito mais muito mesmo do seu post, e estou ansioso pelo próximo.
Trabalho com Java, e comecei a estudar Hibernate + MySQL, mas com a descoberta do db4objects, não vou nem me esforçar no Hibernate, que um banco de dados OO.
Agradeço muito sua atenção em estar escrevendo estes materiais de apoios que só enriquecem nosso conhecimento.
Muito obrigado mesmo.

Jean Bruno

brunopib@gmail.com