RSS

Ejemplo básico JPA con EntityManager , Spring y Maven

04 jul

En este post vamos a crear un proyecto que nos permita traernos de una base de datos mySql un listado de coches. Las tecnologías que vamos a utilizar son Maven para la gestión de dependencias del proyecto, JPA para interactuar con la base de datos, Spring para definir el contexto de nuestra aplicación además de unir todo, y finalmente JUnit para realizar un test de nuestra aplicación.

El pom de nuestra aplicación será el siguiente.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.hopcroft.examples.spring</groupId>
	<artifactId>simpledao</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<pluginRepositories>
		<pluginRepository>
			<id>maven-annotation</id>
			<url>http://maven-annotation-plugin.googlecode.com/svn/trunk/mavenrepo</url>
		</pluginRepository>

	</pluginRepositories>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
					<compilerArguments>
						<processor>org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor</processor>
					</compilerArguments>
				</configuration>
				<version>2.3.2</version>
			</plugin>
			<plugin>
				<groupId>org.bsc.maven</groupId>
				<artifactId>maven-processor-plugin</artifactId>
				<version>2.0.2</version>
				<executions>
					<execution>
						<id>process</id>
						<goals>
							<goal>process</goal>
						</goals>
						<phase>generate-sources</phase>
						<configuration>
							<outputDirectory>src/main/generated-java</outputDirectory>
						</configuration>
					</execution>
				</executions>
			</plugin>
			<plugin>
				<groupId>org.codehaus.mojo</groupId>
				<artifactId>build-helper-maven-plugin</artifactId>
				<version>1.6</version>
				<executions>
					<execution>
						<id>add-source</id>
						<phase>generate-sources</phase>
						<goals>
							<goal>add-source</goal>
						</goals>
						<configuration>
							<sources>
								<source>src/main/generated-java</source>
							</sources>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>

	<dependencies>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>ejb3-persistence</artifactId>
			<version>1.0.2.GA</version>
			<type>pom</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>3.0.5.RELEASE</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>3.0.0.RELEASE</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>3.0.5.RELEASE</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>javax.security</groupId>
			<artifactId>jacc</artifactId>
			<version>1.0</version>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.10</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.8.2</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.2.2</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>3.0.5.RELEASE</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.6.1</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>javassist</groupId>
			<artifactId>javassist</artifactId>
			<version>3.12.1.GA</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>3.5.0-Final</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-annotations</artifactId>
			<version>3.5.0-Final</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.codehaus.openxma</groupId>
			<artifactId>dsl-platform</artifactId>
			<version>3.6.3</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-jpamodelgen</artifactId>
			<version>1.0.0.Final</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
	</dependencies>
</project>

Nuestra aplicación tendra la siguiente estructura.
configuracionProyecto en hop2croft.wordpress.com

Por un lado podemos ver nuestra capa de objeto de dominio en el que tenemos una entidad Car que modela la tabla con el mismo nombre que tenemos en nuestra base de datos.

Base de datos mySql hop2croft.wordpress.com

La entidad Car en nuestro proyecto.

package com.hopcroft.examples.domain;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "Car")
public class Car {
	@Id
	@Column(name = "id")
	private long id;
	@Column(name = "company")
	private String company;
	@Column(name = "model")
	private String model;
	@Column(name = "price")
	private long price;

	public void setId(long id) {
		this.id = id;
	}

	public long getId() {
		return id;
	}

	public String getCompany() {
		return company;
	}

	public void setCompany(String company) {
		this.company = company;
	}

	public String getModel() {
		return model;
	}

	public void setModel(String model) {
		this.model = model;
	}

	public long getPrice() {
		return price;
	}

	public void setPrice(long price) {
		this.price = price;
	}

}

