스프링 부트 시작하기

9/14/2023
36 minutes to read

Spring Boot 기초 학습 목차

Spring Boot 소개
- Spring Boot의 개념
- Spring Boot의 특징
- Spring Boot의 장단점
개발 환경 설정
- JDK 설치
- IDE 설치
- Spring Boot 프로젝트 생성
Spring Boot 애플리케이션 구조
- 프로젝트 구조
- 애플리케이션 클래스
- 프로퍼티 파일
의존성 관리
- 스프링 부트 의존성 관리
- Maven 또는 Gradle 빌드 시스템
스프링 부트 애플리케이션 실행
- 내장 서버 (Embedded Server)
- 애플리케이션 실행 방법
Spring Boot Starter Pack
- 스타터 팩의 개념
- 자주 사용되는 Starter Pack
스프링 부트와 데이터베이스
- 스프링 부트에서 데이터베이스 사용
- H2 데이터베이스
- MySQL 데이터베이스
- JPA를 이용한 데이터베이스 연동
RESTful API 개발
- RESTful API 개념
- HTTP 요청 처리
- 데이터 처리
- HTTP 응답 처리
스프링 부트와 보안
- Spring Security의 개념
- Spring Security 설정
- 사용자 인증 및 권한 부여
스프링 부트 테스트
- JUnit 5 기본 사용법
- MockMvc를 이용한 Controller 테스트
- TestRestTemplate을 이용한 API 테스트

1. Spring Boot 소개

Spring Boot는 스프링 프레임워크를 기반으로 한 자바 웹 애플리케이션 개발을 간편하게 하기 위한 프레임워크입니다. Spring Boot는 별도의 설정 없이 바로 개발을 시작할 수 있는 환경을 제공하며, 내장 서버를 이용하여 애플리케이션을 실행할 수 있습니다. 이를 통해 개발자는 보다 쉽고 빠르게 자바 웹 애플리케이션을 개발할 수 있습니다. 이번 강의에서는 Spring Boot를 처음 학습하는 개발자를 대상으로 Spring Boot의 기본 개념과 특징, 사용 방법 등에 대해 알아보겠습니다.

Spring Boot의 개념

Spring Boot는 스프링 프레임워크의 기술을 기반으로 하고 있으며, 별도의 설정 없이 간편한 애플리케이션 개발을 가능케 해주는 도구입니다. Spring Boot는 내장 서버와 스타터 팩을 제공하여 개발자가 쉽고 빠르게 웹 애플리케이션을 개발할 수 있도록 도와줍니다.

Spring Boot의 특징

Spring Boot의 특징으로는 다음과 같은 것들이 있습니다.

내장 서버를 사용하여 별도의 웹 서버 설치가 필요하지 않습니다.
스프링 프레임워크의 기술을 기반으로 하며, 스프링 프레임워크의 기능들을 활용할 수 있습니다.
스프링 부트는 스타터 팩을 제공합니다. 스타터 팩을 이용하면 필요한 라이브러리들을 자동으로 설정할 수 있습니다.
높은 생산성과 코드의 가독성, 유지보수성이 높습니다.

Spring Boot의 장단점

Spring Boot의 장점은 다음과 같습니다.

간편한 애플리케이션 개발 : Spring Boot는 스프링 프레임워크에서 필요로 하는 설정 파일의 수를 최소화하고, 설정이 필요한 부분은 자동으로 처리할 수 있도록 해줍니다. 따라서, 개발자는 보다 쉽고 빠르게 애플리케이션을 개발할 수 있습니다.
내장 서버 : Spring Boot는 내장 서버를 사용하기 때문에 별도의 웹 서버 설치가 필요하지 않습니다. 이를 통해 애플리케이션의 배포 및 실행이 간편해지며, 개발과 테스트 환경 설정이 단순화됩니다.
스타터 팩 : 스타터 팩을 이용하면 필요한 라이브러리들을 자동으로 설정할 수 있습니다. 이를 통해 개발자는 불필요한 라이브러리들을 제외하고 필요한 라이브러리들만을 사용할 수 있으며, 이는 애플리케이션의 크기를 줄여주고, 빌드 시간을 단축시켜줍니다.
생산성 향상 : Spring Boot는 높은 생산성과 코드의 가독성, 유지보수성이 높은 장점이 있습니다.
관련성이 있는 각종 기능들을 자동으로 처리해주기 때문에 개발자는 보다 적은 노력으로 애플리케이션을 개발할 수 있습니다.

