스프링 부트 백엔드 개발 강좌, 블로그 화면 구성 예제, 템플릿 엔진 개념 잡기

최근 몇 년간 Rapid Application Development(빠른 응용 프로그램 개발)의 중요성이 커지면서, 스프링 부트는 자바 기반의 웹 애플리케이션을 효율적으로 제작할 수 있는 강력한 프레임워크로 자리 잡았습니다. 이번 강좌에서는 스프링 부트를 사용하여 백엔드를 개발하는 방법과 블로그 화면 구성 예제, 그리고 템플릿 엔진의 개념에 대해 자세히 알아보겠습니다.

1. 스프링 부트란?

스프링 부트(Spring Boot)는 스프링 프레임워크를 기반으로 하여, 애플리케이션의 설정과 배포를 간소화하기 위해 만들어졌습니다. 개발자는 복잡한 XML 설정이나 많은 라이브러리 설정 없이 애플리케이션을 신속하게 시작할 수 있습니다. 기본적으로 내장형 서버를 사용하므로, WAR 파일을 만들 필요 없이 JAR 파일로 독립 실행형 애플리케이션을 생성할 수 있는 것이 큰 장점입니다.

1.1 스프링 부트의 주요 특징

  • 자동 설정: 스프링 부트는 필요한 설정을 자동으로 구성하여 개발자가 보다 간편하게 개발할 수 있도록 돕습니다.
  • 선택적 의존성 관리: 필요한 의존성을 쉽게 추가할 수 있으며, Maven 또는 Gradle을 사용하여 손쉽게 관리할 수 있습니다.
  • 명령어 기반의 개발: 스프링 부트 스타터를 사용하여 CLI(Command Line Interface)에서 쉽게 프로젝트를 생성할 수 있습니다.

2. 스프링 부트 환경 설정

스프링 부트를 시작하기 위해 가장 먼저 해야 할 일은 개발 환경을 설정하는 것입니다. 아래의 단계를 통해 스프링 부트를 설치하고 기본 설정을 구현해보겠습니다.

2.1 JDK 설치

스프링 부트를 사용하기 위해서는 JDK(자바 개발 키트)가 필요합니다. Oracle의 공식 웹사이트에서 JDK를 다운로드 후 설치합니다.

2.2 IntelliJ IDEA 설치

스프링 부트 개발을 위해서는 IntelliJ IDEA 또는 Eclipse 등 편리한 개발 도구가 필요합니다. 해당 IDE를 다운로드하여 설치하십시오.

2.3 새로운 프로젝트 생성

1. IntelliJ IDEA를 열고, 'New Project' 선택
2. Spring Initializr 선택
3. 프로젝트 메타데이터 입력 (그룹, 아티팩트, 이름 등)
4. 필요한 의존성을 선택 (Spring Web, Spring Data JPA 등)
5. 프로젝트 생성 완료

3. RESTful API 설계

스프링 부트를 이용한 백엔드 개발의 가장 큰 장점은 RESTful API를 쉽게 구현할 수 있다는 것입니다. REST(Representational State Transfer) 아키텍처 스타일을 따르는 API를 설계하여 클라이언트와의 통신을 효율적으로 처리할 수 있습니다.

3.1 기본 구조 생성

이제 간단한 RESTful API를 만들어보겠습니다. 먼저, 컨트롤러 클래스를 생성합니다.

@RestController
@RequestMapping("/api/v1/blogs")
public class BlogController {
    private final BlogService blogService;

    public BlogController(BlogService blogService) {
        this.blogService = blogService;
    }

    @GetMapping
    public List getAllBlogs() {
        return blogService.getAllBlogs();
    }

    @PostMapping
    public Blog createBlog(@RequestBody Blog blog) {
        return blogService.createBlog(blog);
    }
}

3.2 블로그 서비스 클래스 생성

서비스 클래스에서는 비즈니스 로직을 처리합니다.

@Service
public class BlogService {
    @Autowired
    private BlogRepository blogRepository;

    public List getAllBlogs() {
        return blogRepository.findAll();
    }