También tendremos una capa de acceso a la base de datos donde tendremos una interfaz llamada CarDao que definirá los métodos disponibles para interactuar con la base de datos y una implementación de esa interfaz llamada CarDaoImpl.
Para llamar a la base de datos a diferencia de proyectos anteriores donde usabamos un objeto HibernateTemplate vamos a utilizar una instancia de EntityManager. Un EntityManager será una instancia de de EntityManagerFactory en JPA. Dicha factoria lo que hace es representar la configuración para acceder a la base de datos que utilice nuestra aplicación.
Para utilizar JPA en nuestro proyecto necesitamos crear una unidad de persistencia en el fichero META-INF/persistence.xml. En este fichero debemos crear un elemento persistence-unit con el nombre que queramos, hay que definir el tipo de transacción. Además necesitamos indicarle el proveedor que implementará JPA. En nuestro caso utilizaremos Hibernate.

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence

http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"

	version="1.0">
	<persistence-unit name="JpaPersistenceUnit"
		transaction-type="RESOURCE_LOCAL">
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
	</persistence-unit>
</persistence>

Tendremos que configurar el contexto de nuestra aplicación de manera similar a como lo hacíamos cuando usabamos sessionFactory de Hibernate. Esto es, nos tenemos que crear un dataSource en el fichero de contexto donde definimos la cadena de conexión, usuario, contraseña y tipo de base de datos que vamos a usar. Nos crearemos un entityManagerFactory al que le pasaremos el dataSource recién creado. Este entityManagerFactory estará controlado por un transactionManager. Como estamos usando JPA vamos a utilizar org.springframework.orm.jpa.JpaTransactionManager.
Vemos que también hay un elemento component-scan. Lo explicaremos cuando veamos el Dao. Nuestro fichero de contexto será el siguiente:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd


http://www.springframework.org/schema/tx


http://www.springframework.org/schema/tx/spring-tx-3.0.xsd


http://www.springframework.org/schema/context


http://www.springframework.org/schema/context/spring-context-3.0.xsd">

	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		p:driverClassName="com.mysql.jdbc.Driver" p:url="jdbc:mysql://localhost/test"
		p:username="root" p:password="" p:initialSize="5" p:maxActive="10">
	</bean>

	<bean
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
		id="entityManagerFactory">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<context:component-scan base-package="com.hopcroft.examples.dao">
		<context:include-filter type="annotation"
			expression="org.springframework.stereotype.Repository" />
	</context:component-scan>

	<bean class="org.springframework.orm.jpa.JpaTransactionManager"
		id="transactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>

	<tx:annotation-driven mode="aspectj"
		transaction-manager="transactionManager" />

	<context:spring-configured />
	<context:annotation-config />
</beans>

Una vez vistos todos los ficheros de configuración vamos a ver nuestro Dao, la interfaz y la implementación.

package com.hopcroft.examples.dao;

import java.util.List;

import org.springframework.dao.DataAccessException;

import com.hopcroft.examples.domain.Car;

public interface CarDao {
	public List<Car> getCars() throws DataAccessException;
	public Car getCar(Long carId) throws DataAccessException;
}

package com.hopcroft.examples.dao;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import com.hopcroft.examples.domain.Car;


@Repository
public class CarDaoImpl implements CarDao {
	
	protected EntityManager entityManager;
	
	public EntityManager getEntityManager() {
		return entityManager;
	}
	@PersistenceContext
	public void setEntityManager(EntityManager entityManager) {
		this.entityManager = entityManager;
	}

	@Transactional
	public List<Car> getCars() throws DataAccessException {
		Query query = getEntityManager().createQuery("select c from Car c");
		List<Car> resultList = query.getResultList();
		return resultList;
	}
	@Transactional
	public Car getCar(Long carId) throws DataAccessException {
		return getEntityManager().find(Car.class, carId);
	}
}

No hay mucho que decir de la interfaz. Un par de métodos que implementaremos en CarDaoImpl. La implementación tiene un par de cosas que conviene explicar.

Lo primero que nos encontramos es que la clase está anotada con @Repository. Este tipo de anotación es especial y sirve para indicarle al contexto de Spring que queremos que se incluya en él un componente. Además de la anotación @Repository existen las anotaciones @Service y @Controller. Todas ellas extienden de la notación @Component. La diferencia entre ellas es semántica, @Repository indicará a nuestro contexto Spring que queremos incluir un Dao, @Controller un controlador y @Service … no es díficil de adivinar. Recuerdas el elemento component-scan de nuestro fichero testApplicationContext, en él le indicabamos a Spring que ibamos a incluir en el contexto aquellas clases anotadas como @Repository, es decir, nuestro CarDaoImpl.