Spring Boot의 단점으로는 다음과 같은 것들이 있습니다.

내장 서버의 한계 : Spring Boot의 내장 서버는 단일 애플리케이션에 대해서는 우수한 성능을 발휘하지만, 다수의 클라이언트 요청을 처리하거나 대용량 파일을 다룰 경우 성능 저하가 발생할 수 있습니다. 이러한 경우에는 외부 서버를 이용하거나, 다른 서버와 연동하는 방식을 고려해야 합니다.
설정의 복잡도 : Spring Boot는 설정 파일의 수를 최소화하고 각종 기능들을 자동으로 처리해주기 때문에 간편한 애플리케이션 개발이 가능합니다. 하지만, 설정이 필요한 부분이 있을 경우에는 설정 파일의 내용을 이해하고 작성하는 것이 쉽지 않을 수 있습니다.

Spring Boot는 간단하면서도 많은 기능들을 제공해주는 도구입니다. 개발자는 이를 통해 빠르고 간편하게 웹 애플리케이션을 개발할 수 있습니다.

2. 개발 환경 설정

이번 시간에는 스프링 부트를 개발하기 위한 환경을 설정하는 방법에 대해 알아보겠습니다. 스프링 부트는 자바 언어를 기반으로 동작하므로, 자바 개발 환경이 설치되어 있어야 합니다. 또한, 스프링 부트 개발에는 여러 도구들이 필요합니다. 이러한 도구들을 쉽게 설치하고 관리할 수 있는 스프링 부트 개발 도구인 Spring Tool Suite(STS)를 사용하여 개발환경을 구성할 것입니다. 스프링 부트의 개발 환경을 구성하는 방법에 대해 알아보도록 하겠습니다.

스프링 부트를 개발하기 위해서는 먼저 개발 환경을 설정해야 합니다. 이번 강의에서는 JDK 설치, IDE 설치 및 Spring Boot 프로젝트 생성에 대해 다룰 예정입니다.

2.1 JDK 설치

스프링 부트는 자바 언어를 기반으로 동작하기 때문에 JDK(Java Development Kit)가 설치되어 있어야 합니다. JDK는 Oracle 사이트나 OpenJDK 사이트에서 다운로드 및 설치가 가능합니다.

JDK 설치 후에는 java -version 명령어를 사용하여 설치된 버전을 확인할 수 있습니다.

2.2 IDE 설치

IDE(통합 개발 환경)는 스프링 부트 개발에 있어 매우 중요합니다. 스프링 부트는 다양한 IDE를 지원하지만, 이번 강의에서는 Spring Tool Suite(STS)를 사용하여 개발환경을 구성할 것입니다.

Spring Tool Suite(STS)는 이클립스 기반으로 제작된 스프링 프레임워크 개발 도구입니다. STS는 스프링 프레임워크의 다양한 기능들을 통합하여 제공하기 때문에, 스프링 부트 개발에 있어서 유용합니다. STS는 다음 링크에서 다운로드가 가능합니다.

Spring Tool Suite(STS) 다운로드 링크

2.3 Spring Boot 프로젝트 생성

Spring Boot는 Maven 또는 Gradle을 이용하여 프로젝트를 생성할 수 있습니다. 이번 강의에서는 Maven을 이용하여 스프링 부트 프로젝트를 생성해 보겠습니다.

2.3.1 스프링 부트 프로젝트 생성하기

Spring Tool Suite(STS)를 실행합니다.
File → New → Other 메뉴를 클릭합니다.
New dialog 창에서 Maven Folder 를 선택하고 Maven Project 를 선택합니다.
Next 버튼을 클릭합니다.
프로젝트 생성 정보를 입력합니다.
- Group Id : com.example
- Artifact Id : myproject
- Packaging : jar
- Java Version : 8
Next 버튼을 클릭합니다.
Select Archetype 화면에서 org.springframework.boot:spring-boot-starter-web을 선택하고 Finish 버튼을 클릭합니다.

2.3.2 스프링 부트 애플리케이션 실행하기

Spring Boot 애플리케이션을 실행하기 위해서는 SpringBootApplication 어노테이션이 있는 클래스를 실행해주면 됩니다. 이번 강의에서는 STS에서 스프링 부트 애플리케이션을 실행하는 방법에 대해 알아보겠습니다.

