Spring Data JPA Tutorial: CRUD

标签：

http://www.petrikainulainen.net/programming/spring-framework/spring-data-jpa-tutorial-part-two-crud/ 

We have now configured the persistence layer of our Spring application. We are finally ready to create our first Spring Data JPA repository.

This blog post describes how we can create a repository that provides CRUD operations for todo entries.

Let’s get started.

Creating the Repository

Before we can create our first Spring Data JPA repository, we have to create an entity class that contains the information of a single todo entry. The relevant part of the Todo class looks as follows:

We are now ready to create our first Spring Data JPA repository. We can create the repository that provides CRUD operations for Todo objects by using one of the following methods:

1. Create an interface that extends the CrudRepository interface.
2. Create an interface that extends the Repository interface and add the required methods to the created interface.

Let’s take a closer look at these methods.

Extending the CrudRepository Interface

If we create our repository by extending the CrudRepository interface, we have to provide two type parameters:

1. The type of the entity that is managed by our repository.
2. The type of the entity’s id field.

In other words, when we create the repository that provides CRUD operations for Todo objects, we have to provide the following type parameters:

1. The type of the entity is Todo.
2. The type of the entity’s id field is Long.

The source code of the TodoRepository interface looks as follows:

The CrudRepository interface declares many methods, but the methods that are relevant for this blog post are described in the following:

• The void delete(T entity) method deletes the entity whose id is given as a method parameter.
• The Iterable<T> findAll() method returns all entities that are saved to the database.
• The T findOne(Long id) method returns the entity whose id is given as method parameter. If no entity is found, this method returns null.
• The T save(T entity) method saves the entity given as a method parameter and returns the persisted entity.

Let’s find out how we can create a repository interface that extends the Repository interface.

Extending the Repository Interface

If we create our repository by extending the Repository interface, we have to follow these steps:

1. Provide two type parameters:
   1. The type of the managed entity (Todo).
   2. The type of the entity’s id field (Long).
2. Add the required methods to the repository interface:
   1. The void delete(Todo deleted) method deletes the Todo object given as a method parameter.
   2. The List<Todo> findAll() method returns all Todo objects that are found from the database.
   3. The Optional<Todo> findOne(Long id) method finds the todo entry whose id is given as a method parameter. If no todo entry is found, this method returns an empty Optional.
   4. The Todo save(Todo persisted) method saves the Todo object given as a method parameter and returns the persisted object.

The source code of the TodoRepository interface looks as follows:

Let’s move on and find out which method we should use.

Which Method Should We Use?

It depends.

I know that this is probably the most annoying answer one can give to a question. That is why I created two rules that we can follow when we are creating Spring Data JPA repositories. These rules are:

• If we want to expose all repository methods that are declared by the CrudRepository interface AND we don’t want to return Optional (Guava / Java 8) objects, our repository interfaces should extend the CrudRepository interface.
• If we don’t want to expose all repository methods that are declared by the CrudRepository interface OR we want to return Optional (Guava / Java 8) objects, our repository interfaces must extend the Repository interface.

Case closed?

Not exactly. I argue that we should always use the second method. This opinion is based on two reasons:

• When we create an interface, we should not add unnecessary methods to it. We should keep the interface as small as possible because small interfaces are easier to use and they help us to create components that have only one job.
• Optional helps us to create better APIs because it reveals that there might not be a return value.

If we create our repositories by extending the Repository interface and adding the required methods to the created repository interfaces, we need to add the “same” methods to every interface. Right?

Wrong.

We can avoid this by following these steps:

1. Create a base interface that extends the Repository interface and add the common methods to that interface.
2. Create the actual repository interface that extends our base interface.

Let’s move on and take a closer look at these steps.

First, we have to create a base interface that declares the methods shared by our repositories. We can do this by following these steps:

1. Create the BaseRepository interface that extends the Repository interface. This interface has two type parameters:
   1. T describes the type of the managed entity.
   2. ID describes the type of the entity’s id field.
2. Annotate the created interface with the @NoRepositoryBean annotation. This ensures that Spring Data JPA doesn’t try to create an implementation for our base repository interface.
3. Add the common methods to the created interface.

The source code of the BaseRepository interface looks as follows:

Second, we have to create the actual repository interface that extends our base interface. We can do this by following these steps:

1. Create the TodoRepository interface.
2. Extend the BaseRepository interface and provide two type parameters:
   1. The type of the managed entity is Todo.
   2. The type of the entity’s id field is Long.

The source code of the TodoRepository interface looks as follows:

We have now created a repository hierarchy that allows us to:

• Create repositories that provides CRUD operations for entities without declaring the “same” methods in every repository interface.
• Create repositories that do not provide all CRUD operations. For example, we can create a repository that provides only the findAll() method.

The following figure illustrates the benefits of this solution:

Let’s move on and summarize what we learned from this blog post.

Summary

This blog post has taught us three things:

• We can create repository interfaces by extending either the CrudRepository or the Repository interface.
• We should create our repositories by extending the Repository interface and adding the required methods to the created repository interface.
• If our application has more than one repository, we should create a base repository interface that declares the methods that are shared by our “concrete” repositories.

The next part of this tutorial describes how we can create database queries by using query methods.

P.S. You can get the example application of this blog post from Github.

Spring Data JPA Tutorial: CRUD

标签：

原文地址：http://www.cnblogs.com/glenblogs/p/4223054.html