domingo, 8 de octubre de 2017

Spring Data JPA using Hibernate and Java Configuration with Annotations

  22:50:00   No comments   Edit
In this tutorial I’ll show you how to use Spring Data JPA to integrate a relational database (PostgreSQL in my example) into a Spring Boot application.
I’ll use these technologies and tools:
  • Spring Tool Suite (STS) 3.8.4.RELEASE
  • Java 8
  • Spring Boot 1.5.3.RELEASE
  • Maven 3.3.9
  • PostgreSQL 9.6.2

1. The Project Structure

The final folder structure of our project.
The folder structure of the Spring Data JPA project as seen in STS

2. Create a new Spring Boot project

If you’re using STS, you can easily create a starter project by either selecting File > New > Spring Starter Project from the main menu or right-clicking on the Package Explorer and select New > Spring Starter Project.
STS command to create a new Spring Starter Project
Dialog window to set parameters for the Spring Data JPA project
The list of dependencies of the Spring Data JPA project
In case you’re using another IDE like Eclipse, Netbeans or IntelliJ IDEA, you can create a new Maven project and add to the pom.xml file the dependencies listed in the next paragraph.

3. Maven Dependencies

spring-boot-starter-data-jpa is the fundamental dependency for our project, then we need the driver for whatever SQL database we have chosen, in this case postgresql.
  • pom.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4. <modelVersion>4.0.0</modelVersion>
  6. <groupId>com.thomasvitale</groupId>
  7. <artifactId>Application</artifactId>
  8. <version>0.0.1-SNAPSHOT</version>
  9. <packaging>jar</packaging>
  11. <name>Application</name>
  12. <description>Demo application for Spring Data JPA</description>
  14. <parent>
  15. <groupId>org.springframework.boot</groupId>
  16. <artifactId>spring-boot-starter-parent</artifactId>
  17. <version>1.5.3.RELEASE</version>
  18. <relativePath/> <!-- lookup parent from repository -->
  19. </parent>
  21. <properties>
  22. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  23. <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  24. <java.version>1.8</java.version>
  25. </properties>
  27. <dependencies>
  29. <dependency>
  30. <groupId>org.springframework.boot</groupId>
  31. <artifactId>spring-boot-starter-data-jpa</artifactId>
  32. </dependency>
  34. <dependency>
  35. <groupId>org.postgresql</groupId>
  36. <artifactId>postgresql</artifactId>
  37. <scope>runtime</scope>
  38. </dependency>
  40. <dependency>
  41. <groupId>org.springframework.boot</groupId>
  42. <artifactId>spring-boot-starter-test</artifactId>
  43. <scope>test</scope>
  44. </dependency>
  46. </dependencies>
  48. <build>
  49. <plugins>
  50. <plugin>
  51. <groupId>org.springframework.boot</groupId>
  52. <artifactId>spring-boot-maven-plugin</artifactId>
  53. </plugin>
  54. </plugins>
  55. </build>
  57. </project>
<?xml version="1.0" encoding="UTF-8"?>
<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.thomasvitale</groupId>
  <artifactId>Application</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>Application</name>
  <description>Demo application for Spring Data JPA</description>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.3.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
  </properties>

  <dependencies>
  
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <dependency>
      <groupId>org.postgresql</groupId>
      <artifactId>postgresql</artifactId>
      <scope>runtime</scope>
    </dependency>
  
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>
I’m using PostgreSQL, but this example works fine also with other relational databases. For example, if you want to use MySQL, all you need to do is replace the postgresql dependency with the mysql one.
  1. <dependency>
  2. <groupId>mysql</groupId>
  3. <artifactId>mysql-connector-java</artifactId>
  4. <scope>runtime</scope>
  5. </dependency>
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <scope>runtime</scope>
</dependency>

4. Spring Configuration using Java Annotations and Hibernate