스프링 부트 프로젝트에서 src/main/java 폴더에 위치한 com.example.myproject.MyProjectApplication 파일을 열어줍니다.
MyProjectApplication 클래스를 열어서, main() 메소드를 찾아 실행합니다.
Run as → Spring Boot App을 선택하면 스프링 부트 애플리케이션이 실행됩니다.
스프링 부트 애플리케이션 실행 후, 브라우저에서 http://localhost:8080에 접속하여 스프링 부트 애플리케이션이 정상적으로 동작하는지 확인합니다.

만약 8080 포트가 사용 중이라면, application.properties 파일에서 포트를 변경할 수 있습니다. src/main/resources/application.properties 파일을 열어서, 다음과 같이 포트를 변경할 수 있습니다.

server.port=8081

이렇게 설정하면 스프링 부트 애플리케이션은 8081 포트에서 실행됩니다.

Spring Initializr의 Artifact에 대한 설명

Spring Initializr는 Spring Boot 프로젝트를 시작하기 위한 도구입니다. 여기서 "artifact"는 Maven 또는 Gradle 프로젝트에서 사용되는 중요한 용어 중 하나입니다.

"artifact"를 직역하면 "작품" 또는 "유물"이라는 뜻이지만, 이 맥락에서 그러한 해석은 적절하지 않습니다. Maven이나 Gradle과 같은 빌드 툴에서 "artifact"는 빌드 또는 컴파일 과정을 거쳐 생성된 파일 (예: JAR, WAR 파일 등)을 의미합니다.

따라서, "Spring Initializr"의 "artifact"는 "생성된 빌드 파일" 또는 "빌드 결과물" 정도로 해석할 수 있습니다. 그러나 실제로 개발을 할 때는 '아티팩트' 또는 'artifact'로 그대로 사용하는 경우가 많습니다.

Spring Initializer를 사용하여 JavaCampus 프로젝트 생성 및 로컬 실행

1. Spring Initializer 접속

먼저 스프링 Initializer 웹 사이트(https://start.spring.io/)에 접속합니다.

2. 프로젝트 설정

Project Type: Maven 프로젝트를 선택합니다. (또는 Gradle 프로젝트를 선택할 수 있습니다.)
Language: Java를 선택합니다. (Kotlin이나 Groovy도 가능합니다.)
Packaging: Jar를 선택합니다.
Java Version: 사용하려는 Java 버전을 선택합니다. (예: 11)
Group: 프로젝트의 그룹 ID를 입력합니다. (예: com.javacampus)
Artifact: 프로젝트의 Artifact ID를 입력합니다. (예: JavaCampus)
Name: 프로젝트의 이름을 입력합니다. (예: JavaCampus)
Description: 프로젝트에 대한 설명을 입력합니다.
Package Name: 패키지 이름을 입력합니다. (예: com.javacampus)

3. 프로젝트 의존성 추가

필요한 의존성을 검색창에서 찾아 추가합니다. 예를 들어, 웹 애플리케이션을 개발할 경우 'web'을 검색하여 'Spring Web' 의존성을 선택합니다.

4. 프로젝트 다운로드

'Generate' 버튼을 클릭하여 프로젝트를 압축 파일로 다운로드합니다. 다운로드한 파일을 원하는 폴더에 압축 해제합니다.

5. 프로젝트 실행 환경 설정

IntelliJ IDEA를 사용하는 경우: 압축 해제한 폴더를 IntelliJ에서 'Open' 또는 'Import'하여 프로젝트를 엽니다.
Eclipse를 사용하는 경우: 'File' > 'Import' > 'Maven' > 'Existing Maven Projects'를 선택하고 압축 해제한 폴더를 지정하여 프로젝트를 엽니다.

6. 로컬에서 프로젝트 실행

IntelliJ IDEA: src/main/java 폴더 내에 생성된 'JavaCampusApplication' 클래스를 열어 'Run' 또는 'Debug' 버튼을 클릭하여 프로젝트를 실행합니다.
Eclipse: 프로젝트를 마우스 오른쪽 버튼으로 클릭하고 'Run As' > 'Java Application'을 선택하여 'JavaCampusApplication' 클래스를 실행합니다.

7. 웹 브라우저를 통해 로컬에서 실행 확인

웹 브라우저를 열고 'http://localhost:8080' 주소로 접속하여 프로젝트가 정상적으로 실행되는지 확인합니다.

8. 컨트롤러 및 엔드포인트 추가

기본적인 프로젝트 설정이 끝났으므로, 실제로 사용자와 상호작용할 수 있는 컨트롤러 및 엔드포인트를 추가할 수 있습니다. 예를 들어, "Hello, JavaCampus!" 메시지를 반환하는 간단한 컨트롤러를 만들어 보겠습니다.

src/main/java/com/javacampus 폴더 내에 HelloController.java 파일을 생성합니다.
아래의 코드를 작성하여 컨트롤러를 구현합니다.

package com.javacampus;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, JavaCampus!";
    }
}

9. 엔드포인트 테스트

프로젝트를 다시 실행하고 웹 브라우저에서 'http://localhost:8080/hello' 주소로 접속하여 "Hello, JavaCampus!" 메시지가 표시되는지 확인합니다.

3. Spring Boot 애플리케이션 구조

프로젝트 구조

Spring Boot 애플리케이션의 기본 프로젝트 구조는 다음과 같습니다.

.
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── myapp
│   │   │               └── MyApp.java
│   │   ├── resources
│   │   │   ├── application.properties
│   │   │   ├── static
│   │   │   └── templates
│   ├── test
│   │   └── java
│   │       └── com
│   │           └── example
│   │               └── myapp
│   │                   └── MyAppTests.java
├── pom.xml

애플리케이션 클래스

Spring Boot 애플리케이션은 애플리케이션 클래스를 사용하여 실행됩니다. 애플리케이션 클래스는 @SpringBootApplication 어노테이션을 사용하여 정의되며, main 메서드를 포함합니다.

package com.example.myapp;

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

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

프로퍼티 파일

Spring Boot 애플리케이션은 application.properties 파일을 사용하여 설정을 관리합니다. 이 파일은 프로젝트의 src/main/resources 디렉토리에 위치해야 합니다.

# 서버 포트 설정
server.port=8080

# 데이터베이스 연결 설정
spring.datasource.url=jdbc:mysql://localhost:3306/mydb?useSSL=false
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# JPA 설정
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

이 파일에는 애플리케이션에서 사용하는 여러 설정들을 저장할 수 있으며, 필요한 경우 추가 설정 파일을 생성하여 관리할 수도 있습니다.

4. 의존성 관리

스프링 부트 의존성 관리

Spring Boot는 의존성 관리를 단순화하기 위해 '스타터' 의존성을 제공합니다. 스타터는 특정 기능을 위해 필요한 모든 라이브러리를 포함하며, 버전이 호환되도록 관리됩니다. 스프링 부트 스타터를 사용하면 개발자가 각 라이브러리의 버전을 신경 쓸 필요가 없습니다.

예를 들어, 웹 애플리케이션 개발에 필요한 의존성을 추가하려면 spring-boot-starter-web 스타터를 사용할 수 있습니다.

Maven 또는 Gradle 빌드 시스템

Spring Boot 애플리케이션은 Maven이나 Gradle 빌드 시스템을 사용하여 의존성을 관리합니다. 빌드 시스템을 사용하면 의존성을 쉽게 추가, 제거 및 관리할 수 있습니다.

Maven

Maven을 사용하는 경우, pom.xml 파일에 의존성을 추가할 수 있습니다. 예를 들어, 웹 애플리케이션을 개발하기 위해 spring-boot-starter-web 의존성을 추가하려면 다음 코드를 pom.xml 파일에 추가합니다.

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Gradle

Gradle을 사용하는 경우, build.gradle 파일에 의존성을 추가할 수 있습니다. 예를 들어, 웹 애플리케이션을 개발하기 위해 spring-boot-starter-web 의존성을 추가하려면 다음 코드를 build.gradle 파일에 추가합니다.

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

5. 스프링 부트 애플리케이션 실행

내장 서버 (Embedded Server)

Spring Boot 애플리케이션은 내장 서버를 사용하여 실행됩니다. 대표적인 내장 서버로는 Tomcat, Jetty, Undertow 등이 있습니다. 기본적으로 Spring Boot는 Tomcat을 내장 서버로 사용하며, 별도의 설정이 필요 없습니다.

내장 서버를 사용하면 애플리케이션을 별도의 서버에 배포할 필요 없이 바로 실행할 수 있어 개발 및 테스트 작업이 간편해집니다.