La segunda anotación que vemos es @PersistenceContext. Esta asignada al setter de nuestro EntityManager. Con ello obtenemos una instancia de la EntiyManagerFactory que luego vamos a usar en nuestros métodos para interactuar con la base de datos.
También podemos ver que nuestro métodos están anotados como transacionales. Ello hará que cada uno de nuestro métodos pertenezca a una única transación gestionada por el transactionManager que veíamos en nuestro fichero de contexto.

La lógica de los métodos es muy simple. Tenemos dos métodos uno que lista todos los coches de nuestra base de datos y otro que lista por el id. Para ello utilizamos nuestro entityManager. Al igual que HibernateTemplate, nuestro objeto entityManager tendrá ciertos métodos básicos para interactuar con la base de datos como persist, refresh ó remove.
Una vez creada nuestra aplicación vamos a realizar una pequeña clase de test para probar nuestra aplicación. El código es el siguiente.
Anotamos nuestra clase de prueba como siempre, indicandole que vamos a usar JUnit4 y el fichero de contexto que queremos. Tenemos nuestro dao accesible desde el contexto de prueba de Spring. Creamos un par de métodos de test y los ejecutamos con una configuración de Maven en STS.

test maven en hop2croft.wordpress.com

Ahora podemos ver como todo va bien en nuestro Log.