Spring lets you use either Java configuration or XML configuration or a mix of the two. I’ll use a pure Java configuration. There are a few implementations of JPA, in this example Hibernate is used. Its properties are stored in a dedicated file.
  • JpaConfig.java
  1. package com.thomasvitale;
  3. import java.util.Properties;
  5. import javax.persistence.EntityManagerFactory;
  6. import javax.sql.DataSource;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.context.annotation.PropertySource;
  12. import org.springframework.core.env.Environment;
  13. import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
  14. import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
  15. import org.springframework.jdbc.datasource.DriverManagerDataSource;
  16. import org.springframework.orm.jpa.JpaTransactionManager;
  17. import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
  18. import org.springframework.orm.jpa.vendor.Database;
  19. import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
  20. import org.springframework.transaction.PlatformTransactionManager;
  21. import org.springframework.transaction.annotation.EnableTransactionManagement;
  23. @Configuration
  24. @EnableTransactionManagement
  25. @EnableJpaRepositories(basePackages = "com.thomasvitale.repository")
  26. @PropertySource("classpath:jpa.properties")
  27. public class JpaConfig {
  29. @Autowired
  30. private Environment env;
  32. @Bean
  33. public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
  35. HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
  36. vendorAdapter.setDatabase(Database.POSTGRESQL);
  37. vendorAdapter.setGenerateDdl(true);
  39. LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
  40. em.setDataSource(dataSource());
  41. em.setPackagesToScan("com.thomasvitale.model");
  42. em.setJpaVendorAdapter(vendorAdapter);
  43. em.setJpaProperties(additionalProperties());
  45. return em;
  46. }
  48. @Bean
  49. public DataSource dataSource(){
  50. DriverManagerDataSource dataSource = new DriverManagerDataSource();
  51. dataSource.setDriverClassName(env.getProperty("hibernate.connection.driver_class"));
  52. dataSource.setUrl(env.getProperty("hibernate.connection.url"));
  53. dataSource.setUsername(env.getProperty("hibernate.connection.username"));
  54. dataSource.setPassword(env.getProperty("hibernate.connection.password"));
  55. return dataSource;
  56. }
  58. @Bean
  59. public PlatformTransactionManager transactionManager(EntityManagerFactory emf){
  60. JpaTransactionManager transactionManager = new JpaTransactionManager();
  61. transactionManager.setEntityManagerFactory(emf);
  63. return transactionManager;
  64. }
  66. @Bean
  67. public PersistenceExceptionTranslationPostProcessor exceptionTranslation(){
  68. return new PersistenceExceptionTranslationPostProcessor();
  69. }
  71. Properties additionalProperties() {
  72. Properties properties = new Properties();
  73. properties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
  74. properties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
  75. properties.setProperty("hibernate.current_session_context_class", env.getProperty("hibernate.current_session_context_class"));
  76. return properties;
  77. }
  79. }
package com.thomasvitale;

import java.util.Properties;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.Database;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement 
@EnableJpaRepositories(basePackages = "com.thomasvitale.repository")
@PropertySource("classpath:jpa.properties")
public class JpaConfig {
  
  @Autowired
  private Environment env;

  @Bean
  public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
    
    HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    vendorAdapter.setDatabase(Database.POSTGRESQL);
    vendorAdapter.setGenerateDdl(true);
    
    LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
    em.setDataSource(dataSource());
    em.setPackagesToScan("com.thomasvitale.model");
    em.setJpaVendorAdapter(vendorAdapter);
    em.setJpaProperties(additionalProperties());
 
