Spring Boot Backend Development Course, Blog Production Example, Writing Controller Method Code

Hello! In this course, we will learn how to create a blog using Spring Boot and explore in-depth how to write controller methods. Spring Boot is a Java-based framework that helps you easily develop web applications. In this course, we will implement basic blog functions and aim to build a RESTful API.

1. Introduction to Spring Boot

Spring Boot is an extension of the Spring framework that makes it easier to set up and run Spring applications. The main goal is to reduce complex Spring configurations and help you start applications quickly.

1.1. Advantages of Spring Boot

  • Quick Start: Embedded server allows you to run applications in a short time
  • Auto Configuration: Automatically sets up various libraries and frameworks
  • Flexible Configuration: Easily manage application settings through configuration files

2. Setting Up the Development Environment

Before starting the blog project, let’s set up the necessary development environment. Below are the essential components you need to install for Spring Boot.

  • Java Development Kit (JDK): Install JDK 8 or higher.
  • IDE: Install an IDE such as IntelliJ IDEA, Eclipse, or VSCode
  • Build Tool: Use Maven or Gradle for dependency management

2.1. Creating a New Spring Boot Project

You can create a new Spring Boot project using Spring Initializr. Follow the steps below:

  1. Visit the Website: Go to Spring Initializr.
  2. Enter Project Metadata: Fill in the Group, Artifact, and Name fields, and select Web, JPA, and H2 Database in Dependencies.
  3. Create the Project: Click the Generate button to download the project and open it in your IDE.

3. Designing the Blog Model

Let’s design the basic data model for the blog. Our blog will have the following Entity class.

3.1. Post Entity

package com.example.blog.model;

import lombok.Data;

import javax.persistence.*;
import java.time.LocalDateTime;

@Entity
@Data
@Table(name = "posts")
public class Post {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;
    private String content;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

The code above describes the Post class that represents a blog post. It connects to the database using JPA and automatically generates getter, setter, and toString methods through Lombok’s @Data annotation.

3.2. Creating the Repository

You need to create a Repository interface for interacting with the database. You can easily implement it using Spring Data JPA.

package com.example.blog.repository;

import com.example.blog.model.Post;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface PostRepository extends JpaRepository {
}

4. Implementing the Controller

Now, let’s implement a controller that provides a RESTful API for managing blog posts. The controller handles web requests and manages the connection between the service layer and the database.

4.1. Writing the PostController Class

package com.example.blog.controller;

import com.example.blog.model.Post;
import com.example.blog.repository.PostRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/posts")
public class PostController {
    private final PostRepository postRepository;

    @Autowired
    public PostController(PostRepository postRepository) {
        this.postRepository = postRepository;
    }

    @GetMapping
    public List getAllPosts() {
        return postRepository.findAll();
    }

    @PostMapping
    public Post createPost(@RequestBody Post post) {
        return postRepository.save(post);
    }
}

The code above defines two endpoints for creating and retrieving blog posts. @GetMapping retrieves all posts, while @PostMapping creates a new post.

4.2. Handling Requests and Responses

It is essential to handle requests sent from clients and generate appropriate responses. You can notify the client of the request processing result by returning a response along with the HTTP status code.

 @PostMapping
    public ResponseEntity createPost(@RequestBody Post post) {
        Post createdPost = postRepository.save(post);
        return ResponseEntity.status(HttpStatus.CREATED).body(createdPost);
    }

5. Adding the Service Layer

By adding a service layer that handles business logic, you can improve code separation. Splitting the interaction logic with the database into the service layer makes testing and maintenance easier.

5.1. Implementing the PostService Class

package com.example.blog.service;

import com.example.blog.model.Post;
import com.example.blog.repository.PostRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class PostService {
    private final PostRepository postRepository;

    @Autowired
    public PostService(PostRepository postRepository) {
        this.postRepository = postRepository;
    }

    public List getAllPosts() {
        return postRepository.findAll();
    }

    public Post createPost(Post post) {
        return postRepository.save(post);
    }
}

5.2. Using the Service Layer in the Controller

Modify the controller to call the service layer to perform the logic.

 @Autowired
    private PostService postService;

    @GetMapping
    public List getAllPosts() {
        return postService.getAllPosts();
    }

    @PostMapping
    public Post createPost(@RequestBody Post post) {
        return postService.createPost(post);
    }

6. Exception Handling

Let’s also discuss how to handle various exceptions that may occur in the API. You can implement an exception handler to ensure consistent responses.

6.1. Writing the GlobalExceptionHandler Class

package com.example.blog.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity handleException(Exception e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(e.getMessage());
    }
}

7. Testing the API

Finally, you can test the API using Postman or cURL. Below is an example using Postman.

7.1. Retrieve All Posts

GET http://localhost:8080/api/posts

7.2. Create a New Post

Send JSON format data to http://localhost:8080/api/posts

{
        "title": "First Blog Post",
        "content": "Hello, this is the first blog post."
    }

8. Conclusion and Future Improvements

We have looked at the basics of developing a blog backend using Spring Boot. You should now understand the essential elements needed to create a RESTful API, including writing controller methods, exception handling, and adding a service layer.

Future improvements could include adding authentication and authorization, file uploads, comments functionality, and writing test code to further enhance the blog features. If you have laid the foundation through this course, challenge yourself with more complex projects! We support your development journey.

References