    public Blog createBlog(Blog blog) {
        return blogRepository.save(blog);
    }
}

4. 데이터베이스 설정

이제 데이터베이스와 연결하여 블로그 데이터를 저장하고 관리할 수 있습니다. Spring Data JPA를 사용하여 데이터베이스와의 상호작용을 쉽게 할 수 있습니다.

4.1 의존성 추가

pom.xml 파일에 H2 데이터베이스와 Spring Data JPA 의존성을 추가합니다.

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

4.2 엔티티 클래스 생성

블로그 데이터를 나타내는 엔티티 클래스를 생성합니다.

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

    private String title;
    private String content;
    private String author;

    // Getters and Setters
}

5. 블로그 화면 구성

이제 블로그의 백엔드를 끝마쳤으므로, 프론트엔드와의 연결을 위해 화면 구성을 해보겠습니다. 프론트엔드에서 REST API 호출을 통해 데이터를 표시할 수 있도록 준비합니다.

5.1 HTML 템플릿

Blending의 원리를 사용하여 블로그의 HTML 구조를 생성합니다. Thymeleaf 같은 템플릿 엔진을 통해 동적으로 데이터를 표시할 수 있습니다.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My Blog</title>
</head>
<body>
    <h1>블로그 포스트</h1>
    <div th:each="blog : ${blogs}">
        <h2 th:text="${blog.title}"></h2>
        <p th:text="${blog.content}"></p>
        <p>작성자: <span th:text="${blog.author}"></span></p>
    </div>
    <form action="/api/v1/blogs" method="post">
        <input type="text" name="title" placeholder="제목" required><br>
        <textarea name="content" placeholder="내용" required></textarea><br>
        <input type="text" name="author" placeholder="작성자" required><br>
        <button type="submit">포스트 추가</button>
    </form>
</body>
</html>

5.2 Thymeleaf 템플릿 엔진

Thymeleaf는 스프링 부트와 함께 자주 사용되는 템플릿 엔진입니다. 서버 사이드에서 HTML을 생성하고, 동적으로 데이터와 결합하여 클라이언트에게 반환할 수 있습니다.

6. 템플릿 엔진의 개념

템플릿 엔진은 웹 애플리케이션에서 동적으로 HTML 콘텐츠를 생성하기 위한 도구입니다. 개발자는 미리 정의된 HTML 구조에 데이터를 삽입하여 최종적으로 사용자에게 보여질 콘텐츠를 제작할 수 있습니다.

6.1 템플릿 엔진의 종류

  • Thymeleaf: 스프링 기반 애플리케이션에서 가장 많이 사용되는 템플릿 엔진입니다. HTML5와의 호환성으로 인해 사용하기 간편합니다.
  • Freemarker: 템플릿 파일에 대한 강력한 기능을 제공하며, XML을 포함한 다양한 형식으로 출력할 수 있습니다.
  • Mustache: 로직을 최소한으로 줄이고, 간단하고 직관적인 문법을 제공합니다.

6.2 템플릿 엔진의 작동 원리

템플릿 엔진은 클라이언트가 요청한 HTML 템플릿 파일을 사용하여 서버에서 데이터와 결합한 후, 최종적으로 생성된 HTML 파일을 클라이언트에게 반환하는 방식으로 작동합니다. 이 과정에서 서버 사이드 렌더링 방식으로 작업하므로, SEO 최적화가 용이합니다.

결론

이번 강좌에서는 스프링 부트를 사용하여 백엔드 개발의 기초를 익혔습니다. 블로그 화면 구성 예제와 템플릿 엔진의 개념을 통해 실제 애플리케이션을 구축해보는 계기가 되었기를 바랍니다. 스프링 부트를 통해 더 복잡한 시스템과 다양한 기능을 계속해서 구현해 나가길 바랍니다. 다음 강좌에서도 더 심화된 내용을 다뤄보겠습니다.

스프링 부트 백엔드 개발 강좌, 빈과 스프링 컨테이너