    return em;
  }
  
  @Bean
  public DataSource dataSource(){
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName(env.getProperty("hibernate.connection.driver_class"));
    dataSource.setUrl(env.getProperty("hibernate.connection.url"));
    dataSource.setUsername(env.getProperty("hibernate.connection.username"));
    dataSource.setPassword(env.getProperty("hibernate.connection.password"));
    return dataSource;
  }
  
  @Bean
  public PlatformTransactionManager transactionManager(EntityManagerFactory emf){
    JpaTransactionManager transactionManager = new JpaTransactionManager();
    transactionManager.setEntityManagerFactory(emf);
  
    return transactionManager;
  }
  
  @Bean
  public PersistenceExceptionTranslationPostProcessor exceptionTranslation(){
    return new PersistenceExceptionTranslationPostProcessor();
  }

  Properties additionalProperties() {
    Properties properties = new Properties();
    properties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
    properties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
    properties.setProperty("hibernate.current_session_context_class", env.getProperty("hibernate.current_session_context_class"));
    return properties;
  }

}
  • jpa.properties
  1. hibernate.connection.username=db-user
  2. hibernate.connection.password=db-password
  3. hibernate.connection.url=jdbc:postgresql://localhost:5432/app
  4. hibernate.connection.driver_class=org.postgresql.Driver
  5. hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
  6. hibernate.current_session_context_class=thread
  7. hibernate.hbm2ddl.auto=validate
  8. hibernate.show_sql=false
  9. hibernate.format_sql=false
hibernate.connection.username=db-user
hibernate.connection.password=db-password
hibernate.connection.url=jdbc:postgresql://localhost:5432/app
hibernate.connection.driver_class=org.postgresql.Driver
hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
hibernate.current_session_context_class=thread
hibernate.hbm2ddl.auto=validate
hibernate.show_sql=false
hibernate.format_sql=false
If you’re using MySQL, pay attention to replace line 36 of JpaConfig.java with this one: vendorAdapter.setDatabase(Database.MYSQL); and change the relative values in the jpa.properties file:
  1. hibernate.connection.url=jdbc:mysql://localhost:3306/app
  2. hibernate.connection.driver_class=com.mysql.jdbc.Driver
  3. hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.connection.url=jdbc:mysql://localhost:3306/app
hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.dialect=org.hibernate.dialect.MySQLDialect

5. Person Model

For the Person entity, first of all I create a new table (persons) in my PostgreSQL database (called app).
  1. CREATE TABLE persons(
  2. id SERIAL,
  3. firstName VARCHAR(32),
  4. lastName VARCHAR(32),
  5. PRIMARY KEY(id)
  6. );
CREATE TABLE persons(
  id SERIAL,
  firstName VARCHAR(32),
  lastName VARCHAR(32),
  PRIMARY KEY(id)
);
Then I code the mapping object model. The @Table(name = "persons") annotation specifies in which table to save a Person object. The @GeneratedValue(strategy = GenerationType.IDENTITY) is quite general. In PostgreSQL I have defined the id attribute as SERIAL. In MySQL you probably want to use AUTO_INCREMENT. That’s just fine, it works with both of them.
  • Person.java
  1. package com.thomasvitale.model;
  3. import javax.persistence.Entity;
  4. import javax.persistence.GeneratedValue;
  5. import javax.persistence.GenerationType;
  6. import javax.persistence.Id;
  7. import javax.persistence.Table;
  9. @Entity
  10. @Table(name = "persons")
  11. public class Person {
  13. @Id
  14. @GeneratedValue(strategy = GenerationType.IDENTITY)
  15. private Integer id;
  17. private String firstName;
  18. private String lastName;
  20. public Person() {
  21. }
  23. public Person(String firstName, String lastName) {
  24. this.firstName = firstName;
  25. this.lastName = lastName;
  26. }
  28. public Integer getId() {
  29. return id;
  30. }
  32. public void setId(Integer id) {
  33. this.id = id;
  34. }
  36. public String getFirstName() {
  37. return firstName;
  38. }
  40. public void setFirstName(String firstName) {
  41. this.firstName = firstName;
  42. }
  44. public String getLastName() {
  45. return lastName;
  46. }
  48. public void setLastName(String lastName) {
  49. this.lastName = lastName;
  50. }
  52. @Override
  53. public String toString() {
  54. return firstName + " " + lastName;
  55. }
  56. }
