Spring Data REST example – DEV Community

On this tutorial, we’re gonna construct a Spring Information REST instance in Spring Boot CRUD REST API with Maven that makes use of Spring Information JPA to work together with H2 database with out having to manually implement controller and dealing with HTTP requests. You may know:

• Learn how to configure Spring Information REST, JPA, Hibernate to work with Database
• Learn how to outline Information Fashions and Repository interfaces
• Manner to make use of Spring Information JPA to work together with H2 Database
• Learn how to examine CRUD operations with Postman

Spring Information REST vs Spring Information JPA

Spring Information REST and Spring Information JPA are each initiatives throughout the bigger Spring Information umbrella, and so they serve totally different functions within the context of constructing data-centric purposes with Spring.

Spring Information JPA is commonly used along side Spring Information REST. Spring Information REST can routinely expose Spring Information JPA repositories as RESTful APIs. Which means that as soon as you’ve got outlined your JPA entities and repositories utilizing Spring Information JPA, you should utilize Spring Information REST to show these repositories as RESTful companies with out having to put in writing further controller code.

Spring Information JPA

• Objective: Spring Information JPA simplifies the event of knowledge entry layers by offering a set of abstractions and utilities for working with JPA (Java Persistence API) implementations.
• Options:
  • Automated CRUD (Create, Learn, Replace, Delete) repository era primarily based on JPA entities.
  • Question strategies derived from technique names in repository interfaces.
  • Customized queries utilizing JPQL (Java Persistence Question Language) or native SQL.
  • Pagination, sorting, and different frequent information entry operations are supported.
• Utilization: In the event you want a knowledge entry layer for working with a relational database and wish to leverage JPA for that objective, Spring Information JPA is an efficient alternative. It offers a higher-level abstraction over JPA, making it simpler to work with databases in a Spring utility.

For extra instance, kindly go to:

Spring Information REST

Overview of Spring Information REST instance

We’ll construct a Spring Boot Information REST instance for a Tutorial utility in that:

• Every Tutorial has id, title, description, revealed standing.
• We will create, retrieve, replace, delete Tutorials.
• We now have customized finder strategies equivalent to discover by revealed standing or by title.

These are REST APIs that we offer:

We even have APIs for:

• discover all revealed/unpublished Tutorials:
  GET /api/tutorials/search/findByPublished?revealed=[status]

• discover all Tutorials which title accommodates key phrase
/api/tutorials/search/findByTitleContainingIgnoreCase?title=

Know-how

• Java 17 / 11 / 8
• Spring Boot 3 / 2 (with Spring Information REST, Spring Information JPA)
• H2 Database
• Maven

Undertaking Construction

Let me clarify it briefly.

– Tutorial information mannequin class corresponds to entity and desk tutorials.
– TutorialRepository is an interface that extends JpaRepository for CRUD strategies and customized finder strategies.
– Configuration for Spring Information REST, Datasource, JPA & Hibernate in utility.properties.
– pom.xml accommodates dependencies for Spring Boot and H2.

We will enhance the instance by including Feedback for every Tutorial. It’s the One-to-Many Relationship and I write a tutorial for this at:
Spring Boot One To Many example with JPA, Hibernate

Or add Tags with Many-to-Many Relationship:
Spring Boot Many to Many example with JPA, Hibernate

Create & Setup Spring Boot undertaking

Use Spring web tool or your growth instrument (Spring Tool Suite, Eclipse, Intellij) to create a Spring Boot undertaking.

Then open pom.xml and add these dependencies:

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

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

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Configure Spring Information REST, JPA, h2, Hibernate

Underneath src/essential/assets folder, open utility.properties and write these traces.

spring.information.relaxation.basePath=api

spring.h2.console.enabled=true
# default path: h2-console
spring.h2.console.path=/h2-ui

spring.datasource.url=jdbc:h2:file:./testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto= replace

• spring.information.relaxation.basePath: the basis URI for Spring Information REST
• spring.datasource.url: jdbc:h2:mem:[database-name] for In-memory database and jdbc:h2:file:[path/database-name] for disk-based database.
• spring.datasource.username & spring.datasource.password properties are the identical as your database set up.
• Spring Boot makes use of Hibernate for JPA implementation, we configure H2Dialect for H2 Database
• spring.jpa.hibernate.ddl-auto is used for database initialization. We set the worth to replace worth so {that a} desk might be created within the database routinely equivalent to outlined information mannequin. Any change to the mannequin can even set off an replace to the desk. For manufacturing, this property needs to be validate.
• spring.h2.console.enabled=true tells the Spring to begin H2 Database administration instrument and you may entry this instrument on the browser: http://localhost:8080/h2-console.
• spring.h2.console.path=/h2-ui is for H2 console’s url, so the default url http://localhost:8080/h2-console will change to http://localhost:8080/h2-ui.

You may as well alter the next Spring Information REST properties (beginning with spring.information.relaxation.):

• defaultPageSize: change the default for the variety of objects served in a single web page.
• maxPageSize: change the utmost variety of objects in a single web page.
• pageParamName: change the title of the question parameter for choosing pages.
• limitParamName: change the title of the question parameter for the variety of objects to point out in a web page.
• sortParamName: change the title of the question parameter for sorting.
• defaultMediaType: change the default media sort to make use of when none is specified.
• returnBodyOnCreate: change whether or not a physique needs to be returned when creating a brand new entity.
• returnBodyOnUpdate: change whether or not a physique needs to be returned when updating an entity.

Outline Information Mannequin

Our Information mannequin is Tutorial with 4 fields: id, title, description, revealed.
In mannequin bundle, we outline Tutorial class.

