스프링 부트 백엔드 개발 강좌, 블로그 제작 예제, 블로그 글 목록 조회를 위한 API 구현하기

안녕하세요! 이번 강좌에서는 스프링 부트를 이용하여 간단한 블로그 애플리케이션을 개발하는 방법에 대해 알아보겠습니다. 구체적으로, 블로그 글 목록을 조회하기 위한 API를 구현하는 과정을 단계별로 살펴보겠습니다. 이 강좌를 통해 스프링 부트의 기본적인 구성 요소와 RESTful API 설계의 원리를 이해하고, 실전에서 어떻게 활용할 수 있는지를 배울 수 있습니다.

1. 스프링 부트 소개

스프링 부트는 자바 기반의 웹 프레임워크인 스프링의 일환으로, 개발자가 신속하게 새로운 애플리케이션을 구축할 수 있도록 도와줍니다. 스프링 부트는 복잡한 설정을 최소화하고, 필요한 기능들을 의존성 주입을 통해 쉽게 추가할 수 있게 해줍니다. 스프링의 강력한 기능을 활용하면서도 보다 간편한 개발 경험을 제공합니다.

2. 프로젝트 설정

우선, 스프링 부트 프로젝트를 생성해야 합니다. 이를 위해 Spring Initializr를 이용할 수 있습니다.

  1. 기본 설정
    웹 페이지의 인터페이스는 RESTful API를 통해 구성하므로, ‘Spring Web’ 의존성을 추가합니다. 비즈니스 로직을 구성하기 위한 ‘Spring Data JPA’와 데이터베이스를 연결하기 위한 ‘H2 Database’를 추가합니다.
  2. 프로젝트 메타데이터
    Group: com.example
    Artifact: blog
  3. Java 버전
    Java 11 이상을 사용하도록 설정합니다.

3. 기본 디렉토리 구조

생성한 프로젝트를 IDE(예: IntelliJ IDEA)에서 열고, 기본 디렉토리 구조를 확인합니다. 프로젝트는 다음과 같은 구조를 갖게 될 것입니다.

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

4. 도메인 모델 정의

하나의 블로그 글을 표현하는 도메인 모델을 정의합니다. 이 모델은 블로그 글의 제목, 내용, 작성자, 작성 날짜 등을 포함해야 합니다.

package com.example.blog.model;

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

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

    private String title;
    private String content;
    private String author;
    
    private LocalDateTime createdDate;

    // getters and setters
}

5. JPA Repository 구현

JPA Repository를 통해 데이터베이스에 접근할 수 있도록 인터페이스를 정의합니다. 블로그 글 목록을 조회하는 메서드를 포함해야 합니다.

package com.example.blog.repository;

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

import java.util.List;

@Repository
public interface PostRepository extends JpaRepository {
    List findAll();
}

6. 서비스 레이어 구현

서비스 레이어를 만들어, 비즈니스 로직을 처리하는 클래스를 구현합니다. 여기서는 예를 들어 게시글 목록을 가져오는 메서드를 만들어 보겠습니다.

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 {
    @Autowired
    private PostRepository postRepository;

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

7. 컨트롤러 구현

RESTful API를 위한 컨트롤러를 생성하여 클라이언트의 요청을 처리합니다. 여기서는 HTTP GET 요청을 통해 블로그 글 목록을 조회하는 API를 만들겠습니다.

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.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/api/posts")
public class PostController {
    @Autowired
    private PostService postService;

    @GetMapping
    public ResponseEntity> getAllPosts() {
        List posts = postService.getAllPosts();
        return ResponseEntity.ok(posts);
    }
}

8. 애플리케이션 프로퍼티 설정

데이터베이스 연결을 위한 설정을 application.properties 파일에 추가합니다. H2 데이터베이스를 샘플로 사용합니다.

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.h2.console.enabled=true
spring.jpa.hibernate.ddl-auto=update

9. 애플리케이션 실행 및 테스트

이제 애플리케이션을 실행하고 PostController의 getAllPosts API를 테스트해 보겠습니다. Postman 또는 curl을 사용하여 아래와 같은 요청을 보내면 됩니다.

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

위의 GET 요청을 통해 미리 입력된 게시글 목록이 반환되어야 합니다.

10. 결론

이번 강좌에서는 스프링 부트를 이용하여 간단한 블로그 글 목록 조회 API를 구현해 보았습니다. 이 과정을 통해 스프링 부트의 기본적인 구조와 RESTful API의 설계 원리를 배웠습니다. 추가적으로 사용자 인증 및 CRUD 기능을 구현하여 더 나아가보는 것도 좋은 방법입니다.

더 많은 스프링 부트 관련 자료를 찾아보며, 자신의 블로그 프로젝트를 계속 발전시켜 보세요!

스프링 부트 백엔드 개발 강좌, 블로그 제작 예제, 블로그 글 목록 조회를 위한 API 구현하기 

본 강좌에서는 스프링 부트를 활용하여 블로그 글 목록 조회를 위한 API를 구현하는 방법을 살펴보겠습니다. 스프링 부트는 생산성을 극대화할 수 있는 프레임워크로, 설정과 구성이 간편하여 개발자가 본연의 비즈니스 로직에 집중할 수 있게 해줍니다. 이 강좌에서는 블로그의 기본적인 API를 설계하고 구현하는 과정을 단계별로 자세히 안내하겠습니다.

1. 스프링 부트 소개

스프링 부트(Spring Boot)는 스프링 프레임워크를 기반으로 하는 경량화된 애플리케이션 프레임워크입니다. 주로 마이크로서비스 아키텍처를 구현하는 데 자주 사용되며, 개발자가 빠르게 애플리케이션을 구성하고 배포할 수 있도록 돕습니다. 스프링 부트의 장점은 다음과 같습니다:

  • 자동 구성: 개발자가 최소한의 설정으로 프로젝트를 시작할 수 있습니다.
  • 의존성 관리: Maven 또는 Gradle을 통해 간편하게 라이브러리를 관리할 수 있습니다.
  • 내장 서버: 별도의 서버 설치 없이도 손쉽게 애플리케이션을 실행할 수 있습니다.

2. 프로젝트 준비

2.1. 개발 환경

본 강좌에서는 다음과 같은 개발 환경을 사용합니다:

  • Java 11 이상
  • Spring Boot 2.x
  • Spring Data JPA
  • H2 Database (개발용 인 메모리 데이터베이스)
  • IDEs: IntelliJ IDEA 또는 Eclipse

2.2. 프로젝트 생성

Spring Initializr(https://start.spring.io/)에 접속하여 새로운 프로젝트를 생성합니다. 다음의 의존성을 추가합니다:

  • Spring Web
  • Spring Data JPA
  • H2 Database

프로젝트 이름, 패키지 이름 등 기타 필요한 정보를 입력하고 ZIP 파일로 다운로드한 후, IDE에서 불러옵니다.

3. 데이터 모델링

블로그 글 목록을 조회하기 위해, 먼저 블로그 글을 표현할 HTMLPost 엔티티를 정의해야 합니다.

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

@Entity
public class Post {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String content;
    private String author;
    private LocalDateTime createdAt;

    // Getters and Setters omitted for brevity.
}

4. 리포지토리 계층 구현

데이터베이스와의 상호작용을 위해 JPA를 사용하여 리포지토리 인터페이스를 만들겠습니다.

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

@Repository
public interface PostRepository extends JpaRepository {
}

5. 서비스 계층 구현

비즈니스 로직을 처리하기 위해 서비스 클래스를 만들어야 합니다.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

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

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

    // Additional methods can be added here for more functionalities
}

6. 컨트롤러 구현

클라이언트 요청을 처리할 REST API를 구현하기 위해 컨트롤러 클래스를 작성합니다.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class PostController {
    @Autowired
    private PostService postService;

    @GetMapping("/api/posts")
    public ResponseEntity> getAllPosts() {
        List posts = postService.getAllPosts();
        return ResponseEntity.ok(posts);
    }
}

7. 애플리케이션 실행

이제 모든 구성 요소가 준비되었습니다. `main` 메서드가 포함된 애플리케이션 클래스에서 애플리케이션을 실행할 수 있습니다.

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

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

8. API 테스트

API가 제대로 작동하는지 테스트하기 위해 Postman이나 cURL을 사용할 수 있습니다. GET 요청을 `/api/posts`로 보내어 결과를 확인합니다.

9. 데이터베이스 초기화

테스트를 용이하게 하기 위해 몇 개의 더미 데이터를 데이터베이스에 추가할 수 있습니다. 아래와 같은 방법으로 초기 데이터를 넣어줍니다.

import javax.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class DataInitializer {

    @Autowired
    private PostRepository postRepository;

    @PostConstruct
    public void init() {
        Post post1 = new Post();
        post1.setTitle("첫 번째 블로그 글");
        post1.setContent("블로그 글 내용...");
        post1.setAuthor("작성자1");
        post1.setCreatedAt(LocalDateTime.now());

        Post post2 = new Post();
        post2.setTitle("두 번째 블로그 글");
        post2.setContent("블로그 글 내용...");
        post2.setAuthor("작성자2");
        post2.setCreatedAt(LocalDateTime.now());

        postRepository.save(post1);
        postRepository.save(post2);
    }
}

10. 결론

이번 강좌에서는 스프링 부트를 활용하여 블로그의 글 목록 조회를 위한 간단한 API를 구현해 보았습니다. 이 API는 블로그 글을 데이터베이스에서 조회하여 JSON 형식으로 클라이언트에 반환합니다. 이후에는 CRUD(Create, Read, Update, Delete) 기능 구현, 보안, 배포 등을 추가로 학습해 나갈 수 있습니다.

스프링 부트를 사용하는 것은 백엔드 개발을 더 간편하고 효율적으로 만들어 주며, 다양한 기능과 생태계를 통해 많은 개발자들이 선택하는 프레임워크입니다. 지속적인 학습과 실습을 통해 여러분의 개발 역량을 더욱 발전시켜 나가기를 바랍니다.

참고 자료

스프링 부트 백엔드 개발 강좌, 블로그 제작 예제, 리포지터리 만들기

1. 소개

스프링 부트(Spring Boot)는 Java 기반의 프레임워크로, 빠르고 간편하게 애플리케이션을 개발할 수 있도록 도와줍니다. 본 강좌는 스프링 부트를 사용하여 블로그 웹 애플리케이션을 구축하는 과정에서 필요한 핵심 개념과 기술을 설명합니다. 이 강좌를 통해 데이터베이스와의 연동, REST API 설계, 프론트엔드와의 통신 등의 내용을 다룰 것입니다.

1.1. 강좌 목표

  • 스프링 부트의 기본 개념 이해
  • RESTful API 설계 및 구현
  • JPA를 이용한 데이터베이스 연동 방법 습득
  • 스프링 시큐리티를 활용한 사용자 인증 및 권한 관리
  • 프론트엔드와의 통신을 통한 기능 구현

2. 환경 설정

스프링 부트 애플리케이션을 개발하기 위해서는 다음과 같은 개발 환경이 필요합니다.

2.1. 필수 요구 사항

  • Java 11 이상
  • Spring Boot 2.5 이상
  • Maven 또는 Gradle (의존성 관리 도구)
  • IDE (IntelliJ IDEA, Eclipse 등)

2.2. 개발 환경 구성

다음 단계에 따라 개발 환경을 구성합니다. JAVA JDK를 설치한 후, IDE를 설치하고, 필요한 플러그인과 라이브러리를 추가합니다.

3. 스프링 부트 프로젝트 생성

스프링 부트 프로젝트를 생성하는 방법에는 많은 방법이 있지만, 가장 간단한 방법은 Spring Initializr를 사용하는 것입니다.

3.1. Spring Initializr를 사용하여 프로젝트 생성

  1. 웹 브라우저에서 Spring Initializr 페이지를 엽니다.
  2. 프로젝트 메타데이터를 설정합니다.
  3. Project

    Maven Project 또는 Gradle Project를 선택

  4. Language

    Java를 선택

  5. Spring Boot

    최신 안정 버전을 선택

  6. Project Metadata

    Group과 Artifact를 설정합니다.

  7. Dependencies

    Web, JPA, H2 Database, Security를 추가합니다.

  8. Generate 버튼을 클릭하여 프로젝트를 다운로드합니다.

4. 프로젝트 구조 이해

스프링 부트 프로젝트의 구조는 일반적인 Maven 프로젝트와 동일하지만, 스프링 부트의 관습에 따라 약간의 차이가 있습니다. 다음은 기본 프로젝트 구조입니다.

        └── demo
            ├── DemoApplication.java
            ├── controller
            ├── model
            ├── repository
            └── service
    

4.1. 주요 패키지 설명

  • controller: 웹 요청을 처리하는 컨트롤러 클래스가 위치합니다.
  • service: 비즈니스 로직을 구현하는 서비스 클래스가 위치합니다.
  • repository: 데이터베이스와의 상호작용을 담당하는 리포지터리 클래스가 위치합니다.
  • model: 데이터베이스 엔티티를 정의하는 클래스가 위치합니다.

5. 블로그 도메인 모델 설계

블로그 애플리케이션의 도메인 모델을 정의합니다. 이 모델에는 PostUser 엔티티가 포함됩니다.

5.1. Post 엔티티


    @Entity
    public class Post {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        private String title;
        private String content;
        
        @ManyToOne
        private User author;

        // Getters and Setters
    }
    

5.2. User 엔티티


    @Entity
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        private String username;
        private String password;

        @OneToMany(mappedBy = "author")
        private List posts;

        // Getters and Setters
    }
    

6. 리포지터리 인터페이스 생성

JPA를 사용하여 데이터베이스에 접근하기 위한 리포지터리 인터페이스를 생성합니다. Spring Data JPA를 사용하면 CRUD 작업을 쉽게 수행할 수 있습니다.

6.1. PostRepository


    public interface PostRepository extends JpaRepository {
    }
    

6.2. UserRepository


    public interface UserRepository extends JpaRepository {
        Optional findByUsername(String username);
    }
    

7. 서비스 구현

서비스 레이어를 구현하여 비즈니스 로직을 처리합니다. 서비스는 리포지터리를 호출하여 DB 작업을 수행하고, 필요한 비즈니스 규칙을 적용합니다.

7.1. PostService


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

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

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

7.2. UserService


    @Service
    public class UserService {
        @Autowired
        private UserRepository userRepository;

        public User findUserByUsername(String username) {
            return userRepository.findByUsername(username).orElse(null);
        }

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

8. 컨트롤러 구현

컨트롤러를 구현하여 사용자 요청을 처리합니다. RESTful 웹 서비스를 설계하여 클라이언트와 서버 간의 통신을 담당합니다.

8.1. PostController


    @RestController
    @RequestMapping("/api/posts")
    public class PostController {
        @Autowired
        private PostService postService;

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

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

8.2. UserController


    @RestController
    @RequestMapping("/api/users")
    public class UserController {
        @Autowired
        private UserService userService;

        @PostMapping
        public User createUser(@RequestBody User user) {
            return userService.createUser(user);
        }

        @GetMapping("/{username}")
        public User getUserByUsername(@PathVariable String username) {
            return userService.findUserByUsername(username);
        }
    }
    

9. 스프링 시큐리티 설정

사용자 인증 및 권한 관리를 위해 스프링 시큐리티를 설정합니다. 기본적인 시큐리티 설정을 통해 보호할 URL 및 사용자 인증 메커니즘을 설정합니다.


    @Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http
                .authorizeRequests()
                .antMatchers("/api/users").permitAll()
                .anyRequest().authenticated()
                .and()
                .formLogin();
        }
    }
    

10. 애플리케이션 실행 및 테스트

이제 애플리케이션을 실행하고, Postman 등을 사용하여 API를 테스트할 준비가 되었습니다. 각 엔드포인트가 올바르게 작동하는지 확인합니다.

10.1. 애플리케이션 실행

IntelliJ IDEA의 경우, 메인 클래스에서 Run 아이콘을 클릭하여 애플리케이션을 실행하거나, 명령줄에서 다음 명령어로 실행할 수 있습니다.

./mvnw spring-boot:run

10.2. Postman을 통한 테스트

Postman을 사용하여 REST API를 테스트할 수 있습니다. 아래는 몇 가지 기본적인 테스트 예제입니다.

  • GET /api/posts: 모든 포스트 가져오기
  • POST /api/posts: 새 포스트 생성하기
  • GET /api/users/{username}: 특정 사용자 정보 가져오기
  • POST /api/users: 새 사용자 생성하기

11. 결론

본 강좌를 통해 스프링 부트를 사용하여 간단한 블로그 애플리케이션을 구축하는 방법을 배웠습니다. 이 예제를 통해 REST API 설계, 데이터베이스 연동, 서비스 및 컨트롤러 구현 등 다양한 주제를 다룰 수 있었습니다. 앞으로는 이와 같은 기초를 기반으로 더 복잡한 애플리케이션을 개발하는 데 도전해 보시기 바랍니다.

12. 참고 자료

스프링 부트 백엔드 개발 강좌, 블로그 제작 예제, 반복 작업을 줄여 줄 테스트 코드 작성하기

본 강좌에서는 스프링 부트를 이용하여 블로그를 제작하는 방법을 배우며, 반복 작업을 줄여 줄 테스트 코드 작성법에 대해 알아보겠습니다. 이 블로그 프로젝트는 실제로 배울 수 있는 가장 좋은 방법 중 하나이며, 개발자로서의 역량을 한층 더 강화할 것입니다. 이 강좌는 초보부터 중급자까지 모두를 위한 내용을 담고 있습니다.

1. 스프링 부트 소개

스프링 부트는 스프링 프레임워크의 단순화된 구성으로, 빠르고 쉽게 스프링 애플리케이션을 개발할 수 있도록 도와줍니다. 스프링 부트를 사용하면 복잡한 설정이나 XML 구성을 최소화할 수 있으며, 다양한 내장 서버와 통합하여 적용할 수 있는 이점을 제공합니다.

1.1 스프링 부트의 장점

  • 빠른 시작: 미리 설정된 템플릿을 사용해 간단한 애플리케이션을 빠르게 실행할 수 있습니다.
  • 자동 구성: 스프링 부트는 애플리케이션의 구성 요소를 자동으로 설정해 줍니다.
  • 내장 서버: Tomcat, Jetty 등의 내장 서버를 사용하여 별도의 서버 설치 없이 애플리케이션을 실행할 수 있습니다.
  • 의존성 관리: Maven이나 Gradle을 통한 의존성 관리가 용이합니다.

2. 프로젝트 환경 설정

이제 실제 블로그 애플리케이션을 만들기 위한 환경을 설정해 보겠습니다. 스프링 이니셜라이저를 사용하여 프로젝트를 구성할 수 있습니다.

2.1 스프링 이니셜라이저 사용하기

  1. 웹 브라우저에서 스프링 이니셜라이저로 가습니다.
  2. 프로젝트 메타데이터를 입력합니다:
    • Project: Maven Project
    • Language: Java
    • Spring Boot: 최신 버전 선택
    • Group: com.example
    • Artifact: blog
    • Name: blog
    • Package name: com.example.blog
  3. Dependencies에서 다음을 선택합니다:
    • Spring Web
    • Spring Data JPA
    • H2 Database (이나, MySQL로 변경 가능)
    • Spring Boot DevTools
  4. Generate 버튼을 눌러 ZIP 파일을 다운로드합니다.

3. 블로그 애플리케이션 구조

프로젝트를 설정한 후, 애플리케이션 구조를 살펴보겠습니다. 적절한 디렉토리 구조는 유지보수성과 가독성을 높여줍니다.

3.1 디렉토리 구조

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

4. 기본 모델 및 레포지토리 생성

이제 블로그의 기본적인 모델 클래스와 레포지토리를 생성하겠습니다. 모델은 블로그 포스트를 나타내며, 레포지토리는 데이터베이스와 상호작용하는 역할을 합니다.

4.1 모델 클래스 생성

먼저 BlogPost 모델 클래스를 생성합니다.

    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;
    import java.time.LocalDateTime;

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

        @Column(nullable = false)
        private String title;

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

        private LocalDateTime createdAt;

        public BlogPost() {
            this.createdAt = LocalDateTime.now();
        }

        // Getter와 Setter
    }
    

4.2 레포지토리 인터페이스 생성

다음으로 BlogPostRepository 인터페이스를 생성하여 JPA의 CRUD 기능을 사용할 수 있습니다.

    package com.example.blog.repository;

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

    public interface BlogPostRepository extends JpaRepository {
    }
    

5. 컨트롤러 생성 및 REST API 구현

블로그 포스트의 데이터를 관리하기 위한 REST API를 만들겠습니다. 이를 위해 컨트롤러 클래스를 작성합니다.

5.1 REST 컨트롤러 생성

    package com.example.blog.controller;

    import com.example.blog.model.BlogPost;
    import com.example.blog.repository.BlogPostRepository;
    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 BlogPostController {

        @Autowired
        private BlogPostRepository blogPostRepository;

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

        @PostMapping
        public BlogPost createPost(@RequestBody BlogPost blogPost) {
            return blogPostRepository.save(blogPost);
        }

        @GetMapping("/{id}")
        public ResponseEntity getPostById(@PathVariable Long id) {
            return blogPostRepository.findById(id)
                    .map(post -> ResponseEntity.ok().body(post))
                    .orElse(ResponseEntity.notFound().build());
        }
        
        // Update and Delete 메소드 추가
    }
    

6. 테스트 코드 작성

이번 섹션에서는 작성한 REST API가 올바르게 작동하는지 확인하기 위해 테스트 코드를 작성하겠습니다. 스프링 부트에서는 JUnit과 Mockito를 사용하여 간편하게 테스트를 진행할 수 있습니다.

6.1 테스트 환경 설정

    
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
    
    

6.2 REST API 테스트 예시

    package com.example.blog;

    import com.example.blog.model.BlogPost;
    import com.example.blog.repository.BlogPostRepository;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.http.MediaType;
    import org.springframework.test.web.servlet.MockMvc;
    import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

    import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;

    @SpringBootTest
    @AutoConfigureMockMvc
    public class BlogPostControllerTest {

        @Autowired
        private MockMvc mockMvc;

        @Autowired
        private BlogPostRepository blogPostRepository;

        private ObjectMapper objectMapper;

        @BeforeEach
        public void setUp() {
            objectMapper = new ObjectMapper();
            blogPostRepository.deleteAll();
        }

        @Test
        public void createPost_ShouldReturnCreatedPost() throws Exception {
            BlogPost post = new BlogPost();
            post.setTitle("제목");
            post.setContent("본문 내용");

            mockMvc.perform(post("/api/posts")
                    .content(objectMapper.writeValueAsString(post))
                    .contentType(MediaType.APPLICATION_JSON))
                    .andExpect(MockMvcResultMatchers.status().isCreated());
        }
        
        // 다른 메소드 테스트 추가
    }
    

7. 프로젝트 실행

이제 블로그 애플리케이션을 실행할 준비가 되었습니다. IDE를 사용해 BlogApplication.java 파일을 실행하면 내장 서버가 시작되고 REST API를 사용할 수 있습니다.

7.1 Postman으로 API 테스트하기

Postman과 같은 API 테스트 도구를 사용하여 작성한 REST API를 테스트할 수 있습니다. POST, GET 요청을 통해 블로그 포스트를 추가하고 조회하는 과정을 직접 경험해 보세요.

결론

이번 스프링 부트 백엔드 개발 강좌에서는 간단한 블로그 애플리케이션을 개발하면서 스프링 부트의 핵심 기능을 학습했습니다. 기본적인 CRUD 작업을 통해 데이터베이스와의 상호작용을 경험하고, 테스트 코드를 작성함으로써 개발 프로세스를 더욱 효율적으로 만들 수 있는 방법을 익혔습니다.

이 프로젝트를 기반으로 더 많은 기능을 추가하고, 디자인을 개선해 나감으로써 더욱 완성도 높은 블로그 애플리케이션으로 발전시켜 보세요. 앞으로도 계속 새로운 기능과 프레임워크에 도전하시길 바랍니다. 감사합니다.

스프링 부트 백엔드 개발 강좌, 블로그 제작 예제, API 실행 테스트하기

스프링 부트(Spring Boot)는 Java 기반의 웹 애플리케이션을 빠르고 간편하게 개발할 수 있는 프레임워크입니다. 이 강좌에서는 스프링 부트를 사용하여 백엔드 서버를 구축하고, 블로그 제작 예제를 통해 RESTful API를 구현해보겠습니다. 마지막으로 API 실행 테스트 방법에 대해서도 알아보겠습니다.

1. 스프링 부트 소개

스프링 부트는 스프링 프레임워크를 바탕으로 간편하고 빠르게 애플리케이션을 개발할 수 있는 기술입니다. 스프링 부트를 사용하면 복잡한 설정을 줄이고, 내장 서버를 통해 쉽게 테스트할 수 있습니다.

  • 자동 설정: 기본 설정을 자동으로 수행하여 개발자가 설정에 신경 쓸 필요를 줄입니다.
  • 내장 서버: Tomcat, Jetty 등의 내장 서버를 지원하여 별도의 서버 설치 없이 개발과 테스트가 가능합니다.
  • 스타터 의존성: 다양한 기능을 쉽게 추가할 수 있게 도와주는 스타터 의존성을 제공합니다.

2. 개발 환경 설정

스프링 부트를 사용하기 위해서는 Java Development Kit (JDK)와 Maven 또는 Gradle과 같은 빌드 도구가 필요합니다. 아래는 JDK 및 Maven 설치 방법입니다.

2.1 JDK 설치

JDK 8 이상의 버전을 설치합니다. Oracle의 공식 웹사이트에서 다운로드할 수 있습니다. 설치 후, 아래 명령어로 설치된 버전을 확인합니다:

java -version

2.2 Maven 설치

Maven은 스프링 부트 프로젝트의 의존성을 관리하는 데 사용됩니다. Apache Maven의 공식 사이트에서 다운로드 후 설치합니다. 설치 후 아래 명령어로 설치된 버전을 확인합니다:

mvn -version

2.3 IDE 선택

IntelliJ IDEA, Eclipse, Spring Tool Suite(STS)와 같은 IDE를 사용할 수 있습니다. 이번 강좌에서는 IntelliJ IDEA를 기준으로 설명하겠습니다.

3. 스프링 부트 프로젝트 생성

스프링 부트 프로젝트는 Spring Initializr를 통해 쉽게 생성할 수 있습니다. Spring Initializr는 스프링 부트 애플리케이션의 기본 구조를 자동으로 생성해주는 웹 애플리케이션입니다.

3.1 Spring Initializr 접근하기

아래 링크를 통해 Spring Initializr에 접근합니다:
Spring Initializr

3.2 프로젝트 설정

  • Project: Maven Project
  • Language: Java
  • Spring Boot: 최신 버전 선택
  • Group: com.example
  • Artifact: blog-api
  • Name: blog-api
  • Description: 블로그 API 예제
  • Package name: com.example.blogapi
  • Packaging: Jar
  • Java: 11 선택

3.3 의존성 추가

필요한 의존성을 추가합니다. 다음 의존성을 추가하세요:

  • Spring Web
  • Spring Data JPA
  • H2 Database (또는 MySQL 선택 가능)

설정 후, GENERATE 버튼을 클릭하여 ZIP 파일을 다운로드하고, 원하는 위치에 압축을 풀어줍니다.

4. 프로젝트 구조 이해하기

생성된 프로젝트 폴더 구조는 다음과 같은 형태입니다:


blog-api
 ├── src
 │    ├── main
 │    │    ├── java
 │    │    │    └── com
 │    │    │         └── example
 │    │    │              └── blogapi
 │    │    │                   └── BlogApiApplication.java
 │    │    └── resources
 │    │         ├── application.properties
 │    │         └── static
 │    └── test
 ├── pom.xml

5. 도메인 객체 만들기

이제 블로그 포스트를 나타내는 도메인 객체를 만들어보겠습니다. Post 클래스를 생성하여 블로그 포스트의 속성을 정의합니다.

5.1 Post 클래스 생성

src/main/java/com/example/blogapi 폴더 내에 Post.java 파일을 생성합니다:


package com.example.blogapi;

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

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

    // getters and setters
}

6. 리포지토리 인터페이스 만들기

