Novo componente para facilitar o seu trabalho com JPA. CONFIRA!

Assuntos Gerais
#1

Esses dias comecei a trabalhar com JPA! Pensei em escrever algo que pude-se facilitar o trabalho durante do desenvolvimento. Quem usa JPA em seus projetos, tem que criar um arquivo chamado persistence.xml que fica dentro src/META-INF/

Esse é um exemplo de persistence.xml.

<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
   <persistence-unit name="manager1" transaction-type="RESOURCE_LOCAL">
      <class>org.hibernate.ejb.test.Cat</class>
      <class>org.hibernate.ejb.test.Distributor</class>
      <class>org.hibernate.ejb.test.Item</class>
      <properties>
         <property name="javax.persistence.jdbc.driver" value="org.hsqldb.jdbcDriver"/>
         <property name="javax.persistence.jdbc.user" value="sa"/>
         <property name="javax.persistence.jdbc.password" value=""/>
         <property name="javax.persistence.jdbc.url" value="jdbc:hsqldb:."/>
         <property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect"/>
         <property name="hibernate.max_fetch_depth" value="3"/>
      </properties>
   </persistence-unit>
</persistence>

Por muitas vezes eu esquecia de registrar as classes de entidades que eu criava no arquivo persistence.xml. durante os testes, e só descobria quando geravam as exceptions.

Isso me motivou a escrever esse componente que agilizasse esse processo não precisar de registrar minhas classes de entidades e não mesmo saber que exista o persistence.xml deixando o trabalho pesado para o componente. Apesar de ser um esforço pequeno, porem é um esforço a menos e posso me preocupar mais com o negocio e me preocupar menos com persistence.xml e classes de entidades.

O componente ele funciona independente de implementação JPA. Podendo ser usado qualquer implementação. Seja ela Hibernate, apacheLink, TopLink. Etc.

Você pode baixa-lo em :
http://code.google.com/p/jpa-component/downloads/list

Os fontes também estão disponíveis, para que você também possa contribuir com boas idéias!.

Você também vai precisar XStream.
http://xstream.codehaus.org/download.html

Veja como é fácil utilizar o componente.

Após baixar o arquivo JPA-Component.jar e xstream-1.3.1.jar. Adicione ao classPath de seu projeto

Primeira coisa a se fazer após criar o projeto é verificar se dentro de src/ existe a pasta META-INF. Pois ela é obrigatória quando trabalhamos com JPA.

Dentro da pasta src/META-INF do seu projeto, você deve criar um arquivo chamado configuration.properties. Esse arquivo é responsável por armazenar as configuração da sua conexão. Veja um exemplo abaixo:

hibernate.connection.driver_class=org.postgresql.Driver
hibernate.connection.url=jdbc:postgresql://127.0.0.1:5432/venda/
hibernate.connection.username=postgres
hibernate.connection.password=123456
hibernate.transaction.factory_class=org.hibernate.transaction.JDBCTransactionFactory
hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
hibernate.current_session_context_class=thread
hibernate.show_sql=false
cache.provider_class=org.hibernate.cache.NoCacheProvider
connection.autocommit=false
hibernate.hbm2ddl.auto=update

etex.package.persistent=br.teste.pacote

Essas propriedades, são as do hibernate, caso você use outra implementação JPA. Somente verificar qual são as configuração que você necessita e adicionalas ao arquivo.

Para saber mais sobre as configuração do hibernate segue o link :
http://docs.jboss.org/hibernate/stable/entitymanager/reference/en/html/configuration.html

Existe uma propriedade obrigatória.

Essa propriedade pelo componente para saber apartir de onde ele deve varrer seu projeto para capturar as classes persistentes.

Após feito isso é só começar a utilizar o componente. Veja um exemplo de código abaixo.

package br.teste.pacote;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.servlet.ServletContext;

import br.com.jpa.component.ConfigPersistence;
import br.com.jpa.component.Configuration;

import com.thoughtworks.xstream.XStream;

public class TestJPA {

	public static void main(String[] args) {
		
		Configuration configuration = ConfigPersistence.getInstanceConfiguration();
		
		EntityManagerFactory factory = configuration.createEntityManagerFactory();

		EntityManager em = factory.createEntityManager();
		
		Query query = em.createQuery("SELECT e FROM Cliente e ");
		List<Cliente> clientes = (List<Cliente>)query.getResultList();
		
		for(Cliente cliente : clientes) {
			System.out.println(cliente.getNome());
		}
	}

}

É somente isso!! Fim to tutorial.

Existe dois métodos que pode ajudá-lo em algum processo.

/**
* Responsavel por retornar todas as classes persistentes
 * de sua aplicação
 */
Configuration configuration = ConfigPersistence.getInstanceConfiguration();
		
List<String> minhasClassesPersistentes = configuration.getEntities();
/**
* Esse metodo retorna o <b>persistence.xml</b> que você não deveria nem
* saber que existia, mas esse metodo pole mostra-lo
*/
Configuration configuration = ConfigPersistence.getInstanceConfiguration();
		
String meuPersistenceXml = configuration.getStringXMLPersistence();

É isso pessoal! Qual quer duvida, sugestão, reportar erro. Podem postar aqui no fórum estarei acompanhando.

Já estou ampliando o componente para se trabalhar com múltiplos schemas de banco de dados de maneira bem simples, coisa que o JPA não oferece de uma forma tão simples.

#2