mannequin/Tutorial.java

bundle com.bezkoder.spring.information.relaxation.mannequin;

import jakarta.persistence.*;

@Entity
@Desk(title = "tutorials")
public class Tutorial {

  @Id
  @GeneratedValue(technique = GenerationType.AUTO)
  non-public lengthy id;

  @Column(title = "title")
  non-public String title;

  @Column(title = "description")
  non-public String description;

  @Column(title = "revealed")
  non-public boolean revealed;

  public Tutorial() {

  }

  public Tutorial(String title, String description, boolean revealed) {
    this.title = title;
    this.description = description;
    this.revealed = revealed;
  }

  // getters and setters...

}

• @Entity annotation signifies that the category is a persistent Java class.
• @Desk annotation offers the desk that maps this entity.
• @Id annotation is for the first key.
• @GeneratedValue annotation is used to outline era technique for the first key. GenerationType.AUTO means Auto Increment discipline.
• @Column annotation is used to outline the column in database that maps annotated discipline.

Create Repository Interface

Let’s create a repository to work together with Tutorials from the database.
In repository bundle, create TutorialRepository interface that extends JpaRepository.

repository/TutorialRepository.java

bundle com.bezkoder.spring.information.relaxation.repository;

import java.util.Listing;

import org.springframework.information.jpa.repository.JpaRepository;
import org.springframework.information.relaxation.core.annotation.RepositoryRestResource;
import org.springframework.net.bind.annotation.CrossOrigin;

import com.bezkoder.spring.information.relaxation.mannequin.Tutorial;

@RepositoryRestResource(path="tutorials")
public interface TutorialRepository extends JpaRepository<Tutorial, Lengthy> {
  Listing<Tutorial> findByPublished(boolean revealed);

  Listing<Tutorial> findByTitleContainingIgnoreCase(String title);
}

To show the repository as a RESTful useful resource, you annotate the repository interface with @RepositoryRestResource. This annotation lets you customise the RESTful endpoints and habits, and path defines the bottom URI path for the useful resource.

We additionally outline customized finder strategies:

• findByPublished(): returns all Tutorials with revealed having worth as enter revealed.
• findByTitleContaining(): returns all Tutorials which title accommodates enter title.

The implementation is plugged in by Spring Data JPA routinely.

Extra Derived queries at:
JPA Repository query example in Spring Boot

Customized question with @Question annotation:
Spring JPA @Query example: Custom query in Spring Boot

You may modify this Repository:

You additionally discover approach to write Unit Check for this JPA Repository at:
Spring Boot Unit Test for JPA Repository with @DataJpaTest

Configure CORS in Spring Information REST

We add a @CrossOrigin annotation to the repository interface to allow CORS for the entire TutorialRepository repository.

By default, @CrossOrigin permits all origins and HTTP strategies.

repository/TutorialRepository.java

// ...
import org.springframework.net.bind.annotation.CrossOrigin;

@CrossOrigin
@RepositoryRestResource(path="tutorials")
public interface TutorialRepository extends JpaRepository<Tutorial, Lengthy> {
  // ...
}

We will present one origin, restricted to a number of HTTP strategies with a selected max age.

@CrossOrigin(origins = "http://yourdomain.instance",
  strategies = { RequestMethod.GET, RequestMethod.POST, RequestMethod.DELETE },
  maxAge = 3600)
@RepositoryRestResource(path="tutorials")
public interface TutorialRepository extends JpaRepository<Tutorial, Lengthy> {
  // ...
}

Run & Check

Run Spring Boot utility with command: mvn spring-boot:run.

tutorials desk might be routinely generated in Database.

Let’s open H2 console with url: http://localhost:8080/h2-ui:

Click on on Join button, then examine H2 database, you may see issues like this:

Create some Tutorials:

Retrieve all Tutorials:

Retrieve a Tutorial by Id:

Replace some Tutorials:

The desk information is modified:

Spring Information REST to filter all revealed Tutorials:

Discover all Tutorials which title accommodates string ‘information’:

Delete a Tutorial:

Verify database and it has been already deleted.

Conclusion

Immediately we have constructed a Spring Boot Relaxation CRUD API utilizing Spring Information REST instance and make Spring Information JPA work with H2 Database.

We additionally see that JpaRepository helps a good way to make CRUD operations and customized finder strategies with out want of boilerplate code.

Completely happy studying! See you once more.

Additional Studying

Fullstack CRUD App:

If you wish to add Pagination to this Spring undertaking, you’ll find the instruction at:
Spring Boot Pagination & Filter example | Spring JPA, Pageable

To kind/order by a number of fields:
Spring Data JPA Sort/Order by multiple Columns | Spring Boot

Or approach to write Unit Check:
Spring Boot Unit Test for JPA Repository

We will enhance the instance by including Feedback for every Tutorial. It’s the One-to-Many Relationship and I write a tutorial for this at:
Spring Boot One To Many example with JPA, Hibernate

Or add Tags with Many-to-Many Relationship:
Spring Boot Many to Many example with JPA, Hibernate

Supply Code

You’ll find the whole supply code for this tutorial on Github.

With Relaxation Controller: Spring Boot JPA + H2 example: Build a CRUD Rest APIs
Or APIs with GraphQL:Spring Boot + GraphQL example

Extra JPA queries at:

Validation:
Validate Request Body in Spring Boot

Reactive with R2DBC:
Spring Boot R2DBC + H2 example

Documentation: Spring Boot + Swagger 3 example (with OpenAPI 3)
Caching: Spring Boot Redis Cache example