Build CRUD RESTful API Using Spring Boot 3, Spring Data JPA, Hibernate, and MySQL Database

In this tutorial, we will learn how to build CRUD RESTful API using Spring Boot 3, Spring Data JPA (Hibernate), and MySQL database.

Ramesh Fadatare

Jan. 12, 23 · Tutorial

Like (4)

Save

5.34K Views

In this tutorial, we will learn how to build CRUD RESTful API using Spring Boot 3, Spring Data JPA (Hibernate), and MySQL database.

Note that in this tutorial, we are using the latest Spring Boot version 3.0.0.

Learn complete Spring boot at Learn and Master Spring Boot

Spring Boot Project Architecture

We are going to use three-layer architecture in our Spring Boot project:

Tools and Technologies Used:

Spring Boot 3.0
Java 17
Spring Data JPA
Hibernate
MySQL Database
Maven
Postman

Create and Setup Spring Boot Project in IntelliJ

Spring Boot provides a web tool called Spring Initializer to create and bootstrap Spring Boot applications quickly. Just go here and generate a new Spring Boot project.

Refer to this screenshot to enter the details to create the Spring Boot project:

Here is the pom.xml file for your reference:

     XML 
   
 
 
   <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>net.javaguides</groupId>
    <artifactId>springboot-restful-webservices</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-restful-webservices</name>
    <description>Demo project for Spring Boot Restful Webservices</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <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-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </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>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project> 
  

Project Structure

Refer to this screenshot to create a project structure:

Configure MySQL Database

Let's first create a database, go to MySQL workbench, and use the below SQL query to create a new database:

     SQL 
   
   create database user_management

Next, open the application.propertiesfile and add the following properties to it.

     Properties files 
   
   spring.datasource.url=jdbc:mysql://localhost:3306/user_management
spring.datasource.username=root
spring.datasource.password=Mysql@123

spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
spring.jpa.hibernate.ddl-auto=update

Make sure that you change the spring.datasource.username & spring.datasource.password properties as per your MySQL installation.

In the above properties file, the last two properties are for Hibernate. Spring Boot uses Hibernate as the default JPA implementation.

The property spring.jpa.hibernate.ddl-auto is used for database initialization. I’ve used the value “update” for this property to create the database tables automatically.

Create User JPA Entity

Let's create a User class and add the following content to it:

     Java 
   
 
 
   package net.javaguides.springboot.entity;

import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(nullable = false)
    private String firstName;
    @Column(nullable = false)
    private String lastName;
    @Column(nullable = false, unique = true)
    private String email;
} 
  

Note that we are using Lombok annotations to reduce the boilerplate code (getters/setters).

Create Spring Data JPA Repository — UserRepository

Let's create a UserRepository interface that extends JpaRepository:

     Java 
   
   package net.javaguides.springboot.repository;

import net.javaguides.springboot.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {

}

Note that we do not need to add @Repository annotation because Spring Data JPA internally takes care of it.

Create Service Layer

Let's implement the service layer; we will first create an interface and then its implementation class.

Service Interface

Let's create an UserService interface and declare the following CRUD methods:

     Java 
   
   package net.javaguides.springboot.service;

import net.javaguides.springboot.entity.User;

import java.util.List;

public interface UserService {
    User createUser(User user);

    User getUserById(Long userId);

    List<User> getAllUsers();

    User updateUser(User user);

    void deleteUser(Long userId);
}

UserServiceImpl Class

Let's create UserServiceImpl class that implements UserService interface methods:

     Java 
   
 
 
   package net.javaguides.springboot.service.impl;

import lombok.AllArgsConstructor;
import net.javaguides.springboot.entity.User;
import net.javaguides.springboot.repository.UserRepository;
import net.javaguides.springboot.service.UserService;
import org.apache.logging.log4j.util.Strings;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.Objects;
import java.util.Optional;

@Service
@AllArgsConstructor
public class UserServiceImpl implements UserService {

    private UserRepository userRepository;

    @Override
    public User createUser(User user) {
        return userRepository.save(user);
    }

    @Override
    public User getUserById(Long userId) {
        Optional<User> optionalUser = userRepository.findById(userId);
        return optionalUser.get();
    }

    @Override
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    @Override
    public User updateUser(User user) {
        User existingUser = userRepository.findById(user.getId()).get();
        existingUser.setFirstName(user.getFirstName());
        existingUser.setLastName(user.getLastName());
        existingUser.setEmail(user.getEmail());
        User updatedUser = userRepository.save(existingUser);
        return updatedUser;
    }

    @Override
    public void deleteUser(Long userId) {
        userRepository.deleteById(userId);
    }
} 
  

