1. Información general
Este tutorial muestra cómo configurar Spring con JPA , usando Hibernate como proveedor de persistencia.
Para obtener una introducción paso a paso sobre cómo configurar el contexto Spring utilizando la configuración basada en Java y el pom básico de Maven para el proyecto, consulte este artículo.
Comenzaremos configurando JPA en un proyecto Spring Boot, luego analizaremos la configuración completa que necesitamos si tenemos un proyecto Spring estándar.
Aquí hay un video sobre cómo configurar Hibernate 4 con Spring 4 (recomiendo verlo en 1080p completo):
2. JPA en Spring Boot
El proyecto Spring Boot está destinado a hacer que la creación de aplicaciones Spring sea mucho más rápida y sencilla. Esto se hace con el uso de iniciadores y la configuración automática para varias funcionalidades de Spring, entre ellas JPA.
2.1. Dependencias de Maven
Para habilitar JPA en una aplicación Spring Boot, necesitamos las dependencias spring-boot-starter y spring-boot-starter-data-jpa :
org.springframework.boot spring-boot-starter 2.2.6.RELEASE org.springframework.boot spring-boot-starter-data-jpa 2.2.6.RELEASE El resorte de arranque-motor de arranque contiene la auto-configuración necesaria para la primavera JPA. Además, el proyecto spring-boot-starter-jpa hace referencia a todas las dependencias necesarias, como hibernate-core .
2.2. Configuración
Spring Boot configura Hibernate como el proveedor JPA predeterminado , por lo que ya no es necesario definir el bean entityManagerFactory a menos que queramos personalizarlo.
Spring Boot también puede configurar automáticamente el bean dataSource , dependiendo de la base de datos que estemos usando . En el caso de una base de datos en memoria de tipo H2 , HSQLDB y Apache Derby , Boot configura automáticamente el DataSource si la correspondiente dependencia de la base de datos está presente en el classpath.
Por ejemplo, si queremos usar una base de datos H2 en memoria en una aplicación Spring Boot JPA, solo necesitamos agregar la dependencia h2 al archivo pom.xml :
com.h2database h2 1.4.200 De esta manera, no necesitamos definir el bean dataSource , pero podemos hacerlo si queremos personalizarlo.
Si queremos usar JPA con la base de datos MySQL , entonces necesitamos la dependencia mysql-connector-java , así como definir la configuración de DataSource .
Podemos hacer esto en una clase @Configuration , o usando las propiedades estándar de Spring Boot.
La configuración de Java tiene el mismo aspecto que en un proyecto Spring estándar:
@Bean public DataSource dataSource() { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver"); dataSource.setUsername("mysqluser"); dataSource.setPassword("mysqlpass"); dataSource.setUrl( "jdbc:mysql://localhost:3306/myDb?createDatabaseIfNotExist=true"); return dataSource; }Para configurar la fuente de datos usando un archivo de propiedades, tenemos que establecer propiedades con el prefijo spring.datasource :
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.username=mysqluser spring.datasource.password=mysqlpass spring.datasource.url= jdbc:mysql://localhost:3306/myDb?createDatabaseIfNotExist=trueSpring Boot configurará automáticamente una fuente de datos basada en estas propiedades.
También en Spring Boot 1, el grupo de conexiones predeterminado era Tomcat , pero con Spring Boot 2 se ha cambiado a HikariCP .
Puede encontrar más ejemplos de configuración de JPA en Spring Boot en el proyecto GitHub.
Como podemos ver, la configuración básica de JPA es bastante simple si usamos Spring Boot.
Sin embargo, si tenemos un proyecto Spring estándar, entonces necesitamos una configuración más explícita, usando Java o XML. Eso es en lo que nos centraremos en las próximas secciones.
3. La configuración de JPA Spring con Java - en un proyecto que no es de arranque
Para usar JPA en un proyecto Spring, necesitamos configurar EntityManager.
Esta es la parte principal de la configuración y podemos hacerlo a través de un bean de fábrica Spring. Puede ser LocalEntityManagerFactoryBean más simple o LocalContainerEntityManagerFactoryBean más flexible .
Veamos cómo podemos usar la última opción:
@Configuration @EnableTransactionManagement public class PersistenceJPAConfig{ @Bean public LocalContainerEntityManagerFactoryBean entityManagerFactory() { LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean(); em.setDataSource(dataSource()); em.setPackagesToScan(new String[] { "com.baeldung.persistence.model" }); JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter(); em.setJpaVendorAdapter(vendorAdapter); em.setJpaProperties(additionalProperties()); return em; } // ... }También necesitamos definir explícitamente el bean DataSource que hemos usado anteriormente:
@Bean public DataSource dataSource(){ DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver"); dataSource.setUrl("jdbc:mysql://localhost:3306/spring_jpa"); dataSource.setUsername( "tutorialuser" ); dataSource.setPassword( "tutorialmy5ql" ); return dataSource; }La parte final de la configuración son las propiedades adicionales de Hibernate y los beans TransactionManager y exceptionTranslation :
@Bean public PlatformTransactionManager transactionManager() { JpaTransactionManager transactionManager = new JpaTransactionManager(); transactionManager.setEntityManagerFactory(entityManagerFactory().getObject()); return transactionManager; } @Bean public PersistenceExceptionTranslationPostProcessor exceptionTranslation(){ return new PersistenceExceptionTranslationPostProcessor(); } Properties additionalProperties() { Properties properties = new Properties(); properties.setProperty("hibernate.hbm2ddl.auto", "create-drop"); properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect"); return properties; }4. La configuración de JPA Spring con XML
A continuación, veamos la misma configuración de Spring con XML:
create-drop org.hibernate.dialect.MySQL5Dialect Existe una diferencia relativamente pequeña entre XML y la nueva configuración basada en Java. Es decir, en XML, una referencia a otro bean puede apuntar al bean oa una fábrica de beans para ese bean.
En Java, sin embargo, dado que los tipos son diferentes, el compilador no lo permite, por lo que EntityManagerFactory se recupera primero de su fábrica de frijoles y luego se pasa al administrador de transacciones:
transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());5. Adopción de XML completo
Por lo general, JPA define una unidad de persistencia a través del archivo META-INF / persistence.xml . A partir de Spring 3.1, persistence.xml ya no es necesario . El LocalContainerEntityManagerFactoryBean ahora es compatible con una packagesToScan propiedad donde los paquetes se analiza la existencia @Entity clases se pueden especificar.
Este archivo fue la última pieza de XML que necesitamos eliminar. Ahora podemos configurar JPA completamente sin XML.
We would usually specify JPA properties in the persistence.xml file. Alternatively, we can add the properties directly to the entity manager factory bean:
factoryBean.setJpaProperties(this.additionalProperties());As a side note, if Hibernate would be the persistence provider, then this would be the way to specify Hibernate specific properties as well.
6. The Maven Configuration
In addition to the Spring Core and persistence dependencies – show in detail in the Spring with Maven tutorial – we also need to define JPA and Hibernate in the project, as well as a MySQL connector:
org.hibernate hibernate-core 5.2.17.Final runtime mysql mysql-connector-java 8.0.19 runtime Note that the MySQL dependency is included here as an example. We need a driver to configure the datasource, but any Hibernate-supported database will do.
7. Conclusion
Este tutorial ilustró cómo configurar JPA con Hibernate en Spring tanto en una aplicación Spring Boot como en una aplicación Spring estándar.
Como siempre, el código presentado en este artículo está disponible en GitHub.