애플리케이션 실행 방법

IDE에서 실행: IntelliJ, Eclipse 등의 IDE에서는 애플리케이션 클래스를 우클릭한 후 'Run' 또는 'Debug'를 선택하여 애플리케이션을 실행할 수 있습니다.
명령어를 사용한 실행: 애플리케이션을 실행하려면 프로젝트 디렉토리에서 다음 명령어를 실행합니다.
- Maven: ./mvnw spring-boot:run
- Gradle: ./gradlew bootRun
실행 가능한 JAR 파일로 실행: 애플리케이션을 패키징한 후, 실행 가능한 JAR 파일을 사용하여 애플리케이션을 실행할 수 있습니다. 패키징은 다음 명령어를 사용하여 수행할 수 있습니다.
- Maven: ./mvnw package
- Gradle: ./gradlew build
패키징이 완료되면 target 또는 build/libs 디렉토리에 실행 가능한 JAR 파일이 생성됩니다. 이 파일을 사용하여 애플리케이션을 실행하려면 다음 명령어를 사용합니다.

java -jar target/myapp-0.0.1-SNAPSHOT.jar

6. Spring Boot Starter Pack

스타터 팩의 개념

Spring Boot Starter Pack은 의존성 관리를 간편하게 하기 위해 제공되는 라이브러리 모음입니다. Starter Pack은 특정 기능을 위해 필요한 모든 라이브러리를 포함하며, 버전이 호환되도록 관리됩니다. 스프링 부트 스타터 팩을 사용하면 개발자가 각 라이브러리의 버전을 신경 쓸 필요가 없습니다.

자주 사용되는 Starter Pack

다음은 Spring Boot에서 자주 사용되는 Starter Pack의 예입니다.

spring-boot-starter-web: 웹 애플리케이션 개발을 위한 스타터 팩입니다. Spring MVC, Tomcat, Jackson 등의 라이브러리를 포함합니다.

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

spring-boot-starter-data-jpa: JPA 및 Hibernate를 사용한 데이터 액세스를 위한 스타터 팩입니다.

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

spring-boot-starter-security: Spring Security를 사용하여 애플리케이션의 보안을 강화하는데 사용되는 스타터 팩입니다.

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

spring-boot-starter-test: 애플리케이션 테스트를 위한 스타터 팩입니다. JUnit, Mockito, Hamcrest 등의 라이브러리를 포함합니다.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

이외에도 Spring Boot는 여러 가지 기능을 위한 다양한 Starter Pack을 제공하고 있습니다. 필요한 기능에 맞는 Starter Pack을 사용하여 의존성 관리를 간편하게 할 수 있습니다.

7. 스프링 부트와 데이터베이스

스프링 부트에서 데이터베이스 사용

Spring Boot는 다양한 데이터베이스와 쉽게 통합할 수 있는 기능을 제공합니다. JPA(Java Persistence API)를 사용하여 데이터베이스와 객체 간의 매핑을 처리할 수 있으며, Spring Data JPA를 사용하여 더 간편한 데이터 액세스 및 관리를 제공합니다.

H2 데이터베이스

H2는 인메모리 데이터베이스로, 개발 및 테스트 작업에 유용합니다. H2 데이터베이스를 사용하려면 spring-boot-starter-data-jpa 및 com.h2database:h2 의존성을 추가해야 합니다.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

H2 데이터베이스를 사용하려면 application.properties 파일에 다음 설정을 추가합니다.

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

MySQL 데이터베이스

MySQL 데이터베이스를 사용하려면 spring-boot-starter-data-jpa 및 mysql-connector-java 의존성을 추가해야 합니다.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

MySQL 데이터베이스를 사용하려면 application.properties 파일에 다음 설정을 추가합니다.

spring.datasource.url=jdbc:mysql://localhost:3306/mydb?useSSL=false
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

이 설정을 통해 MySQL 데이터베이스와 연결할 수 있으며, 필요에 따라 추가 설정을 통해 데이터베이스 연결 및 사용을 더욱 세밀하게 조절할 수 있습니다.

JPA를 이용한 데이터베이스 연동

Java Persistence API(JPA)는 자바 객체와 관계형 데이터베이스 간의 매핑을 처리하는 표준 명세입니다. 스프링 부트에서는 JPA를 이용하여 데이터베이스 연동을 쉽게 구현할 수 있습니다.