Create Controller Layer — UserController

We’ll now create the REST APIs for creating, retrieving, updating, and deleting a User resource.

Let's create UserController class and let's build CRUD REST API's for User resource:

     Java 
   
 
 
   package net.javaguides.springboot.controller;

import lombok.AllArgsConstructor;
import net.javaguides.springboot.entity.User;
import net.javaguides.springboot.service.UserService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@AllArgsConstructor
@RequestMapping("api/users")
public class UserController {

    private UserService userService;

    // build create User REST API
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user){
        User savedUser = userService.createUser(user);
        return new ResponseEntity<>(savedUser, HttpStatus.CREATED);
    }

    // build get user by id REST API
    // http://localhost:8080/api/users/1
    @GetMapping("{id}")
    public ResponseEntity<User> getUserById(@PathVariable("id") Long userId){
        User user = userService.getUserById(userId);
        return new ResponseEntity<>(user, HttpStatus.OK);
    }

    // Build Get All Users REST API
    // http://localhost:8080/api/users
    @GetMapping
    public ResponseEntity<List<User>> getAllUsers(){
        List<User> users = userService.getAllUsers();
        return new ResponseEntity<>(users, HttpStatus.OK);
    }

    // Build Update User REST API
    @PutMapping("{id}")
    // http://localhost:8080/api/users/1
    public ResponseEntity<User> updateUser(@PathVariable("id") Long userId,
                                           @RequestBody User user){
        user.setId(userId);
        User updatedUser = userService.updateUser(user);
        return new ResponseEntity<>(updatedUser, HttpStatus.OK);
    }

    // Build Delete User REST API
    @DeleteMapping("{id}")
    public ResponseEntity<String> deleteUser(@PathVariable("id") Long userId){
        userService.deleteUser(userId);
        return new ResponseEntity<>("User successfully deleted!", HttpStatus.OK);
    }
}
 
  

Running Spring Boot Application

Run the Spring Boot Application From IDE:

From your IDE, run the SpringbootRestfulWebservicesApplication.main() method as a standalone Java class that will start the embedded Tomcat server on port 8080 and point the browser here.

Run the Spring Boot Application Using the Command Line:

Just go to the root directory of the application and type the following command to run it:

$ mvn spring-boot:run

The application will start at Spring Boot’s default tomcat port 8080.

Test CRUD RESTful WebServices Using Postman Client

Create User REST API

Request URL

HTTP Method: POST
Request Body:

   
   {
    "firstName": "ramesh",
    "lastName":"fadatare",
    "email": "ramesh@gmail.com"
}

Refer to this screenshot to test Create User REST API:

Get User REST API

Request URL

HTTP Method: GET

Refer to this screenshot to test GET User REST API:

Update User REST API

Request URL

HTTP Method: PUT
Request Body:

   
   {
    "firstName": "ram",
    "lastName":"fadatare",
    "email": "ram@gmail.com"
}

Refer to this screenshot to test the Update User REST API:

Get All Users REST API

Request URL

HTTP Method: GET

Refer to this screenshot to test GET All User REST API:

DELETE User REST API

Request URL

HTTP Method: DELETE

Refer to this screenshot to test Delete User REST API:

Source Code on GitHub

The source code of this tutorial is available on my GitHub repository at Spring Boot CRUD RESTful WebServices

Conclusion

In this tutorial, we have created a Spring boot project and built CRUD RESTful Webservices using Spring Boot 3, Spring Data JPA (Hibernate), and MySQL database.

API Database MySQL REST Spring Data Spring Boot

Published at DZone with permission of Ramesh Fadatare. See the original article here.

Opinions expressed by DZone contributors are their own.

Comments

Build CRUD RESTful API Using Spring Boot 3, Spring Data JPA, Hibernate, and MySQL Database

In this tutorial, we will learn how to build CRUD RESTful API using Spring Boot 3, Spring Data JPA (Hibernate), and MySQL database.

Spring Boot Project Architecture

Tools and Technologies Used:

Create and Setup Spring Boot Project in IntelliJ

Project Structure

Configure MySQL Database

Create User JPA Entity

Create Spring Data JPA Repository — UserRepository

Create Service Layer

Service Interface

UserServiceImpl Class

Create Controller Layer — UserController

Running Spring Boot Application

Run the Spring Boot Application From IDE:

Run the Spring Boot Application Using the Command Line:

Test CRUD RESTful WebServices Using Postman Client

Create User REST API

Get User REST API

Update User REST API

Get All Users REST API

DELETE User REST API

Source Code on GitHub

Conclusion

Popular on DZone

Partner Resources