[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] ------------------------------------------------------------------------
[INFO] Building simpleDaoEntityManager 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] 
[INFO] --- maven-resources-plugin:2.4.3:resources (default-resources) @ simpleDaoEntityManager ---
[WARNING] Using platform encoding (MacRoman actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 1 resource
[INFO] 
[INFO] --- maven-compiler-plugin:2.3.2:compile (default-compile) @ simpleDaoEntityManager ---
[INFO] Nothing to compile - all classes are up to date
[INFO] 
[INFO] --- maven-resources-plugin:2.4.3:testResources (default-testResources) @ simpleDaoEntityManager ---
[WARNING] Using platform encoding (MacRoman actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 1 resource
[INFO] 
[INFO] --- maven-compiler-plugin:2.3.2:testCompile (default-testCompile) @ simpleDaoEntityManager ---
[INFO] Nothing to compile - all classes are up to date
[INFO] 
[INFO] --- maven-surefire-plugin:2.5:test (default-test) @ simpleDaoEntityManager ---
[INFO] Surefire report directory: /Users/Ivan/Documents/workspace/hsqldb/simpleDaoEntityManager/target/surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.hopcroft.examples.test.CarTest
04-jul-2011 21:06:44 org.springframework.test.context.TestContextManager retrieveTestExecutionListeners
INFO: @TestExecutionListeners is not present for class [class com.hopcroft.examples.test.CarTest]: using defaults.
04-jul-2011 21:06:45 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [testApplicationContext.xml]
04-jul-2011 21:06:46 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.GenericApplicationContext@c4a5ec: startup date [Mon Jul 04 21:06:46 CEST 2011]; root of context hierarchy
04-jul-2011 21:06:47 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@a93995: defining beans [dataSource,entityManagerFactory,carDaoImpl,org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.context.annotation.internalPersistenceAnnotationProcessor,transactionManager,org.springframework.transaction.config.internalTransactionAspect,org.springframework.context.config.internalBeanConfigurerAspect]; root of factory hierarchy
04-jul-2011 21:06:47 org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean createNativeEntityManagerFactory
INFO: Building JPA container EntityManagerFactory for persistence unit 'JpaPersistenceUnit'
SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/Users/Ivan/.m2/repository/org/ow2/easybeans/easybeans-uberjar-hibernate/1.2.1/easybeans-uberjar-hibernate-1.2.1.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/Users/Ivan/.m2/repository/org/slf4j/slf4j-jcl/1.5.2/slf4j-jcl-1.5.2.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
04-jul-2011 21:06:47 org.slf4j.impl.JCLLoggerAdapter info
INFO: Hibernate Annotations 3.5.0-Final
04-jul-2011 21:06:48 org.slf4j.impl.JCLLoggerAdapter info
INFO: Hibernate 3.5.0-Final
04-jul-2011 21:06:48 org.slf4j.impl.JCLLoggerAdapter info
INFO: hibernate.properties not found
04-jul-2011 21:06:48 org.slf4j.impl.JCLLoggerAdapter info
INFO: Bytecode provider name : javassist
04-jul-2011 21:06:48 org.slf4j.impl.JCLLoggerAdapter info
INFO: using JDK 1.4 java.sql.Timestamp handling
04-jul-2011 21:06:48 org.slf4j.impl.JCLLoggerAdapter info
INFO: Hibernate Commons Annotations 3.2.0.Final
04-jul-2011 21:06:48 org.slf4j.impl.JCLLoggerAdapter info
INFO: Hibernate EntityManager 3.5.6-Final
04-jul-2011 21:06:48 org.slf4j.impl.JCLLoggerAdapter info
INFO: Processing PersistenceUnitInfo [
	name: JpaPersistenceUnit
	...]
04-jul-2011 21:06:48 org.slf4j.impl.JCLLoggerAdapter info
INFO: Binding entity from annotated class: com.hopcroft.examples.domain.Car
04-jul-2011 21:06:48 org.slf4j.impl.JCLLoggerAdapter info
INFO: Bind entity com.hopcroft.examples.domain.Car on table Car
04-jul-2011 21:06:49 org.slf4j.impl.JCLLoggerAdapter info
INFO: Hibernate Validator not found: ignoring
04-jul-2011 21:06:49 org.slf4j.impl.JCLLoggerAdapter info
INFO: Hibernate Validator 1.2.1
04-jul-2011 21:06:49 org.slf4j.impl.JCLLoggerAdapter info
INFO: Instantiated an instance of org.hibernate.validator.engine.resolver.JPATraversableResolver.
04-jul-2011 21:06:49 org.slf4j.impl.JCLLoggerAdapter info
INFO: Instantiated an instance of org.hibernate.validator.engine.resolver.JPATraversableResolver.
04-jul-2011 21:06:49 org.slf4j.impl.JCLLoggerAdapter info
INFO: Instantiated an instance of org.hibernate.validator.engine.resolver.JPATraversableResolver.
04-jul-2011 21:06:49 org.slf4j.impl.JCLLoggerAdapter info
INFO: Initializing connection provider: org.hibernate.ejb.connection.InjectedDataSourceConnectionProvider
04-jul-2011 21:06:49 org.slf4j.impl.JCLLoggerAdapter info
INFO: Using provided datasource
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: RDBMS: MySQL, version: 5.5.11
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: JDBC driver: MySQL-AB JDBC Driver, version: mysql-connector-java-5.1.10 ( Revision: ${svn.Revision} )
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Using dialect: org.hibernate.dialect.MySQLDialect
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Disabling contextual LOB creation as JDBC driver reported JDBC version [3] less than 4
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Transaction strategy: org.hibernate.transaction.JDBCTransactionFactory
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: No TransactionManagerLookup configured (in JTA environment, use of read-write or transactional second-level cache is not recommended)
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Automatic flush during beforeCompletion(): disabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Automatic session close at end of transaction: disabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: JDBC batch size: 15
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: JDBC batch updates for versioned data: disabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Scrollable result sets: enabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: JDBC3 getGeneratedKeys(): enabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Connection release mode: auto
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Maximum outer join fetch depth: 2
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Default batch fetch size: 1
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Generate SQL with comments: disabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Order SQL updates by primary key: disabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Order SQL inserts for batching: disabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Query translator: org.hibernate.hql.ast.ASTQueryTranslatorFactory
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Using ASTQueryTranslatorFactory
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Query language substitutions: {}
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: JPA-QL strict compliance: enabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Second-level cache: enabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Query cache: disabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Cache region factory : org.hibernate.cache.impl.NoCachingRegionFactory
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Optimize cache for minimal puts: disabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Structured second-level cache entries: disabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Statistics: disabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Deleted entity synthetic identifier rollback: disabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Default entity-mode: pojo
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Named query checking : enabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Check Nullability in Core (should be disabled when Bean Validation is on): disabled
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Hibernate Search 3.2.0.CR1
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: building session factory
04-jul-2011 21:06:50 org.slf4j.impl.JCLLoggerAdapter info
INFO: Not binding factory to JNDI, no JNDI name configured
Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 7.813 sec

Results :

Tests run: 2, Failures: 0, Errors: 0, Skipped: 0

04-jul-2011 21:06:51 org.springframework.context.support.AbstractApplicationContext doClose
INFO: Closing org.springframework.context.support.GenericApplicationContext@c4a5ec: startup date [Mon Jul 04 21:06:46 CEST 2011]; root of context hierarchy
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 17.313s
[INFO] Finished at: Mon Jul 04 21:06:51 CEST 2011
[INFO] Final Memory: 6M/12M
[INFO] ------------------------------------------------------------------------

Otras entradas que te pueden interesar son:

About these ads
 
10 comentarios

Publicado por en 4 julio, 2011 en JPA

 

Etiquetas: , , , , , ,

10 Respuestas a “Ejemplo básico JPA con EntityManager , Spring y Maven

  1. jean

    4 septiembre, 2012 at 11:33 pm

    Buenas Tardes. Amigo no dejastes el codigo fuente correspondiente a CarTest. Saludos!!

     
  2. Nico

    15 agosto, 2013 at 4:00 pm

    hola, muy bueno el tutorial, ya puse la pagina en favoritos..
    tengo una duda, quizas tonta, pero no me queda del todo claro; usando esas herramientas (Spring, maven, jpa) cuando quiero hacer un build para usar el programa que hago en la pc del cliente, necesito instalar algo aparte de la base de datos y el Java jre?
    actualmente hago un build y ejecuto el .jar y con eso funciona, pero no se si es igual implementando estas herramientas.
    Gracias

     
    • hop2croft

      15 agosto, 2013 at 8:52 pm

      Buenas Nico,

      muchas gracias por leer el post. Últimamente no escribo mucho pero a ver si me animo de nuevo.

      En cuanto a la pregunta, que no es tonta :), la respuesta corta es no. La larga es la siguiente:

      Cuando usas maven para gestionar tus proyectos, todas las dependencias que necesites se van a definir en un fichero llamado pom.xml. Con ello vas a lograr que te despreocupes de las librerías que utilices y que sea maven el que se encargue de ellas. Maven tiene un directorio llamado repositorio local (normalmente se encuentra en $HOME/.m2) donde se van a almacenar todas esas librerías. En caso de que tu proyecto haga referencia a librerías que no tengas en el repositorio local, lo que se hace cada vez que compilas un proyecto gestionado por Maven, es que éste (Maven) busca las librerías en un repositorio en Internet, se las baja y las guarda en el repositorio local.

      Maven además tiene lo que se conoce como un ciclo de vida con una serie de comandos asociados que te permiten por ejemplo compilar directamente tus proyectos a través del propio maven. Te pongo un enlace por si te pueden servir:

      Muchas gracias de nuevo y se tienes alguna duda más no dudes en postear :)

       
  3. Nico

    16 agosto, 2013 at 4:07 am

    Gracias por tu respuesta!,
    no salio el link :P
    estoy a full leyendo y aprendiendo sobre estas herramientas, sigo con dudas pero de a poco las voy despejando….
    hasta ahora, para hacer aplicaciones de escritorio, siempre me maneje con Java en netbeans, utilizando el patron dao para la base de datos (postgresql), y estoy viendo con buenos ojos empezar a usar alguna de estas herramientas..

     

Deja un comentario

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

 
Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.

Únete a otros 69 seguidores

%d personas les gusta esto: