Spring Boot Backend Development Course, Blog Creation Example, Writing Service Method Code

Blog Creation Example: Writing Service Method Code

This tutorial covers how to create a simple blog using Spring Boot. We will implement CRUD (Create, Read, Update, Delete) functionalities for blog posts. This tutorial will proceed step-by-step from the basic setup of Spring Boot to writing service method code.

1. Introduction to Spring Boot

Spring Boot is a framework that simplifies the configuration of the Spring Framework and helps create standalone applications easily. Spring Boot provides various starter dependencies and supports rapid development and deployment. In this tutorial, we will use Spring Boot to create a RESTful API and implement CRUD functionalities.

2. Setting Up Development Environment

To develop a Spring Boot application, you need the Java Development Kit (JDK) and an Integrated Development Environment (IDE). IntelliJ IDEA or Eclipse is recommended, and you will need JDK version 11 or higher.

https://spring.io/projects/spring-boot

2.1. Creating a Project

You can use Spring Initializr to create a Spring Boot project. Please use the following settings:

Project: Maven Project
Language: Java
Spring Boot: 2.5.x (choose the latest stable version)
Group: com.example
Artifact: blog
Dependencies: Spring Web, Spring Data JPA, H2 Database (or MySQL)

2.2. Project Structure

Once the Spring Boot project is created, it has the following basic structure:


blog
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── blog
│   │   │               ├── BlogApplication.java
│   │   │               ├── controller
│   │   │               ├── model
│   │   │               └── repository
│   │   └── resources
│   │       ├── application.properties
│   │       └── static
│   └── test
└── pom.xml

3. Writing Blog Model Class

We will write a model class that can represent a blog post. Below is an example of the Post model class:

package com.example.blog.model;

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

@Entity
public class Post {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String title;

    @Column(nullable = false, length = 1000)
    private String content;

    // Constructor, getter, setter omitted
}

4. Writing Repository Interface

To interact with the database, we will write a repository class. Since we will be using Spring Data JPA, we can simply define the interface:

package com.example.blog.repository;

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

public interface PostRepository extends JpaRepository<Post, Long> {
}

5. Writing Service Class

We will write a service class to handle business logic. The service class will implement methods for CRUD functionalities:

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;
import java.util.Optional;

@Service
public class PostService {
    @Autowired
    private PostRepository postRepository;

    // Retrieve list of posts
    public List<Post> findAll() {
        return postRepository.findAll();
    }

    // Add a post
    public Post save(Post post) {
        return postRepository.save(post);
    }

    // Retrieve a post
    public Optional<Post> findById(Long id) {
        return postRepository.findById(id);
    }

    // Update a post
    public Post update(Long id, Post postDetails) {
        Post post = postRepository.findById(id).orElseThrow(() -> new RuntimeException("Post not found."));
        post.setTitle(postDetails.getTitle());
        post.setContent(postDetails.getContent());
        return postRepository.save(post);
    }

    // Delete a post
    public void delete(Long id) {
        postRepository.deleteById(id);
    }
}

6. Writing Controller Class

We will write a REST controller class to handle client requests. This class will receive HTTP requests and call appropriate service methods:

package com.example.blog.controller;

import com.example.blog.model.Post;
import com.example.blog.service.PostService;
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 {
    @Autowired
    private PostService postService;

    // Retrieve list of posts
    @GetMapping
    public List<Post> getAllPosts() {
        return postService.findAll();
    }

    // Add a post
    @PostMapping
    public Post createPost(@RequestBody Post post) {
        return postService.save(post);
    }

    // Retrieve a post
    @GetMapping("/{id}")
    public ResponseEntity<Post> getPostById(@PathVariable Long id) {
        return postService.findById(id)
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }

    // Update a post
    @PutMapping("/{id}")
    public ResponseEntity<Post> updatePost(@PathVariable Long id, @RequestBody Post postDetails) {
        try {
            Post updatedPost = postService.update(id, postDetails);
            return ResponseEntity.ok(updatedPost);
        } catch (RuntimeException e) {
            return ResponseEntity.notFound().build();
        }
    }

    // Delete a post
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deletePost(@PathVariable Long id) {
        postService.delete(id);
        return ResponseEntity.noContent().build();
    }
}

7. Application Configuration

Add database settings in the application.properties file. If you are using H2 database, set it up as follows:


spring.h2.console.enabled=true
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

8. Running the Application

Once all the settings are complete, you can run the application. You can run the BlogApplication.java class using your IDE, or use the command below in the terminal:

mvn spring-boot:run

9. API Testing with Postman

Once the application is running correctly, you can use Postman to test the API. Here are various HTTP requests you can use:

GET /api/posts – Retrieve all posts
POST /api/posts – Add a post
GET /api/posts/{id} – Retrieve a specific post
PUT /api/posts/{id} – Update a post
DELETE /api/posts/{id} – Delete a post

Conclusion

In this tutorial, we explained how to implement the backend of a blog application using Spring Boot. We established services and REST APIs that provide CRUD functionalities, allowing users to manage blog posts. We hope this tutorial helps you understand the fundamentals of Spring Boot and lays the groundwork for actual application development.