스프링 부트(Spring Boot)는 자바 기반의 엔터프라이즈 애플리케이션 개발을 위한 프레임워크로, 빠르고 쉽게 웹 애플리케이션을 개발할 수 있도록 돕습니다. 그 중심에는 스프링 컨테이너가 존재하며, 빈(Bean)의 개념은 스프링 애플리케이션의 핵심 요소입니다. 이번 강좌에서는 빈과 스프링 컨테이너에 대해 자세히 살펴보겠습니다.

1. 스프링 프레임워크 개요

스프링 프레임워크는 자바 플랫폼을 위한 애플리케이션 프레임워크로, 개발자들이 빈의 생명주기를 관리하고, 의존성 주입(Dependency Injection)을 통해 컴포넌트를 연결할 수 있게 해줍니다. 이를 통해 소프트웨어의 결합도를 낮추고, 테스트 용이성을 높이며, 유지보수성을 개선합니다.

2. 스프링의 컨테이너

스프링 컨테이너는 애플리케이션의 구성 요소를 관리하는 핵심적인 부분입니다. 객체의 생성, 설정, 그리고 의존성 주입을 담당합니다. 스프링의 두 가지 주요 컨테이너는 다음과 같습니다.

  • BeanFactory: 가장 기본적인 컨테이너로, 객체를 지연 로딩(lazy loading) 방식으로 생성합니다.
  • ApplicationContext: BeanFactory의 기능을 모두 포함하고 있으며, 더 많은 기능을 제공합니다. 예를 들어, 국제화 지원, 이벤트 전파, 레이어를 통한 다양한 애플리케이션 구성 요소들을 지원합니다.

3. 빈(Bean) 개념

스프링에서 빈은 스프링 컨테이너에 의해 관리되는 객체를 의미합니다. 빈은 일반적으로 애플리케이션의 비즈니스 로직을 수행하는 데 필요합니다. 빈은 XML 파일이나 자바 설정 파일에서 정의할 수 있습니다.

빈을 정의할 때는 아래의 요소들을 고려해야 합니다.

  • scope: 빈의 생명주기를 정의합니다. 일반적인 스코프에는 singleton, prototype, request, session, global session이 있습니다.
  • qualifier: 여러 개의 빈이 있을 경우, 특정 빈을 선택하기 위한 방법을 제공합니다.
  • autowiring: 스프링 컨테이너가 빈의 의존성을 자동으로 주입하는 방법입니다.

4. 빈 생명주기

스프링에서는 빈의 생명주기를 다양한 상태로 관리할 수 있습니다. 빈의 생성부터 소멸까지의 과정을 살펴보겠습니다.

  1. 빈 인스턴스화(Instantiation): 스프링 컨테이너가 빈 객체를 생성합니다.
  2. 의존성 주입(Dependency Injection): 필요한 의존성을 주입합니다.
  3. 초기화(Initialization): 초기화 메소드가 호출됩니다. 이 단계에서 애플리케이션은 빈이 사용될 준비가 되도록 설정됩니다.
  4. 사용(Usage): 빈을 사용합니다. 요청을 처리하거나 특정 작업을 수행합니다.
  5. 소멸(Destruction): 애플리케이션의 종료 시 빈이 소멸됩니다. 이 단계에서 필요한 정리 작업이 수행됩니다.

5. 빈 정의

빈을 정의하는 방법에는 여러 가지가 있지만, 주로 XML 설정 파일과 자바 기반 설정 파일을 사용합니다. 각 방법을 살펴보겠습니다.

5.1 XML 설정 파일을 통한 빈 정의

XML 설정 파일에서 빈을 정의하는 방법은 다음과 같습니다.

        <beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans.xsd">

            <bean id="exampleBean" class="com.example.Example">
                <property name="propertyName" value="propertyValue"/>
            </bean>

        </beans>

5.2 자바 기반 설정 방법

자바 기반 설정을 통해 빈을 정의할 경우 @Configuration과 @Bean 어노테이션을 사용할 수 있습니다.

        @Configuration
        public class AppConfig {
        
            @Bean
            public Example exampleBean() {
                return new Example("propertyValue");
            }
        }

6. 의존성 주입

의존성 주입은 객체 사이의 관계를 설정하고 관리하는 방식으로, 주입 방식에는 세 가지가 있습니다.

  • 생성자 주입(Constructor Injection): 빈의 생성자를 통해 의존성을 주입합니다.
  • 세터 주입(Setter Injection): 세터 메소드를 통해 의존성을 주입합니다.
  • 필드 주입(Field Injection): 필드에 직접 주입하는 방식입니다. 그러나 이 방법은 권장되지 않습니다.

6.1 생성자 주입 예제

        public class SampleBean {
            private final DependencyBean dependency;

            public SampleBean(DependencyBean dependency) {
                this.dependency = dependency;
            }
        }

6.2 세터 주입 예제

        public class SampleBean {
            private DependencyBean dependency;

            @Autowired
            public void setDependency(DependencyBean dependency) {
                this.dependency = dependency;
            }
        }

7. 빈의 스코프 정의

스프링에서는 빈의 생명주기를 관리하기 위해 스코프를 설정할 수 있습니다. 각 스코프의 특징을 아래에 정리하였습니다.

  • singleton: 기본 스코프이며 애플리케이션당 하나의 인스턴스만 생성됩니다.
  • prototype: 요청할 때마다 새로운 인스턴스가 생성됩니다.
  • request: 웹 애플리케이션에서 HTTP 요청당 하나의 인스턴스가 생성됩니다.
  • session: HTTP 세션당 하나의 인스턴스가 생성됩니다.
  • globalSession: 포털 애플리케이션에서 모든 세션에서 공유되는 인스턴스입니다.

8. 스프링 컨테이너 초기화

스프링 애플리케이션을 시작하기 전에 스프링 컨테이너를 초기화해야 합니다. 일반적으로 SpringApplication.run() 메소드를 호출하여 초기화를 수행합니다.

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

9. 빈의 프로파일

스프링에서는 환경을 기준으로 빈을 구성할 수 있도록 프로파일을 지원합니다. 프로파일을 사용하면 개발, 테스트, 프로덕션 환경에 맞는 빈 설정을 유지할 수 있습니다.

        @Profile("dev")
        @Bean
        public DataSource devDataSource() {
            return new HikariDataSource();
        }

        @Profile("prod")
        @Bean
        public DataSource prodDataSource() {
            return new HikariDataSource();
        }

10. 결론

스프링 부트는 강력한 백엔드 애플리케이션 개발을 지원하는 프레임워크이며, 빈과 스프링 컨테이너는 애플리케이션의 구조와 동작을 이해하는 데 필수적입니다. 이번 강좌에서는 빈의 정의, 생명주기, 의존성 주입, 스코프 및 초기화 방법에 대해 설명했습니다. 앞으로의 강좌에서 더 많은 내용을 배우고 스프링 부트를 사용하여 실제 애플리케이션을 개발해보기를 기대합니다.

스프링 부트 백엔드 개발 강좌, 블로그 화면 구성 예제, 타임리프 문법 익히기용 컨트롤러 작성하기

1. 개요

이 강좌에서는 스프링 부트를 이용한 백엔드 개발을 위한 기본적인 이해를 돕고, 블로그 화면 구성 예제를 통해 타임리프 문법을 익히는 방법을 설명합니다.

스프링 부트(Spring Boot)는 자바 기반의 웹 어플리케이션 프레임워크로, 복잡한 설정 없이 빠르고 간편하게 웹 애플리케이션을 만들 수 있도록 도와줍니다. 이를 통해 개발자는 비즈니스 로직에 집중하며, 생산성을 높일 수 있습니다.

2. 기술 스택

이번 강좌에서 사용할 주요 기술 스택은 다음과 같습니다:

  • Java 11 이상
  • Spring Boot 2.x
  • Thymeleaf
  • Spring Data JPA
  • H2 Database

이 기술 스택은 백엔드 개발에 있어 강력한 조합을 이룹니다. 각 기술 스택의 간략한 설명은 다음과 같습니다.

  • Java: 객체 지향 프로그래밍 언어로, 플랫폼에 독립적입니다.
  • Spring Boot: Java Spring에서 설정과 배포를 간소화한 프레임워크입니다.
  • Thymeleaf: HTML5 템플릿 엔진으로, 뷰를 구성하는 데 사용됩니다.
  • Spring Data JPA: 데이터베이스와의 상호작용을 쉽게 도와주는 라이브러리입니다.
  • H2 Database: 메모리 기반의 경량형 데이터베이스로, 테스트와 프로토타입에 적합합니다.

3. 프로젝트 설정

스프링 부트 프로젝트를 설정하기 위해 Spring Initializr를 사용합니다. Spring Initializr에 접속하여 아래의 설정을 합니다:

  • Project: Maven Project
  • Language: Java
  • Spring Boot: 2.x
  • Group: com.example
  • Artifact: blog
  • Dependencies: Spring Web, Thymeleaf, Spring Data JPA, H2 Database

위의 설정을 저장하고, 프로젝트를 내려받습니다. 이후 IDE에서 임포트하여 작업을 시작합니다.

4. 엔티티 클래스 생성

애플리케이션에 필요한 데이터 모델을 정의하기 위해 엔티티 클래스를 생성합니다. 기본적인 블로그 게시물을 저장하기 위해 Post 엔티티 클래스를 아래와 같이 작성합니다:

package com.example.blog.model;

import javax.persistence.*;

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

    @Column(nullable = false)
    private String title;

    @Column(nullable = false)
    private String content;

    private String author;

    // getters and setters
}

이 클래스는 게시물의 ID, 제목, 내용 및 작성자를 포함하고 있습니다. JPA를 활용하여 데이터베이스와의 매핑을 처리합니다.

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

Post 엔티티에 대한 CRUD 작업을 처리하기 위해 JpaRepository를 상속받는 레포지토리 인터페이스를 생성합니다:

package com.example.blog.repository;

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

public interface PostRepository extends JpaRepository {
}

이 인터페이스는 Post 엔티티와 연결된 데이터베이스의 CRUD 작업을 간편하게 사용할 수 있도록 해줍니다.

6. 서비스 클래스 작성

비즈니스 로직을 담당하는 서비스 클래스를 생성하여 비즈니스 규칙을 정의합니다. PostService 클래스를 아래와 같이 작성합니다:

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 findAll() {
        return postRepository.findAll();
    }

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

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

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

이 클래스는 게시물 목록을 조회하고, 게시물을 저장 및 삭제하는 메소드를 정의하고 있습니다.

7. 컨트롤러 작성

이제 클라이언트 요청을 처리하기 위해 컨트롤러 클래스를 작성합니다. PostController 클래스를 아래와 같이 작성할 수 있습니다:

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.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Controller
@RequestMapping("/posts")
public class PostController {
    private final PostService postService;

    @Autowired
    public PostController(PostService postService) {
        this.postService = postService;
    }

    @GetMapping
    public String list(Model model) {
        List posts = postService.findAll();
        model.addAttribute("posts", posts);
        return "post/list";
    }

    @GetMapping("/new")
    public String createForm(Model model) {
        model.addAttribute("post", new Post());
        return "post/form";
    }

    @PostMapping
    public String create(Post post) {
        postService.save(post);
        return "redirect:/posts";
    }
    
    @GetMapping("/{id}")
    public String view(@PathVariable Long id, Model model) {
        Post post = postService.findById(id);
        model.addAttribute("post", post);
        return "post/view";
    }

    @GetMapping("/edit/{id}")
    public String editForm(@PathVariable Long id, Model model) {
        Post post = postService.findById(id);
        model.addAttribute("post", post);
        return "post/form";
    }

    @PostMapping("/edit/{id}")
    public String edit(@PathVariable Long id, Post post) {
        post.setId(id);
        postService.save(post);
        return "redirect:/posts";
    }

    @GetMapping("/delete/{id}")
    public String delete(@PathVariable Long id) {
        postService.deleteById(id);
        return "redirect:/posts";
    }
}

컨트롤러는 패턴에 따라 HTTP 요청에 대한 핸들러 메소드들을 정의합니다. 위 코드에서는 게시물의 목록, 게시물 생성, 수정, 삭제 기능을 구현합니다.

8. 타임리프 템플릿 작성

이제 Thymeleaf를 사용하여 HTML 뷰를 작성할 시간입니다. 게시물 목록을 표시할 list.html은 다음과 같이 작성할 수 있습니다:

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>게시물 목록</title>
</head>
<body>
    <h1>게시물 목록</h1>
    <a href="@{/posts/new}">새 게시물 작성</a>
    <ul>
        <li th:each="post : ${posts}">
            <a th:href="@{/posts/{id}(id=${post.id})}">[[${post.title}]]</a>
        </li>
    </ul>
</body>
</html>

위 템플릿은 게시물 목록을 표시하며, 각 게시물 제목을 클릭하면 해당 게시물의 세부 정보 페이지로 이동합니다.

9. 마무리

이 강좌에서는 스프링 부트와 타임리프를 사용하여 간단한 블로그 애플리케이션을 구축하는 방법을 소개했습니다. 각 단계별로 엔티티, 레포지토리, 서비스, 컨트롤러 및 뷰를 만들어가며 기초적인 백엔드 개발을 이해하는 데 도움이 되었길 바랍니다.

더 많은 기능을 추가하고 싶다면, 게시물의 댓글 기능, 사용자 인증 및 권한 관리 등을 구현해 보세요. 이를 통해 더 발전된 웹 애플리케이션 개발의 기초를 쌓을 수 있을 것입니다.

스프링 부트 백엔드 개발 강좌, 블로그 화면 구성 예제, 타임리프 사용을 위한 의존성 추가하기

소개

스프링 부트(Spring Boot)는 스프링 프레임워크를 기반으로 한 경량 웹 애플리케이션 프레임워크로, 개발자가 신속하게 애플리케이션을 구축할 수 있도록 도와줍니다. 특히 백엔드 개발에서 스프링 부트는 RESTful 웹 서비스, 데이터베이스 연동, 보안 처리 등 많은 기능을 제공합니다. 이번 강좌에서는 스프링 부트를 이용하여 블로그 화면을 구성하는 예제를 다루고, 타임리프(Thymeleaf) 사용을 위한 의존성 추가에 대해서도 알아보겠습니다.

블로그 화면 구성 예제

1. 프로젝트 생성

스프링 부트 프로젝트를 생성하기 위해 Spring Initializr를 사용하겠습니다. 다음의 설정을 선택하세요.

  • Project: Gradle Project
  • Language: Java
  • Spring Boot: 2.7.0 (최신 버전 선택)
  • Group: com.example
  • Artifact: blog
  • Name: blog
  • Description: 블로그 애플리케이션
  • Package name: com.example.blog
  • Packaging: Jar
  • Java: 11

이후 Dependencies 섹션에서 ‘Spring Web’, ‘Thymeleaf’, ‘Spring Data JPA’, ‘H2 Database’를 추가한 후, 프로젝트를 생성합니다.

2. 의존성 추가하기

스프링 부트 프로젝트가 생성되면, build.gradle 파일에서 필요한 의존성을 확인해 보겠습니다. 아래와 같이 의존성이 추가되어 있어야 합니다.

dependencies {
        implementation 'org.springframework.boot:spring-boot-starter-web'
        implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
        implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
        runtimeOnly 'com.h2database:h2'
    }

3. 블로그 도메인 설계

이제 블로그를 구성할 도메인 모델을 설계해 보겠습니다. 기본적으로 블로그 글(Post)을 표현하는 모델이 필요합니다.

package com.example.blog.model;

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
}

4. 레포지토리 추가

레포지토리 인터페이스를 추가해 보겠습니다. 이는 데이터베이스와 상호작용하는 로직을 포함합니다.

package com.example.blog.repository;

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

public interface PostRepository extends JpaRepository {
}

5. 서비스 레이어 추가

블로그 글을 관리하기 위한 서비스 레이어를 추가하겠습니다. 여기서는 글을 생성하고 조회하는 메서드를 포함합니다.

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();
    }

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

6. 컨트롤러 추가

이제 웹 애플리케이션의 요청을 처리할 컨트롤러를 추가하겠습니다.

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.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

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

    @GetMapping
    public String listPosts(Model model) {
        List posts = postService.getAllPosts();
        model.addAttribute("posts", posts);
        return "postList";
    }

    @GetMapping("/new")
    public String newPostForm(Model model) {
        model.addAttribute("post", new Post());
        return "postForm";
    }

    @PostMapping
    public String savePost(Post post) {
        postService.savePost(post);
        return "redirect:/posts";
    }
}

7. Thymeleaf 템플릿 구성

이제 Thymeleaf를 사용하여 블로그 화면을 구성해 보겠습니다. src/main/resources/templates 폴더에 postList.html와 postForm.html 파일을 생성합니다.

postList.html

<!DOCTYPE html>
    <html xmlns:th="http://www.w3.org/1999/xhtml">
        <head>
            <title>블로그 글 목록</title>
        </head>
        <body>
            <h1>블로그 글 목록</h1>
            <a href="@{/posts/new}">새 글 작성</a>
            <ul>
                <li th:each="post : ${posts}">
                    <h2 th:text="${post.title}"></h2>
                    <p th:text="${post.content}"></p>
                </li>
            </ul>
        </body>
    </html>

postForm.html

<!DOCTYPE html>
    <html xmlns:th="http://www.w3.org/1999/xhtml">
        <head>
            <title>새 글 작성</title>
        </head>
        <body>
            <h1>새 글 작성</h1>
            <form th:action="@{/posts}" method="post">
                <label for="title">제목</label>
                <input type="text" id="title" name="title" required/>

                <label for="content">내용</label>
                <textarea id="content" name="content" required></textarea>

                <button type="submit">저장</button>
            </form>
        </body>
    </html>

결론

이번 강좌에서는 스프링 부트를 사용하여 간단한 블로그 애플리케이션을 구성하는 방법을 배웠습니다. 블로그 글을 작성하고 목록을 조회하는 기능을 구현했으며, 타임리프를 통해 HTML 템플릿을 작성하는 방법에 대해서도 알아보았습니다. 이 강좌를 바탕으로 더 복잡한 기능을 추가하여 나만의 블로그를 만들어보시기 바랍니다.

추가 자료

더 많은 내용을 익히고 싶다면, 다음의 자료들을 참고해 보세요.

스프링 부트 백엔드 개발 강좌, 블로그 화면 구성 예제, 엔티티에 생성, 수정 시간 추가하기

블로그 화면 구성 예제

스프링 부트를 활용한 블로그 웹 애플리케이션을 개발하는 것은 현대 웹 개발에서 매우 유용한 기술입니다. 이번 강좌에서는 스프링 부트를 이용하여 간단한 블로그 화면을 구성하는 방법을 다루고, 엔티티에 생성 및 수정 시간을 추가하는 방법에 대해서도 알아보겠습니다.

1. 스프링 부트란?

스프링 부트(Spring Boot)는 자바 기반의 스프링 프레임워크를 더욱 쉽게 사용할 수 있도록 도와주는 오픈소스 프레임워크입니다. 초기 설정과 구성을 최소화하여 개발자가 비즈니스 로직에 집중할 수 있게 하는 것이 특징입니다. 이 강좌에서는 스프링 부트를 사용하여 블로그 애플리케이션을 만들면서 다양한 기능을 구현해 볼 것입니다.

2. 프로젝트 설정

스프링 부트 프로젝트 설정을 위해 Spring Initializr를 사용합니다. 다음과 같은 설정을 통해 프로젝트를 생성할 수 있습니다.

  • Project: Maven Project
  • Language: Java
  • Spring Boot: 2.5.x 또는 최신 버전
  • Group: com.example
  • Artifact: blog
  • Dependencies: Spring Web, Spring Data JPA, H2 Database, Lombok

생성된 프로젝트를 IDE에서 열어 작업을 시작합니다.

3. 블로그 엔티티 구성

블로그 애플리케이션의 핵심은 Post라는 엔티티입니다. 이 엔티티는 블로그 포스트를 대표하며, 기본적으로 제목, 내용, 작성 시간 및 수정 시간을 포함합니다.

