Guia para objetos de dados Java

1. Visão geral

O Java Data Objects é uma API projetada para persistir dados orientados a objetos em qualquer banco de dados e fornece uma linguagem de consulta amigável usando a sintaxe Java.

Neste artigo, veremos como usar a API JDO para persistir nossos objetos em um banco de dados.

2. Dependências e configuração do Maven

Vamos usar a API DataNucleus JDO atualizada e oferece suporte completo para a API JDO 3.2.

Vamos adicionar a seguinte dependência ao nosso arquivopom.xml:


    org.datanucleus
    javax.jdo
    3.2.0-m6


    org.datanucleus
    datanucleus-core
    5.1.0-m2


    org.datanucleus
    datanucleus-api-jdo
    5.1.0-m2


    org.datanucleus
    datanucleus-rdbms
    5.1.0-m2


    org.datanucleus
    datanucleus-xml
    5.0.0-release

As versões mais recentes das dependências podem ser encontradas aqui:javax.jdo,datanucleus-core,datanucleus-api-jdo,datanucleus-rdbmsedatanucleus-xml.

3. Modelo

Vamos salvar nossos dados em um banco de dados e, antes que possamos fazer isso, precisamos criar uma classe que será usada pelo JDO para armazenar nossos dados.

Para fazer isso, precisamos criar uma classe com algumas propriedades e anotá-la com o@PersistentCapable:

@PersistenceCapable
public class Product {

    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.INCREMENT)
    long id;

    String name;
    Double price = 0.0;

    // standard constructors, getters, setters
}

Também anotamos nossa chave primária e a estratégia escolhida.

Depois de criar nosso objeto, precisamos executar o aprimorador para gerar o bytecode exigido pelo JDO. Usando o Maven, podemos executar este comando:

mvn datanucleus:enhance

Esta etapa é obrigatória. Caso contrário, obteremos um erro de tempo de compilação que a classe não foi aprimorada.

Claro, é possível fazer isso automaticamente durante uma compilação do Maven:


    org.datanucleus
    datanucleus-maven-plugin
    5.0.2
    
        JDO
        ${basedir}/datanucleus.properties
        ${basedir}/log4j.properties
        true
    
    
        
            process-classes
            
                enhance

A última versão do plugin pode ser encontrada aqui:datanucleus-maven-plugin

4. Objetos Persistentes

Temos acesso ao banco de dados usando uma fábrica JDO que nos fornece o gerenciador de transações encarregado de realizar as transações:

PersistenceManagerFactory pmf = new JDOPersistenceManagerFactory(pumd, null);
PersistenceManager pm = pmf.getPersistenceManager();

As transações são usadas para permitir uma reversão em caso de erro:

Transaction tx = pm.currentTransaction();

Fazemos nossas transações dentro de um blocotry/catch:

Product product = new Product("Tablet", 80.0);
pm.makePersistent(product);

Em nosso blocofinally, definimos essas operações para serem feitas em caso de falha.

Se por algum motivo a transação não puder ser concluída, fazemos um rollback e também fechamos a conexão com o banco de dados compm.close():

finally {
    if (tx.isActive()) {
        tx.rollback();
    }
    pm.close();
}

Para conectar nosso programa ao banco de dados, precisamos criar umpersistence-unit em tempo de execução para especificar as classes persistentes, o tipo de banco de dados e os parâmetros de conexão:

PersistenceUnitMetaData pumd = new PersistenceUnitMetaData(
  "dynamic-unit", "RESOURCE_LOCAL", null);
pumd.addClassName("com.example.jdo.Product");
pumd.setExcludeUnlistedClasses();
pumd.addProperty("javax.jdo.option.ConnectionDriverName", "org.h2.Driver");
pumd
  .addProperty("javax.jdo.option.ConnectionURL", "jdbc:h2:mem:mypersistence");
pumd.addProperty("javax.jdo.option.ConnectionUserName", "sa");
pumd.addProperty("javax.jdo.option.ConnectionPassword", "");
pumd.addProperty("datanucleus.autoCreateSchema", "true");

5. Lendo Objetos

