Spring Boot CRUD Example with MySQL

In this tutorial, we will create a Spring Boot CRUD (Create, Read, Update, Delete) application with MySQL. We will cover setting up the project, configuring MySQL, creating the necessary entities and repositories, implementing the service layer, and creating RESTful controllers to handle CRUD operations.

Prerequisites

Before we start, ensure you have the following:

• Java Development Kit (JDK) installed
• Apache Maven installed
• MySQL installed
• An IDE (such as IntelliJ IDEA, Eclipse, or VS Code) installed

Step 1: Setting Up the Project

1.1 Create a Spring Boot Project

1. Open Spring Initializr:

   • Go to Spring Initializr in your web browser.

2. Configure Project Metadata:

   • Project: Maven Project
   • Language: Java
   • Spring Boot: Select the latest version of Spring Boot
   • Group: com.example
   • Artifact: spring-boot-mysql-crud
   • Name: spring-boot-mysql-crud
   • Description: Spring Boot CRUD example with MySQL
   • Package Name: com.example.springbootmysqlcrud
   • Packaging: Jar
   • Java Version: 17 (or your preferred version)
   • Click Next.

3. Select Dependencies:

   • Select the following dependencies:
     • Spring Web
     • Spring Data JPA
     • MySQL Driver
     • Spring Boot DevTools
   • Click Next.

4. Generate the Project:

   • Click Generate to download the project zip file.
   • Extract the zip file to your desired location.

5. Open the Project in Your IDE:

   • Open your IDE and import the project as a Maven project.

1.2 Project Structure

After importing the project, create packaging structure as per below structure:

spring-boot-mysql-crud
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── springbootmysqlcrud
│   │   │               ├── SpringBootMysqlCrudApplication.java
│   │   │               ├── controller
│   │   │               ├── model
│   │   │               ├── repository
│   │   │               └── service
│   ├── main
│   │   └── resources
│   │       ├── application.properties
│   └── test
│       └── java
│           └── com
│               └── example
│                   └── springbootmysqlcrud
│                       └── SpringBootMysqlCrudApplicationTests.java
└── pom.xml

Step 2: Configuring MySQL

2.1 Create a MySQL Database

1. Open your MySQL client (MySQL Workbench, command line, etc.).
2. Create a new database named springbootdb:

   CREATE DATABASE springbootdb;
   

2.2 Configure Spring Boot to Use MySQL

Open the application.properties file located in the src/main/resources directory and add the following configuration:

spring.datasource.url=jdbc:mysql://localhost:3306/springbootdb?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

Replace yourpassword with the password for your MySQL root user.

Step 3: Creating the Entity

3.1 Create the Employee Entity

In the model package, create a new Java class named Employee:

package com.example.springbootmysqlcrud.model;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Employee {

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

    // Getters and Setters

    public Long getId() {
        return id;
    }

    public void setId(Long 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;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Step 4: Creating the Repository

4.1 Create the EmployeeRepository Interface

In the repository package, create a new Java interface named EmployeeRepository:

package com.example.springbootmysqlcrud.repository;

import com.example.springbootmysqlcrud.model.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Long> {
}

Step 5: Creating the Service

5.1 Create the EmployeeService Interface

In the service package, create a new Java interface named EmployeeService:

package com.example.springbootmysqlcrud.service;

import com.example.springbootmysqlcrud.model.Employee;

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

public interface EmployeeService {
    List<Employee> getAllEmployees();
    Optional<Employee> getEmployeeById(Long id);
    Employee saveEmployee(Employee employee);
    Employee updateEmployee(Employee employee);
    void deleteEmployee(Long id);
}

5.2 Implement the EmployeeService Interface

In the service package, create a new Java class named EmployeeServiceImpl:

package com.example.springbootmysqlcrud.service;

import com.example.springbootmysqlcrud.model.Employee;
import com.example.springbootmysqlcrud.repository.EmployeeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class EmployeeServiceImpl implements EmployeeService {

    @Autowired
    private EmployeeRepository employeeRepository;

    @Override
    public List<Employee> getAllEmployees() {
        return employeeRepository.findAll();
    }

    @Override
    public Optional<Employee> getEmployeeById(Long id) {
        return employeeRepository.findById(id);
    }

    @Override
    public Employee saveEmployee(Employee employee) {
        return employeeRepository.save(employee);
    }

    @Override
    public Employee updateEmployee(Employee employee) {
        return employeeRepository.save(employee);
    }

    @Override
    public void deleteEmployee(Long id) {
        employeeRepository.deleteById(id);
    }
}

Step 6: Creating the Controller

6.1 Create the EmployeeController Class

In the controller package, create a new Java class named EmployeeController:

package com.example.springbootmysqlcrud.controller;

import com.example.springbootmysqlcrud.model.Employee;
import com.example.springbootmysqlcrud.service.EmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

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

@RestController
@RequestMapping("/api/employees")
public class EmployeeController {

    @Autowired
    private EmployeeService employeeService;

    @GetMapping
    public List<Employee> getAllEmployees() {
        return employeeService.getAllEmployees();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Employee> getEmployeeById(@PathVariable Long id) {
        Optional<Employee> employee = employeeService.getEmployeeById(id);
        return employee.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
    }

    @PostMapping
    public Employee createEmployee(@RequestBody Employee employee) {
        return employeeService.saveEmployee(employee);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Employee> updateEmployee(@PathVariable Long id, @RequestBody Employee employeeDetails) {
        Optional<Employee> employeeOptional = employeeService.getEmployeeById(id);
        if (employeeOptional.isPresent()) {
            Employee employee = employeeOptional.get();
            employee.setFirstName(employeeDetails.getFirstName());
            employee.setLastName(employeeDetails.getLastName());
            employee.setEmail(employeeDetails.getEmail());
            return ResponseEntity.ok(employeeService.updateEmployee(employee));
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteEmployee(@PathVariable Long id) {
        Optional<Employee> employee = employeeService.getEmployeeById(id);
        if (employee.isPresent()) {
            employeeService.deleteEmployee(id);
            return ResponseEntity.noContent().build();
        } else {
            return ResponseEntity.notFound().build();
        }
    }
}

Step 7: Running the Application

1. Run the Application:
   • Open the SpringBootMysqlCrudApplication class in the src/main/java/com/example/springbootmysqlcrud directory.
   • Click the green Run button in your IDE or use the terminal to run the application: sh ./mvnw spring-boot:run

2. Verify the Application:
   • Open your web browser or a tool like Postman and navigate to http://localhost:8080/api/employees.

You can now perform CRUD operations on the Employee entity using the following endpoints:

• GET /api/employees: Get all employees
• GET /api/employees/{id}: Get employee by ID
• POST /api/employees: Create a new employee
• PUT /api/employees/{id}: Update an existing employee
• DELETE /api/employees/{id}: Delete an employee

Conclusion

In this tutorial, we have walked through the process of creating a Spring Boot CRUD application with MySQL. We configured the project, set up MySQL, created the necessary entities, repositories, services, and controllers, and tested the CRUD operations. This setup provides a solid foundation for developing more complex Spring Boot applications with MySQL.