Una guida all'APP con la primavera

1. Panoramica

Questo tutorial mostra come configurare Spring con JPA , utilizzando Hibernate come provider di persistenza.

Per un'introduzione passo passo sulla configurazione del contesto Spring utilizzando la configurazione basata su Java e il pom Maven di base per il progetto, vedere questo articolo.

Inizieremo configurando JPA in un progetto Spring Boot, quindi esamineremo la configurazione completa di cui abbiamo bisogno se abbiamo un progetto Spring standard.

Ecco un video sulla configurazione di Hibernate 4 con Spring 4 (consiglio di guardarlo a 1080p):

2. JPA in Spring Boot

Il progetto Spring Boot ha lo scopo di rendere la creazione di applicazioni Spring molto più rapida e semplice. Questo viene fatto con l'uso di starter e auto-configurazione per varie funzionalità Spring, tra cui JPA.

2.1. Dipendenze di Maven

Per abilitare JPA in un'applicazione Spring Boot, abbiamo bisogno delle dipendenze spring-boot-starter e 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 

Lo spring-boot-starter contiene la configurazione automatica necessaria per Spring JPA. Inoltre, il progetto spring-boot-starter-jpa fa riferimento a tutte le dipendenze necessarie come hibernate-core .

2.2. Configurazione

Spring Boot configura Hibernate come provider JPA predefinito , quindi non è più necessario definire il bean entityManagerFactory a meno che non si desideri personalizzarlo.

Spring Boot può anche configurare automaticamente il bean dataSource , a seconda del database che stiamo utilizzando . Nel caso di un database in memoria di tipo H2 , HSQLDB e Apache Derby , Boot configura automaticamente DataSource se la dipendenza del database corrispondente è presente sul classpath.

Ad esempio, se vogliamo utilizzare un database H2 in memoria in un'applicazione Spring Boot JPA, dobbiamo solo aggiungere la dipendenza h2 al file pom.xml :

 com.h2database h2 1.4.200 

In questo modo, non abbiamo bisogno di definire il bean dataSource , ma possiamo farlo se vogliamo personalizzarlo.

Se vogliamo utilizzare JPA con il database MySQL , allora abbiamo bisogno della dipendenza mysql-connector-java , oltre a definire la configurazione DataSource .

Possiamo farlo in una classe @Configuration o usando le proprietà standard di Spring Boot.

La configurazione Java ha lo stesso aspetto di un progetto Spring standard:

@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; }

Per configurare l'origine dati utilizzando un file delle proprietà, dobbiamo impostare le proprietà con prefisso 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=true

Spring Boot configurerà automaticamente un'origine dati in base a queste proprietà.

Anche in Spring Boot 1, il pool di connessioni predefinito era Tomcat , ma con Spring Boot 2 è stato modificato in HikariCP .

Puoi trovare altri esempi di configurazione di JPA in Spring Boot nel progetto GitHub.

Come possiamo vedere, la configurazione di base di JPA è abbastanza semplice se usiamo Spring Boot.

Tuttavia, se abbiamo un progetto Spring standard, abbiamo bisogno di una configurazione più esplicita, utilizzando Java o XML. Questo è ciò su cui ci concentreremo nelle prossime sezioni.

3. La configurazione Spring JPA con Java - in un progetto non di avvio

Per utilizzare JPA in un progetto Spring, è necessario configurare EntityManager.

Questa è la parte principale della configurazione e possiamo farlo tramite un bean di fabbrica Spring. Può essere il più semplice LocalEntityManagerFactoryBean o il più flessibile LocalContainerEntityManagerFactoryBean .

Vediamo come possiamo utilizzare quest'ultima opzione:

@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; } // ... }

Abbiamo anche bisogno di definire esplicitamente il bean DataSource che abbiamo usato sopra:

@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 finale della configurazione sono le proprietà aggiuntive di Hibernate e il TransactionManager e i bean 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 configurazione JPA Spring con XML

Successivamente, vediamo la stessa configurazione Spring con XML:

        create-drop org.hibernate.dialect.MySQL5Dialect              

C'è una differenza relativamente piccola tra XML e la nuova configurazione basata su Java. Vale a dire, in XML, un riferimento a un altro bean può puntare al bean oa una bean factory per quel bean.

In Java, tuttavia, poiché i tipi sono diversi, il compilatore non lo consente, quindi EntityManagerFactory viene prima recuperato dalla sua bean factory e quindi passato al gestore delle transazioni:

transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());

5. Andare completamente senza XML

Di solito, JPA definisce un'unità di persistenza tramite il file META-INF / persistence.xml . A partire dalla Spring 3.1, persistence.xml non è più necessario . Il LocalContainerEntityManagerFactoryBean supporta ora una packagesToScan proprietà in cui i pacchetti per la ricerca di @Entity classi può essere specificato.

Questo file è stato l'ultimo pezzo di XML che dobbiamo rimuovere. Ora possiamo configurare JPA completamente senza 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

Questo tutorial ha illustrato come configurare JPA con Hibernate in Spring sia in Spring Boot che in un'applicazione Spring standard.

Come sempre, il codice presentato in questo articolo è disponibile su GitHub.