package com.example.blog.entity;

import lombok.Getter;
import lombok.Setter;

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

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

    private String title;

    @Column(length = 10000)
    private String content;

    private LocalDateTime createdAt;

    private LocalDateTime updatedAt;

    @PrePersist
    public void onCreate() {
        this.createdAt = LocalDateTime.now();
    }

    @PreUpdate
    public void onUpdate() {
        this.updatedAt = LocalDateTime.now();
    }
}

위의 코드는 Post 엔티티의 구조를 보여줍니다. @Entity 어노테이션으로 이 클래스가 JPA 엔티티임을 명시하고, @Id와 @GeneratedValue를 사용하여 기본 키를 생성합니다. 생성 및 수정 시간은 LocalDateTime을 사용하여 자동으로 관리합니다.

4. 데이터베이스 설정

이번 예제에서는 H2 데이터베이스를 사용하겠습니다. application.properties 파일에 다음과 같이 추가하여 H2 데이터베이스를 설정합니다.

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=password
spring.jpa.hibernate.ddl-auto=create

H2 콘솔을 활성화하면 브라우저에서 데이터베이스를 직접 확인할 수 있습니다.

5. Repository 인터페이스 만들기

데이터베이스와의 상호작용을 위한 Repository를 생성합니다. Spring Data JPA를 이용하면 인터페이스만 정의해도 기본적인 CRUD 기능이 제공됩니다.

package com.example.blog.repository;

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

public interface PostRepository extends JpaRepository {
}

6. 서비스 레이어 구현

서비스 레이어는 비즈니스 로직을 처리하는 곳입니다. PostService 클래스를 만들어 블로그 포스트의 CRUD 기능을 구현합니다.

package com.example.blog.service;

import com.example.blog.entity.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 findAll() {
        return postRepository.findAll();
    }

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

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

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

7. 컨트롤러 구현

이제 사용자 요청을 처리할 PostController를 생성하겠습니다. 이 컨트롤러는 REST API를 정의하며 클라이언트와의 상호작용을 관리합니다.

package com.example.blog.controller;

import com.example.blog.entity.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;

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

    @GetMapping("/{id}")
    public ResponseEntity getPostById(@PathVariable Long id) {
        Post post = postService.findById(id);
        return post != null ? ResponseEntity.ok(post) : ResponseEntity.notFound().build();
    }

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

    @PutMapping("/{id}")
    public ResponseEntity updatePost(@PathVariable Long id, @RequestBody Post post) {
        post.setId(id);
        Post updatedPost = postService.save(post);
        return ResponseEntity.ok(updatedPost);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity deletePost(@PathVariable Long id) {
        postService.delete(id);
        return ResponseEntity.noContent().build();
    }
}

8. Spring Boot 애플리케이션 실행

모든 설정이 완료되면, BlogApplication 클래스를 실행하여 애플리케이션을 실행할 수 있습니다.

package com.example.blog;

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);
    }
}

9. 전체 흐름 요약

위의 모든 과정은 포스트를 생성, 수정, 삭제하는 RESTful API를 구현하는 단계입니다. 프론트엔드는 React나 Vue.js와 같은 최신 프레임워크를 사용하여 디자인할 수 있으며, 백엔드는 위 API를 통해 데이터와 상호작용합니다.

10. 기타 고려사항

블로그 애플리케이션을 개발할 때 다양한 기능을 고려해야 합니다. 예를 들어, 사용자 인증 및 권한 관리, 댓글 기능, 태그 시스템 등이 있습니다. 이러한 기능들은 추가적인 엔티티 및 서비스 클래스를 통해 구현할 수 있습니다.

마치며

스프링 부트를 활용한 블로그 애플리케이션 개발은 굉장히 유익한 경험이 될 것입니다. 이로 인해 스프링 프레임워크와 JPA, RESTful API에 대한 이해도를 높일 수 있습니다. 이번 강좌에서 다룬 내용을 바탕으로 스스로 프로젝트를 확장하고 발전시킬 수 있기를 바랍니다.

부록: 참고 자료