의존성 추가: JPA를 사용하려면 먼저 spring-boot-starter-data-jpa 의존성을 추가해야 합니다.

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

Entity 클래스 작성: 데이터베이스 테이블과 매핑되는 자바 객체를 작성합니다. @Entity 어노테이션을 사용하여 이 클래스가 엔티티임을 나타냅니다.

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

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

    private String name;
    private String email;

    // 생성자, getter, setter 등 생략
}

Repository 인터페이스 작성: 데이터 액세스를 처리하는 Repository 인터페이스를 작성합니다. 이 인터페이스는 JpaRepository 인터페이스를 상속받아야 하며, 제네릭 타입으로 엔티티 클래스와 ID 타입을 지정합니다.

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

public interface UserRepository extends JpaRepository<User, Long> {
}

서비스 및 컨트롤러 작성: Repository를 사용하여 데이터베이스와 상호 작용하는 서비스 및 컨트롤러를 작성합니다.

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

import java.util.List;

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

    public List<User> findAll() {
        return userRepository.findAll();
    }

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

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

import java.util.List;

@RestController
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/users")
    public List<User> findAll() {
        return userService.findAll();
    }

    @PostMapping("/users")
    public User save(@RequestBody User user) {
        return userService.save(user);
    }
}

이렇게 JPA를 사용하면 데이터베이스 연동 작업을 쉽게 처리할 수 있으며, SQL 작성 없이도 CRUD 작업을 수행할 수 있는 장점이 있습니다.

8. RESTful API 개발

RESTful API 개념

REST(REpresentational State Transfer)는 웹 서비스 개발을 위한 아키텍처 스타일입니다. RESTful API는 HTTP 프로토콜을 사용하여 서버와 클라이언트 간의 자원을 주고받는 방식을 정의합니다. RESTful API는 다음과 같은 특징을 가집니다:

Stateless: 각 요청 간에 상태 정보를 저장하지 않습니다.
Cacheable: 클라이언트는 응답을 캐시할 수 있습니다.
Client-Server: 클라이언트와 서버가 분리되어 각각의 관심사를 독립적으로 처리합니다.

HTTP 요청 처리

스프링 부트에서는 @RestController 어노테이션을 사용하여 RESTful API를 개발할 수 있습니다. HTTP 요청 처리를 위한 어노테이션을 사용하여 각 메서드와 매핑할 수 있습니다.

@GetMapping: HTTP GET 요청을 처리합니다.
@PostMapping: HTTP POST 요청을 처리합니다.
@PutMapping: HTTP PUT 요청을 처리합니다.
@DeleteMapping: HTTP DELETE 요청을 처리합니다.

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

데이터 처리

HTTP 요청으로부터 데이터를 처리하기 위해 다음 어노테이션을 사용할 수 있습니다:

@PathVariable: URL 경로에 포함된 변수를 메서드 매개변수로 전달합니다.
@RequestParam: URL 쿼리 파라미터를 메서드 매개변수로 전달합니다.
@RequestBody: 요청 본문을 메서드 매개변수로 전달합니다.

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @GetMapping("/users/{id}")
    public String getUser(@PathVariable Long id) {
        // ...
    }

    @GetMapping("/users")
    public String searchUsers(@RequestParam String query) {
        // ...
    }
}

HTTP 응답 처리

스프링 부트에서는 ResponseEntity를 사용하여 HTTP 응답을 처리할 수 있습니다. ResponseEntity는 HTTP 응답에 포함되는 상태 코드, 헤더, 본문을 캡슐화합니다.

다음 예제는 사용자 생성 요청을 처리하는 RESTful API를 작성하는 방법을 보여줍니다.

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @PostMapping("/users")
    public ResponseEntity<String> createUser(@RequestBody User user) {
        // 데이터 저장 로직 등...
        
        return new ResponseEntity<>("User created successfully", HttpStatus.CREATED);
    }
}

이러한 방법을 사용하여 HTTP 응답 처리를 수행할 수 있으며, 필요에 따라 다양한 응답 형태를 구현할 수 있습니다. 이를 통해 클라이언트에 적절한 응답을 전달할 수 있습니다.

9. 스프링 부트와 보안

Spring Security의 개념

Spring Security는 스프링 기반 애플리케이션의 보안을 위한 프레임워크입니다. 인증, 인가, CSRF(Cross-Site Request Forgery) 방지, 세션 관리 등 다양한 보안 기능을 제공합니다.

