Create a RESTful Web Service with Spring Boot & Database connection

Last updated on Jan 30, 2023

Spring Boot is a popular framework for building Java applications, and it makes it easy to create a RESTful web service with a database. In this tutorial, we'll create a simple Spring Boot project with a REST controller and a database using the Spring Initializer.

Set up the Environment:

Install the latest version of the JDK
Install a Java Integrated Development Environment (IDE) such as IntelliJ IDEA or Eclipse.
Install the latest version of Maven.

2. Create a new Project

Open the IDE and click on "Create New Project."
Choose "Spring Initializer" as the project type.
Fill in the required information, such as the project name and package name.
Choose the necessary dependencies. For this tutorial, choose "Spring Web" and "Spring Data JPA."
Click on "Generate" to create the project.

3. Set up the database

Choose a database management system, such as MySQL or PostgreSQL, and install it.
Connect to the database using a client, such as MySQL Workbench or pgAdmin.
Create a new database for the project.
In the application.properties file, specify the database connection details, such as the URL, username, and password.

spring.datasource.url=jdbc:postgresql://localhost:5432/records_db
spring.datasource.username=postgres
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.show-sql=true

4. Create a Model class:

Create a new package in the project called "models."
Create a new class in the package and annotate it with @Entity. This indicates that the class represents a database entity.
Add fields to the class, such as id, name, and email. Annotate each field with @Column to indicate that it maps to a column in the database.
Add getters and setters for each field.

package com.example.models;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Record {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private String email;

    public Record() {}

    public Record(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

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

5. Create a Repository:

Create a new package in the project called "repositories."
Create a new interface in the package and extend JpaRepository.
Specify the model class and the type of the primary key as the generic types of the interface.

package com.example.repositories;

import org.springframework.data.jpa.repository.JpaRepository;

import com.example.models.Record;

public interface RecordRepository extends JpaRepository<Record, Long> {}

6. Create a REST controller:

Create a new package in the project called "controllers."
Create a new class in the package and annotate it with @RestController.
Inject the repository into the class using @Autowired.
Create methods to handle HTTP requests, such as GET, POST, PUT, and DELETE. Use @GetMapping, @PostMapping, @PutMapping, and @DeleteMapping to map the methods to the appropriate HTTP methods.
Use the repository to perform CRUD operations on the database.

package com.example.controllers;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.example.models.Record;
import com.example.repositories.RecordRepository;

@RestController
public class RecordController {

    @Autowired
    private RecordRepository recordRepository;

    @GetMapping("/records")
    public List<Record> getAllRecords() {
        return recordRepository.findAll();
    }

    @GetMapping("/records/{id}")
    public Record getRecordById(@PathVariable Long id) {
        return recordRepository.findById(id).orElse(null);
    }

    @PostMapping("/records")
    public Record createRecord(@RequestBody Record record) {
        return recordRepository.save(record);
    }

    @PutMapping("/records/{id}")
    public Record updateRecord(@PathVariable Long id, @RequestBody Record record) {
        record.setId(id);
        return recordRepository.save(record);
    }

    @DeleteMapping("/records/{id}")
    public void deleteRecord(@PathVariable Long id) {
        recordRepository.deleteById(id);
    }
}

7. Run the Application

In the IDE, right-click on the main class and choose "Run."
Open a web browser and access the endpoint specified in the controller method. For example, if you have a GET method that returns all the records, you can access it by visiting http://localhost:8080/records.

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

8. Test the application:

Use a tool such as Postman to test the various endpoints in the REST controller.
Verify that the data is being stored and retrieved from the database as expected.

This tutorial demonstrates how to create a simple Spring Boot project with a REST controller and a database. You can build upon this foundation to create more complex applications as needed.