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á!