Para ler dados de nosso banco de dados dentro de nosso bloco de transações, criamos uma consulta. Em seguida, armazenamos esses itens em uma coleção JavaList, que manterá uma cópia na memória das informações do armazenamento persistente.

O gerenciador de persistência nos dá acesso à interface de consulta que nos permite interagir com o banco de dados:

Query q = pm.newQuery(
  "SELECT FROM " + Product.class.getName() + " WHERE price < 1");
List products = (List) q.execute();
Iterator iter = products.iterator();
while (iter.hasNext()) {
    Product p = iter.next();
    // show the product information
}

6. Atualizando objetos

Para atualizar objetos no banco de dados, precisamos encontrar os objetos que queremos atualizar usando uma consulta, depois atualizamos os resultados da consulta e confirmamos a transação:

Query query = pm.newQuery(Product.class, "name == \"Phone\"");
Collection result = (Collection) query.execute();
Product product = (Product) result.iterator().next();
product.setName("Android Phone");

7. Excluindo Objetos

Semelhante ao procedimento de atualização, procuramos o objeto primeiro e depois o excluímos usando o gerenciador de persistência. Nessas situações, o JDO atualiza o armazenamento persistente:

Query query = pm.newQuery(Product.class, "name == \"Android Phone\"");
Collection result = (Collection) query.execute();
Product product = (Product) result.iterator().next();
pm.deletePersistent(product);

8. Armazenamento de dados XML

Usando o plug-in XML, podemos usar arquivos XML para manter nossos dados.

Especificamos nossoConnectionURL indicando que é um arquivo XML e especificando o nome do arquivo: __

pumdXML.addProperty("javax.jdo.option.ConnectionURL", "xml:file:myPersistence.xml");

Um armazenamento de dados XML não suporta a propriedade de incremento automático, portanto, precisamos criar outra classe:

@PersistenceCapable()
public class ProductXML {

    @XmlAttribute
    private long productNumber = 0;
    @PrimaryKey
    private String name = null;
    private Double price = 0.0;

    // standard getters and setters

A anotação@XmlAttribute indica que isso aparecerá no arquivo XML como um atributo do elemento.

Vamos criar e manter nosso produto:

ProductXML productXML = new ProductXML(0,"Tablet", 80.0);
pm.makePersistent(productXML);

Obtemos o produto armazenado no arquivo XML:


    Tablet
    80.0

8.1. Recuperar objetos do armazenamento de dados XML

Podemos recuperar nossos objetos do arquivo XML usando uma consulta:

Query q = pm.newQuery("SELECT FROM " + ProductXML.class.getName());
List products = (List) q.execute();

E então usamos o iterador para interagir com cada objeto.

9. Consultas JDO

JDOQL é uma linguagem de consulta baseada em objeto projetada para executar consultas usando objetos Java.

9.1. JDOQL declarativo

Usando a consulta declarativa, declaramos os parâmetros e os definimos usando Java, isso garante a segurança do tipo:

Query qDJDOQL = pm.newQuery(Product.class);
qDJDOQL.setFilter("name == 'Tablet' && price == price_value");
qDJDOQL.declareParameters("double price_value");
List resultsqDJDOQL = qDJDOQL.setParameters(80.0).executeList();

9.2. SQL

O JDO fornece um mecanismo para executar consultas SQL padrão:

Query query = pm.newQuery("javax.jdo.query.SQL", "SELECT * FROM PRODUCT");
query.setClass(Product.class);
List results = query.executeList();

Usamosjavax.jdo.query.SQL como um parâmetro para o objeto de consulta e o segundo parâmetro é o próprio SQL.

9.3. JPQL

O JDO também fornece um mecanismo para executar consultas JPA. Podemos usar a sintaxe completa da linguagem de consulta JPA:

Query q = pm.newQuery("JPQL",
  "SELECT p FROM " + Product.class.getName() + " p WHERE p.name = 'Laptop'");
List results = (List) q.execute();

10. Sumário

Neste tutorial, nós:

criou um aplicativo CRUD simples que usa JDO
salvou e recuperou nossos dados como XML
examinou mecanismos de consulta comuns

Como sempre, você pode encontrar o código no artigoover on Github.

TOC

Guia para objetos de dados Java