데이터베이스와 상호작용하기 위해 JPA 리포지토리를 사용합니다. PostRepository 인터페이스를 생성하여 CRUD 기능을 구현합니다.

6.1 PostRepository 인터페이스 생성

src/main/java/com/example/blogapi 폴더 내에 PostRepository.java 파일을 생성합니다:


package com.example.blogapi;

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

public interface PostRepository extends JpaRepository {
}

7. 서비스 클래스 만들기

비즈니스 로직을 처리하기 위해 서비스 클래스를 생성합니다. PostService 클래스를 만들어 블로그 포스트의 CRUD 기능을 구현합니다.

7.1 PostService 클래스 생성

src/main/java/com/example/blogapi 폴더 내에 PostService.java 파일을 생성합니다:


package com.example.blogapi;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

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

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

    public Post getPostById(Long id) {
        return postRepository.findById(id).orElse(null);
    }

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

    public Post updatePost(Long id, Post post) {
        Post existingPost = postRepository.findById(id).orElse(null);
        if (existingPost != null) {
            existingPost.setTitle(post.getTitle());
            existingPost.setContent(post.getContent());
            return postRepository.save(existingPost);
        }
        return null;
    }

    public void deletePost(Long id) {
        postRepository.deleteById(id);
    }
}

8. 컨트롤러 클래스 만들기

클라이언트의 요청을 처리할 RESTful API를 생성하기 위해 컨트롤러 클래스를 작성합니다.

8.1 PostController 클래스 생성

src/main/java/com/example/blogapi 폴더 내에 PostController.java 파일을 생성합니다:


package com.example.blogapi;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/posts")
public class PostController {
    @Autowired
    private PostService postService;

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

    @GetMapping("/{id}")
    public Post getPostById(@PathVariable Long id) {
        return postService.getPostById(id);
    }

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

    @PutMapping("/{id}")
    public Post updatePost(@PathVariable Long id, @RequestBody Post post) {
        return postService.updatePost(id, post);
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deletePost(@PathVariable Long id) {
        postService.deletePost(id);
    }
}

9. 애플리케이션 속성 설정

데이터베이스 연결 및 기타 설정을 위해 application.properties 파일을 수정합니다.

9.1 H2 데이터베이스 설정

src/main/resources/application.properties 파일을 다음과 같이 수정합니다:


# H2 Database
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

10. 애플리케이션 실행하기

이제 모든 설정이 완료되었습니다. IDE에서 BlogApiApplication.java 클래스를 실행하여 애플리케이션을 시작합니다.

10.1 H2 콘솔 접근하기

애플리케이션이 정상적으로 실행되면, H2 콘솔에 접근하여 데이터베이스를 확인할 수 있습니다:

11. API 테스트하기

이제 Postman이나 cURL을 사용하여 API를 테스트해봅시다.

11.1 Postman 설치

Postman은 API를 테스트하는 데 사용되는 유용한 도구입니다. Postman을 설치한 후, 아래와 같이 요청을 보낼 수 있습니다.

11.2 API 요청 예제

  • GET /api/posts: 모든 포스트 조회
  • GET /api/posts/{id}: 특정 포스트 조회
  • POST /api/posts: 포스트 생성
  • PUT /api/posts/{id}: 포스트 수정
  • DELETE /api/posts/{id}: 포스트 삭제

11.2.1 POST 요청 예제:


POST /api/posts
Content-Type: application/json

{
    "title": "첫 포스트",
    "content": "안녕하세요, 첫 포스트입니다."
}

11.2.2 GET 요청 예제:


GET /api/posts

12. 마무리

이번 강좌에서는 스프링 부트를 사용하여 간단한 블로그 API를 구현하는 방법을 알아보았습니다. 도메인 객체, 리포지토리, 서비스, 컨트롤러를 모두 설정하고, Postman을 사용하여 API를 테스트하는 과정을 살펴보았습니다.

이제 여러분은 스프링 부트를 통해 블로그 API를 생성할 수 있는 기초를 마련하였습니다. 추가적으로 더 많은 기능을 구현하거나, 다른 데이터베이스로의 전환, 배포 방법 등을 학습하며 지식을 확장해 나가시기 바랍니다.

References