package com.thomasvitale.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "persons")
public class Person {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Integer id;
  
  private String firstName;
  private String lastName;

  public Person() {
  }

  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  public Integer getId() {
    return id;
  }

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

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  @Override
  public String toString() {
    return firstName + " " + lastName;
  }
}

6. Person Repository

Our PersonRepository extends the JpaRepository interface, that provides us with a lot of operations out-of-the-box, including the standard CRUD operations. You can also add custom operations like findByFirstName and findByLastName without writing any implementation: Spring Data JPA creates them for you!
  • PersonRepository.java
  1. package com.thomasvitale.repository;
  3. import java.util.List;
  5. import org.springframework.data.jpa.repository.JpaRepository;
  6. import org.springframework.stereotype.Repository;
  8. import com.thomasvitale.model.Person;
  10. @Repository
  11. public interface PersonRepository extends JpaRepository<Person, Integer> {
  13. public Person findByFirstName(String firstName);
  14. public List<Person> findByLastName(String lastName);
  16. }
package com.thomasvitale.repository;

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.thomasvitale.model.Person;

@Repository
public interface PersonRepository extends JpaRepository<Person, Integer> {
  
  public Person findByFirstName(String firstName);
  public List<Person> findByLastName(String lastName);
  
}

7. Demo

Let’s try some CRUD operations to test our application.
  1. package com.thomasvitale;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.boot.CommandLineRunner;
  5. import org.springframework.boot.SpringApplication;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  8. import com.thomasvitale.model.Person;
  9. import com.thomasvitale.repository.PersonRepository;
  11. @SpringBootApplication
  12. public class Application implements CommandLineRunner {
  14. @Autowired
  15. PersonRepository personRepository;
  17. public static void main(String[] args) {
  18. SpringApplication.run(Application.class, args);
  19. }
  21. @Override
  22. public void run(String... arg0) throws Exception {
  24. // Save three Person documents on PostgreSQL
  25. personRepository.save(new Person("Sheldon", "Cooper"));
  26. personRepository.save(new Person("Missy", "Cooper"));
  27. personRepository.save(new Person("Leonard", "Hofstadter"));
  29. // Get all the people
  30. System.out.println(">>> All the people in the database:");
  31. personRepository.findAll().forEach(System.out::println);
  33. // Get all the people with a specific last name
  34. System.out.println(">>> All people with last name = 'Cooper'");
  35. personRepository.findByLastName("Cooper").forEach(System.out::println);
  37. // Update an individual person
  38. Person person = personRepository.findByFirstName("Sheldon");
  39. person.setFirstName("Shelly");
  40. personRepository.save(person);
  42. // Delete all
  43. personRepository.deleteAll();
  45. }
  46. }
package com.thomasvitale;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.thomasvitale.model.Person;
import com.thomasvitale.repository.PersonRepository;

@SpringBootApplication
public class Application implements CommandLineRunner {
  
  @Autowired
  PersonRepository personRepository;

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }

  @Override
  public void run(String... arg0) throws Exception {
    
      // Save three Person documents on PostgreSQL
      personRepository.save(new Person("Sheldon", "Cooper"));
      personRepository.save(new Person("Missy", "Cooper"));
      personRepository.save(new Person("Leonard", "Hofstadter"));
      
      // Get all the people
      System.out.println(">>> All the people in the database:");
      personRepository.findAll().forEach(System.out::println);
      
      // Get all the people with a specific last name
      System.out.println(">>> All people with last name = 'Cooper'");
      personRepository.findByLastName("Cooper").forEach(System.out::println);
      
      // Update an individual person
      Person person = personRepository.findByFirstName("Sheldon");
      person.setFirstName("Shelly");
      personRepository.save(person);
      
      // Delete all 
      personRepository.deleteAll();
    
  }
}

Resources

FacebookTwitterLinkedInGoogle+PinterestShare

0 comentarios:

Publicar un comentario

Suscribirse a: Enviar comentarios (Atom)