Spring Security 설정

의존성 추가: spring-boot-starter-security 의존성을 추가합니다.

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

보안 설정 클래스 작성: WebSecurityConfigurerAdapter를 상속받아 보안 설정 클래스를 작성합니다.

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 요청에 대한 인증 및 인가 설정
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 사용자 인증 및 권한 정보 설정
    }
}

사용자 인증 및 권한 부여

인메모리 사용자 인증: AuthenticationManagerBuilder를 사용하여 인메모리 사용자 인증을 구성할 수 있습니다.

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .inMemoryAuthentication()
        .withUser("user").password("{noop}password").roles("USER")
        .and()
        .withUser("admin").password("{noop}adminpassword").roles("ADMIN");
}

인증 및 인가 설정: HttpSecurity 객체를 사용하여 URL에 따른 인증 및 인가 설정을 수행할 수 있습니다.

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .antMatchers("/user/**").hasRole("USER")
            .anyRequest().authenticated()
        .and()
        .formLogin()
            .loginPage("/login").permitAll()
        .and()
        .logout()
            .logoutUrl("/logout").permitAll();
}

이렇게 설정하면, /admin으로 시작하는 URL에는 'ADMIN' 권한이 필요하며, /user로 시작하는 URL에는 'USER' 권한이 필요합니다. 인증되지 않은 사용자는 로그인 페이지로 리다이렉트됩니다.

Spring Security를 사용하면 애플리케이션의 보안을 쉽게 관리할 수 있으며, 필요에 따라 다양한 인증 및 인가

다음 내용을 기술 문서로 작성하세요. 기술 문서는 순수 markdown 코드로 주시되, 문서 내의 코드나 출력, 명령 결과는 ``` 코드 블록으로 묶어서 실행되지 않도록 해주세요.

10. 스프링 부트 테스트

JUnit 5 기본 사용법

JUnit 5는 자바 애플리케이션의 유닛 테스트를 작성하고 실행하는데 사용되는 테스트 프레임워크입니다. 스프링 부트 프로젝트에서 JUnit 5를 사용하려면 spring-boot-starter-test 의존성을 추가해야 합니다.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

JUnit 5에서 테스트 클래스와 메서드를 작성하는 방법은 다음과 같습니다.

테스트 클래스에 @ExtendWith(SpringExtension.class) 어노테이션을 추가합니다.
테스트 메서드에 @Test 어노테이션을 추가합니다.

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.test.context.junit.jupiter.SpringExtension;

@ExtendWith(SpringExtension.class)
public class MyTests {

    @Test
    public void testMethod() {
        // ...
    }
}

MockMvc를 이용한 Controller 테스트

MockMvc를 사용하여 스프링 MVC 컨트롤러의 테스트를 수행할 수 있습니다. MockMvc를 사용하려면 다음과 같이 설정합니다.

테스트 클래스에 @WebMvcTest 어노테이션을 추가합니다.
MockMvc 객체를 주입받습니다.

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.web.servlet.MockMvc;

@ExtendWith(SpringExtension.class)
@WebMvcTest(MyController.class)
public class MyControllerTests {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testMethod() {
        // ...
    }
}

TestRestTemplate을 이용한 API 테스트

TestRestTemplate을 사용하여 API 테스트를 수행할 수 있습니다. TestRestTemplate를 사용하려면 다음과 같이 설정합니다.

테스트 클래스에 @SpringBootTest와 @AutoConfigureMockMvc 어노테이션을 추가합니다.
TestRestTemplate 객체를 주입받습니다.

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
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.test.context.junit.jupiter.SpringExtension;
import org.springframework.boot.test.web.client.TestRestTemplate;

@ExtendWith(SpringExtension.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureMockMvc
public class MyApiTests {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testMethod() {
        // ...
    }
}

이렇게 설정한 후, TestRestTemplate의 메서드를 사용하여 HTTP 요청을 보내고 응답을 검증할 수 있습니다. 예를 들어, 다음 코드는 /api/users 경로에 GET 요청을 보내고 응답의 상태 코드가 200인지 검증합니다.

@Test
public void getUsers() {
    ResponseEntity<String> response = restTemplate.getForEntity("/api/users", String.class);
    assertEquals(HttpStatus.OK, response.getStatusCode());
}