Table of Contents

• What you’ll build
• What you’ll need
• Set up the project
• Define a simple entity
• Create simple queries
• Create an Application class
• Summary

This guide walks you through the process of building an application that uses Spring Data JPA to store and retrieve data in a relational database.

What you’ll build

You’ll build an application that stores Person POJOs in a memory-based database.

What you’ll need

https://raw.github.com/spring-guides/getting-started-macros/master/prereq_editor_jdk_buildtools.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/how_to_complete_this_guide.adoc

Set up the project

https://raw.github.com/spring-guides/getting-started-macros/master/build_system_intro.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/create_directory_structure_hello.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/create_both_builds.adoc build.gradle

link:initial/build.gradle[role=include]

Define a simple entity

In this example, you store Customer objects, annotated as a JPA entity.

src/main/java/hello/Customer.java

link:complete/src/main/java/hello/Customer.java[role=include]

Here you have a Customer class with three attributes, the id, the firstName, and the lastName. You also have two constructors. The default constructor only exists for the sake of JPA. You won’t use it directly, so it is designated as protected. The other constructor is the one you’ll use to create instances of Customer to be saved to the database.

Note	In this guide, the typical getters and setters have been left out for brevity.

The Customer class is annotated with @Entity, indicating that it is a JPA entity. For lack of a @Table annotation, it is assumed that this entity will be mapped to a table named Customer.

The Customer’s `id property is annotated with @Id so that JPA will recognize it as the object’s ID. The id property is also annotated with @GeneratedValue to indicate that the ID should be generated automatically.

The other two properties, firstName and lastName are left unannotated. It is assumed that they’ll be mapped to columns that share the same name as the properties themselves.

The convenient toString() method will print out the customer’s properties.

Create simple queries

Spring Data JPA focuses on using JPA to store data in a relational database. Its most compelling feature is the ability to create repository implementations automatically, at runtime, from a repository interface.

To see how this works, create a repository interface that works with Customer entities:

src/main/java/hello/CustomerRepository.java

link:complete/src/main/java/hello/CustomerRepository.java[role=include]

CustomerRepository extends the CrudRepository interface. The type of entity and ID that it works with,Customer and Long, are specified in the generic parameters on CrudRepository. By extending CrudRepository, CustomerRepository inherits several methods for working with Customer persistence, including methods for saving, deleting, and finding Customer entities.

Spring Data JPA also allows you to define other query methods by simply declaring their method signature. In the case of CustomerRepository, this is shown with a findByLastName() method.

In a typical Java application, you’d expect to write a class that implements CustomerRepository. But that’s what makes Spring Data JPA so powerful: You don’t have to write an implementation of the repository interface. Spring Data JPA creates an implementation on the fly when you run the application.

Let’s wire this up and see what it looks like!

Create an Application class

Here you create an Application class with all the components.

src/main/java/hello/Application.java

link:complete/src/main/java/hello/Application.java[role=include]

In the configuration, you need to add the @EnableJpaRepositories annotation. This annotation tells Spring Data JPA that it should seek out any interface that extends org.springframework.data.repository.Repository and automatically generate an implementation. By extending JpaRepository, your CustomerRepository interface transitively extends Repository. Therefore, Spring Data JPA will find it and create an implementation for you.

Most of the content in Application sets up several beans to support Spring Data JPA and the sample:

• The dataSource() method defines a DataSource bean, as an embedded database to which the objects are persisted.

• The entityManagerFactory() method defines a LocalContainerEntityManagerFactoryBean that is ultimately used to create a proxy bean that implements the EntityManagerFactory interface. It is the bean through which JPA operations will be performed. Note that this factory bean’s packagesToScan property is set to look for entities in the package named "hello". This makes it possible to work with JPA without defining a "persistence.xml" file.

• The jpaVendorAdapter() method defines a Hibernate-based JPA vendor adapter bean for use by the EntityManagerFactory bean.

• The transactionManager() method defines a JpaTransactionManager bean for transactional persistence.

Application includes a main() method that puts the CustomerRepository through a few tests. First, it fetches the CustomerRepository from the Spring application context. Then it saves a handful of Customer objects, demonstrating the save() method and setting up some data to work with. Next, it calls findAll() to fetch all Customer objects from the database. Then it calls findOne() to fetch a single Customer by its ID. Finally, it calls findByLastName() to find all customers whose last name is "Bauer".

https://raw.github.com/spring-guides/getting-started-macros/master/build_an_executable_jar_mainhead.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/build_an_executable_jar_with_both.adoc

https://raw.github.com/spring-guides/getting-started-macros/master/run_the_application_with_both.adoc

You should see something like this:

== Customers found with findAll():
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=2, firstName='Chloe', lastName='O'Brian']
Customer[id=3, firstName='Kim', lastName='Bauer']
Customer[id=4, firstName='David', lastName='Palmer']
Customer[id=5, firstName='Michelle', lastName='Dessler']

== Customer found with findOne(1L):
Customer[id=1, firstName='Jack', lastName='Bauer']

== Customer found with findByLastName('Bauer'):
Customer[id=1, firstName='Jack', lastName='Bauer']
Customer[id=3, firstName='Kim', lastName='Bauer']

Summary

Congratulations! You’ve written a simple application that uses Spring Data JPA to save objects to a database and to fetch them — all without writing a concrete repository implementation.