Panduan JPA dengan Spring

1. Ikhtisar

Tutorial ini menunjukkan cara mengatur Spring dengan JPA , menggunakan Hibernate sebagai penyedia persistensi.

Untuk pengenalan langkah demi langkah tentang menyiapkan konteks Spring menggunakan konfigurasi berbasis Java dan pom Maven dasar untuk proyek tersebut, lihat artikel ini.

Kita akan mulai dengan menyiapkan JPA dalam proyek Spring Boot, lalu kita akan melihat konfigurasi lengkap yang kita perlukan jika kita memiliki proyek Spring standar.

Berikut adalah video tentang cara mengatur Hibernate 4 dengan Spring 4 (saya sarankan untuk menontonnya dalam 1080p penuh):

2. JPA di Spring Boot

Proyek Spring Boot dimaksudkan untuk membuat aplikasi Spring lebih cepat dan mudah. Hal ini dilakukan dengan penggunaan starter dan konfigurasi otomatis untuk berbagai fungsi Spring, di antaranya JPA.

2.1. Dependensi Maven

Untuk mengaktifkan JPA di aplikasi Spring Boot, kita memerlukan dependensi spring-boot-starter dan 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 

The semi-boot-starter berisi auto-konfigurasi yang diperlukan untuk Spring JPA. Juga, proyek spring-boot-starter-jpa mereferensikan semua dependensi yang diperlukan seperti hibernate-core .

2.2. Konfigurasi

Spring Boot mengkonfigurasi Hibernate sebagai penyedia JPA default , jadi tidak perlu lagi mendefinisikan kacang entityManagerFactory kecuali kita ingin menyesuaikannya.

Spring Boot juga dapat secara otomatis mengkonfigurasi dataSource bean, tergantung pada database yang kita gunakan . Dalam kasus database dalam memori tipe H2 , HSQLDB, dan Apache Derby , Boot secara otomatis mengonfigurasi DataSource jika dependensi database terkait ada di classpath.

Misalnya, jika kita ingin menggunakan database H2 dalam memori di aplikasi JPA Spring Boot, kita hanya perlu menambahkan dependensi h2 ke file pom.xml :

 com.h2database h2 1.4.200 

Dengan cara ini, kita tidak perlu mendefinisikan bean dataSource , tapi kita bisa melakukannya jika kita ingin menyesuaikannya.

Jika kita ingin menggunakan JPA dengan database MySQL , maka kita membutuhkan dependensi mysql-connector-java , serta untuk menentukan konfigurasi DataSource .

Kita dapat melakukan ini di kelas @Configuration , atau dengan menggunakan properti Spring Boot standar.

Konfigurasi Java terlihat sama seperti di proyek Spring standar:

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

Untuk mengonfigurasi sumber data menggunakan file properti, kita harus menyetel properti yang diawali dengan 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 secara otomatis akan mengkonfigurasi sumber data berdasarkan properti ini.

Juga di Spring Boot 1, kumpulan koneksi default adalah Tomcat , tetapi dengan Spring Boot 2 itu telah diubah menjadi HikariCP .

Anda dapat menemukan lebih banyak contoh konfigurasi JPA di Spring Boot di proyek GitHub.

Seperti yang bisa kita lihat, konfigurasi dasar JPA cukup sederhana jika kita menggunakan Spring Boot.

Namun, jika kita memiliki proyek Spring standar, maka kita memerlukan konfigurasi yang lebih eksplisit, baik menggunakan Java atau XML. Itulah yang akan kita fokuskan di bagian selanjutnya.

3. Konfigurasi Musim Semi JPA Dengan Java - dalam Proyek Non-Boot

Untuk menggunakan JPA dalam proyek Spring, kita perlu menyiapkan EntityManager.

Ini adalah bagian utama dari konfigurasi dan kita dapat melakukannya melalui kacang pabrik Spring. Hal ini dapat berupa sederhana LocalEntityManagerFactoryBean atau yang lebih fleksibel LocalContainerEntityManagerFactoryBean .

Mari kita lihat bagaimana kita dapat menggunakan opsi terakhir:

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

Kita juga perlu secara eksplisit mendefinisikan bean DataSource yang telah kita gunakan di atas:

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

Bagian terakhir dari konfigurasi adalah properti Hibernate tambahan dan kacang TransactionManager dan 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. Konfigurasi Musim Semi JPA Dengan XML

Selanjutnya, mari kita lihat Konfigurasi Musim Semi yang sama dengan XML:

        create-drop org.hibernate.dialect.MySQL5Dialect              

Ada perbedaan yang relatif kecil antara XML dan konfigurasi berbasis Java yang baru. Yaitu, dalam XML, referensi ke kacang lain bisa menunjuk ke kacang atau pabrik kacang untuk kacang itu.

Namun, di Java, karena tipenya berbeda, compiler tidak mengizinkannya, sehingga EntityManagerFactory pertama kali diambil dari bean factory-nya dan kemudian diteruskan ke transaction manager:

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

5. Menggunakan tanpa XML Penuh

Biasanya, JPA mendefinisikan unit persistensi melalui file META-INF / persistence.xml . Mulai Spring 3.1, persistence.xml tidak lagi diperlukan . The LocalContainerEntityManagerFactoryBean sekarang mendukung packagesToScan properti di mana paket untuk memindai @ Entity kelas dapat ditentukan.

File ini adalah bagian terakhir dari XML yang perlu kami hapus. Kami sekarang dapat menyiapkan JPA sepenuhnya tanpa 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

Tutorial ini mengilustrasikan cara mengkonfigurasi JPA dengan Hibernate in Spring di Spring Boot dan aplikasi Spring standar.

Seperti biasa, kode yang disajikan dalam artikel ini tersedia di GitHub.