Tiny Commit

[스프링부트 완전정복] 13. RESTful 웹 서비스

Tiny Commit — Tue, 30 Dec 2025 19:38:21 +0900

1. RESTful 웹 서비스의 개요

REST(Representational State Transfer) 원리를 사용하여 HTTP와 웹의 장점을 최대한 활용할 수 있는 아키텍처입니다.
특정 자원에 대해 CRUD(Create, Read, Update, Delete) 연산을 수행하기 위해 URI로 자원을 명시하고, GET, POST, PUT, DELETE 등의 HTTP 방식을 사용하여 요청을 보냅니다.

RESTful 웹 서비스의 3대 구성 요소

리소스 (Resource): 서버의 고유한 아이디를 가진 자원을 의미하며 URI에 해당합니다.
메서드 (Method): 리소스에 대해 요청을 보내는 방식으로 GET, POST, PUT, PATCH, DELETE 등이 있습니다.
리소소 형태 (Representation): 클라이언트와 서버가 데이터를 주고받는 형태로 JSON, XML, TEXT 등이 있으며 최근에는 JSON을 주로 사용합니다.

URL과 URI의 차이 URL은 리소스의 위치를 의미하고, URI는 리소스를 식별하는 문자열 구성을 의미합니다. URI가 URL을 포함하는 더 포괄적인 범위입니다.

2. RESTful 방식의 애너테이션

주요 애너테이션 요약

유형	설명
@RequestBody	컨트롤러 요청 처리 메서드의 매개변수에 선언하며, HTTP 요청 본문(body)을 해당 매개변수에 바인딩합니다.
@ResponseBody	컨트롤러 요청 처리 메서드의 매개변수에 선언하며, 반환값을 HTTP 응답 본문(body)에 바인딩합니다.
@RestController	@Controller와 @ResponseBody를 결합한 형태로, REST API를 제공하는 컨트롤러임을 명시합니다.

2.1 @RequestBody

HTTP 요청 본문 내용을 XML, JSON 또는 기타 데이터 형태의 자바 객체로 매핑하는 역할을 합니다.
폼 페이지에서 name=value 형태로 전송되는 일반적인 데이터는 @RequestParam 등을 사용하지만, JSON과 같은 문자열 형태의 데이터는 @RequestBody를 통해 전달받아야 합니다.

// @RequestBody로 단일 매개변수 받기

@PostMapping()
public String submit(@RequestBody String param, Model model) {
    model.addAttribute("data1", "@RequestBody로 정보 받기");
    model.addAttribute("data2", param);
    return "viewPage01_result";
}

요청 처리를 RequestBody에 선언하고 선언된 매개변수는 폼 페이지에서 입력된 다중 값을 &로 연결된 name = value형태로 전달 받습니다.
폼페이지에서 입력을 하면, sumit(컨트롤러 요청처리 메서드)에서 매개변수를 받가 각각을 출력합니다. (data1, data2)

// @RequestBody를 활용한 요청 데이터 처리

@Controller
@RequestMapping("/exam02")
public class Example02Controller {

    @GetMapping("/form")
    public String form() {
        return "exam02/form"; // 입력 폼 페이지로 이동
    }

    @PostMapping("/submit")
    @ResponseBody // 리턴값을 페이지가 아닌 데이터(JSON 등)로 응답
    public Map<String, String> submit(@RequestBody HashMap<String, String> map) {
        // @RequestBody: HTTP 요청 본문(JSON)을 Map 객체로 변환
        return map; // 전달받은 데이터를 그대로 JSON 형태로 반환
    }
}

사용자 웹 요청이 GET방식이면 컨트롤러 요청 처리 메서드가 showFOrm()으로 viewPage02를 출력합니다.
폼을 입력하면 POST방식으로 호출되어 sumit()이 실행됩니다.
sumit매서드는 매개변수 HashMap타입의 map객체는 JSON형식으로 전달됩니다.

2.2 @ResponseBody

자바 객체를 HTTP 응답 본문(body) 내용으로 매핑하여 클라이언트에게 전달합니다.
@RequestBody와 마찬가지로 데이터 형식(JSON/XML)에 맞는 메시지 변환기(HttpMessageConverter)가 작동하여 자동으로 변환해 줍니다.

@Controller
@RequestMapping("/exam03")
public class Example03Controller {

    @GetMapping("/submit")
    @ResponseBody // 객체를 직접 HTTP 응답 본문으로 전송
    public Person submit() {
        Person person = new Person();
        person.setName("HongGilSon");
        person.setAge(20);
        person.setEmail("hgs@naver.com");
        
        return person; // MappingJackson2HttpMessageConverter가 JSON으로 자동 변환 
        		// 객체가 JSON 형식 {"name":"HongGilSon", ...}으로 응답됨
    }
}

package com.springboot.domain;

import lombok.Data; // Lombok 라이브러리 사용

@Data // Getter, Setter, toString, EqualsAndHashCode 등을 자동 생성
public class Person {
    private String name;
    private String age;
    private String email;
}

2.3 @RestController

클래스 전체에 @RestController를 적용하여 모든 메서드에서 @ResponseBody를 생략하는 최신 방식입니다.
@Controller일때는 @ResponseBody를 선언해야 하지만 @RestController를 사용하면 @ResponseBody를 붙일 필요 없다.
- 메서드마다 @ResponseBody를 자동으로 붙여 코드가 간결해집니다.
- 변환값을 JSON으로 변환해서 응답합니다.

@RestController // @Controller + @ResponseBody 합쳐진 형태
@RequestMapping("/exam04")
public class Example04Controller {

    @GetMapping("/submit")
    public Person submit() {
        // 별도의 @ResponseBody 선언 없이도 Person 객체가 JSON으로 반환됨
        Person person = new Person();
        person.setName("HongGilSon");
        person.setAge(20);
        person.setEmail("hgs@naver.com");
        
        return person;
    }
}

3. RESTful 웹 서비스의 CRUD

CRUD(Create, Read, Update, Delete)를 HTTP 요청 방식과 매핑하여 리소스에 접근합니다.

유형	설명	CRUD 작업
POST	새로운 리소스를 생성하거나 기존 리소스를 갱신	Create
GET	리소스를 조회하여 읽어 오기	Read
PUT	리소스를 변경	Update
DELETE	기존 리소스를 삭제	Delete
OPTION	리소스에 대한 사용 가능한 작업 얻기

// application.properties
spring.mvc.hiddenmethod.filter.enabled=true

@Controller
@RequestMapping("/exam05")
public class Example05Controller {

    // 수정을 위한 폼 페이지 출력 (GET 방식)
    @GetMapping
    public String showForm(@ModelAttribute Person person) {
        return "viewPage05";
    }

    // 데이터를 실제로 수정 처리 (PUT 방식)
    @PutMapping
    public String submit(@ModelAttribute Person person, Model model) {
        model.addAttribute("data1", "@PutMapping 적용하기");
        model.addAttribute("data2", person);
        System.out.println(person); // 콘솔에 수정된 객체 정보 출력
        return "viewPage05_result";
    }
}

<form action="exam05" method="post">
    <input type="hidden" name="_method" value="put" /> 
    
    <p>이름 : <input type="text" name="name" /></p>
    <p>나이 : <input type="text" name="age" /></p>
    <p>이메일 : <input type="text" name="email" /></p>
    <input type="submit" value="확인" />
</form>

4. [도서 쇼핑몰] 장바주니 페이지 만들기

RESTful 방식의 장바구니 기본 구조 만들기
RESTful 웹 서비스를 위한 장바구니 CRUD 만들기

출처 : 송미영, 『 스프링부트 완전정복: 개념부터 실정 프로젝트까지 』길벗캠퍼스 (2024).

[스프링부트 완전정복] 12. 로그 기록

Tiny Commit — Tue, 30 Dec 2025 10:38:18 +0900

1. 로드의 개요

실행되는 동안 남긴 로그 기옥은 애플리테이션의 정확한 상황과 상태 정보를 제공합니다.

1.1 로깅 라이브러리

로그는 애플리케이션이 실행되는 동안 버그나 성능에 관한 통계 등의 정보를 전달하는 역할을 합니다.
필요한 정보를 직접 로깅하거나, 문제의 원인을 파악할 수 있는 다양한 로깅 라이브러리를 제공합니다.

로깅 라이브러리 유형

유형	설명
java.util.logging	자바에서 기본으로 제공하는 로깅 패키지
Log4j	2015년에 개발이 중단된 가장 오래된 로깅 라이브러리 중 하나
Logback	Log4j 이후 출시되었으며, 스프링 부트의 spring-boot-starter-logging에 기본 포함됨
Log4j2	가장 최근에 등장했으며 Logback과 유사한 기능을 가짐 (Java 7 이상 동작)

로그 레벨 유형

TRACE < DEBUG < INFO < WARN < ERROR < FATAL

레벨	설명
FATAL	조기 종료를 유발하는 아주 심각한 오류
ERROR	런타임 오류 또는 예상치 못한 에러 상황
WARN	실행에는 문제없으나 향후 발생할 수 있는 잠재적 문제에 대한 경고
INFO	시작/종료와 같은 런타임 이벤트 정보 (일반적인 정보 확인용)
DEBUG	개발 단계에서 시스템 흐름을 파악하기 위한 상세 정보
TRACE	가장 상세한 로그 레벨로 최하위 수준의 정보 출력

1.2 SLF4J와 로깅 라이브러리

SLF4J는 다양한 로깅 라이브러리를 통일된 방식으로 사용할 수 있게 해주는 추상 인터페이스입니다.
SLF4J를 사용하면 코드 수정 없이 라이브러리만 교체하여 로그를 관리할 수 있습니다.
Lombok의 @Slf4j 애너테이션을 사용하면 별도의 로깅 선언 코드 없이 바로 log 객체를 사용할 수 있습니다.

// SLF4J의 로그 레벨 동작 예

@Controller
public class Example01Controller {
    @GetMapping("/exam01")
    public String requestMethod(Model model) {
    	Logger logger = LoggerFactory.getLogger(Example01Controller.class);
        logger.trace("Trace 메시지!");
        logger.debug("Debug 메시지!");
        logger.info("Info 메시지!");
        logger.warn("Warn 메시지!");
        logger.error("Error 메시지!");
        model.addAttribute("data", "Slf4j로 로그 출력하기")
        return "viewPage";
    }
}

// Slf4j를 이용한 로그 레벨 동작 예

@Slf4j
@Controller
public class Example02Controller {
    @GetMapping("/exam02")
    public String requestMethod(Model model) {
        log.trace("Trace 메시지!");
        log.debug("Debug 메시지!");
        log.info("Info 메시지!");
        log.warn("Warn 메시지!");
        log.error("Error 메시지!");
        
        return "viewPage";
    }
}

2. Log4j2를 이용한 로그 기록

2.1 Log4j2의 개요

자바로 작성되어 안정적이고 신속하며 유연합니다.
보안 취약점을 개선하여 로깅기능 강화시킨것으로 멀티스레드 환경에서 성능향상
로그 메시지의 더 나은 파라미터화
로그 이벤트에 더 많은 메타데이터 제공
로깅의 유연성과 확장성을 증가

스프링 부트 기본 로거인 Logback과 충돌을 방지하기 위해 기본 로거를 제외하고 Log4j2 의존성을 추가해야 합니다.

configurations {
    all {
        // Log4j2와의 충돌 방지를 위해 기본 로거 삭제
        exclude group: 'org.springframework.boot', module: 'spring-boot-starter-logging'
    }
}

dependencies {
    // Log4j2 의존성 라이브러리 추가
    implementation 'org.springframework.boot:spring-boot-starter-log4j2'
}

2.2 Log4j2 구조

Log4j2는 크게 세 가지 요소로 구성됩니다:

Logger: 로그 기록을 수행하는 핵심 모듈.

Logger는 로그 작업을 수행하는 핵심 요소로, 로그 레벨과 Appender 설정을 통해 출력 대상과 위치를 결정합니다.
Root Logger: <Root> 요소로 정의하며, 일반적인 로그 설정의 기본이 됩니다.
일반 Logger: <Logger> 요소로 정의하며, 특정 패키지나 클래스별로 다른 설정을 적용할 수 있습니다.

<Configuration>
    <Loggers>
        <Logger name="com.springboot" level="DEBUG" additivity="false">
            <AppenderRef ref="console"/>
        </Logger>
        
        <Root level="INFO">
            <AppenderRef ref="console"/>
        </Root>
    </Loggers>
</Configuration>

Appender: 로그가 출력될 위치(콘솔, 파일, DB 등)를 결정.

<Console>: 콘솔에 출력.
<File>: 특정 파일에 계속 기록.
<RollingFile>: 파일 크기나 날짜에 따라 백업 파일을 생성하며 기록.

<Appenders>
    <Console name="console" target="SYSTEM_OUT">
        <PatternLayout pattern="%d %5p [%c] %m%n"/>
    </Console>

    <File name="file" fileName="./logs/file/sample.log" append="false">
        <PatternLayout pattern="%d %5p [%c] %m%n"/>
    </File>

    <RollingFile name="rollingFile" fileName="log.log" filePattern="log.%i.log">
        <PatternLayout pattern="%d %5p [%c] %m%n"/>
        <Policies>
            <SizeBasedTriggeringPolicy size="15MB"/> <TimeBasedTriggeringPolicy interval="1"/> </Policies>
        <DefaultRolloverStrategy max="3" fileIndex="min"/> </RollingFile>
</Appenders>

Layout: 로그의 출력 형식을 결정 (주로 PatternLayout 사용).

<PatternLayout pattern="%d{HH:mm:ss,SSS} [%thread] %-5level %logger{36} - %msg%n" />

// 로깅 실전 코드 (Lombok @Slf4j 활용)
// Lombok의 @Slf4j를 사용하면 별도의 로거 생성 코드 없이 편리하게 로그를 남길 수 있습니다.

@Slf4j
@Controller
public class Example02Controller {
    @GetMapping("/exam02")
    public String requestMethod2(Model model) {
        log.trace("Trace 메시지!");
        log.debug("Debug 메시지!");
        log.info("Info 메시지!");
        log.warn("Warn 메시지!");
        log.error("Error 메시지!");
        
        model.addAttribute("data", "@Slf4j로 로그 출력하기");
        return "viewPage";
    }
}

3. 인터셉터를 이용한 로그 기록

특정 URL 을 요청할 때 컴트롤러로 가는 요청을 가로챈 뒤 특정 작업을 처리하는 것

3.1 인터셉터

사용자가 URL을 요청하면 컨트롤러에 요청이 들어가기 전(또는 응답하기 전)에 가로채어 특정 작업을 수행합니다.

주요 기능:

응답 페이지를 출력하기 전에 서버에서 데이터를 미리 가져오는 기능
폼에서의 제출(submit) 중복을 막는 기능
요청이 처리되기 전에 파일을 업로드하는 기능
각 요청에 대한 상세 내역을 기록하는 기능
유효성을 검사하는 기능
시간별 동작 및 성능의 병목 지점을 검사하는 기능

3.2 HandlerInterceptor로 로그 기록

인터셉터의 주요 메서드 및 동작 시점

preHandle(): 컨트롤러가 호출되기 전 실행됩니다. false 반환 시 이후 과정은 실행되지 않습니다.
postHandle(): 컨트롤러가 정상 처리된 후, 뷰로 전달되기 전 실행됩니다.
afterCompletion(): 뷰 전송이 완료된 후, 즉 모든 처리가 끝난 후 실행됩니다.

// 인터셉터 클래스 구현 (ExampleInterceptor.java)

package com.springboot.controller;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.method.HandlerMethod;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ExampleInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.info("preHandle() 호출......");
        if (handler instanceof HandlerMethod) {
            HandlerMethod method = (HandlerMethod) handler;
            log.info("핸들러 메서드명 : " + method.getMethod().getName());
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, org.springframework.web.servlet.ModelAndView modelAndView) throws Exception {
        log.info("postHandle() 호출......");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.info("afterCompletion() 호출......");
    }
}

// 인터셉터 등록 설정 (LoggingConfig.java)
// 작성한 인터셉터를 스프링 빈으로 등록해야 작동합니다.

package com.springboot.config;

import com.springboot.controller.ExampleInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class LoggingConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 인터셉터를 등록함
        registry.addInterceptor(new ExampleInterceptor());
    }
}

4. [도서 쇼핑몰] 로그 기록 만들기

Log4j2로 콘솔에 로그 기록하기
인터센터로 모든 요청 URL의 콘솔 및 파일에 로그 기록하기
인터셉터로 특정 요청 URL의 콘솔 및 파일에 로그 기록하기

출처 : 송미영, 『 스프링부트 완전정복: 개념부터 실정 프로젝트까지 』길벗캠퍼스 (2024).

[스프링부트 완전정복] 11. 예외 처리

Tiny Commit — Tue, 30 Dec 2025 09:47:40 +0900

1. 예외 처리의 개요

스프링 부트 애플리케이션을 개발하다 보면 웹 요청 처리 중 다양한 예외가 발생합니다. 예외가 발생했을 때 사용자에게 단순히 에러 페이지를 보여주는 것이 아니라, 적절한 HTTP 상태 코드와 메시지를 전달하는 것이 중요합니다.

1.1 예외 처리

프로그램 실행 중 문제가 발생했을 때, 해당 처리를 중단하고 비정상 종료를 막기 위해 별도의 처리를 하는 것을 의미합니다. 웹 애플리케이션에서는 에러 발생 시 사용자에게 적절한 응답을 주는 것이 핵심입니다.

1.2 예외 처리 방법

웹 요청에 따라 컨트롤러의 요청 처리 ㅁ서드가 실행되는 중에 발생한 예외를 처리할 수 있는 유용한 애너페이션

애너테이션	설명
@ResponseStatus	예외를 특정 HTTP 상태 코드와 매핑하여 응답
@ExceptionHandler	특정 컨트롤러 내에서 발생하는 에러를 직접 구체화하여 처리
@ControllerAdvice	여러 컨트롤러에서 발생하는 공통 예외를 한곳에서 모아 처리

2. @ResponseStatus 를 이용한 HTTP 상태 코드 기반 예외 처리

2.1 HTTP 상태 코드

서버가 정상 처리되었는지 오류가 발생했는지를 알려주는 정보를 담고 있는것

상태 코드	상숫값	설명
400	BAD_REQUEST	잘못된 요청일 때 사용
401	UNAUTHORIZED	클라이언트 인증 문제 발생 시 사용
403	FORBIDDEN	접근 권한이 없을 때 사용
404	NOT_FOUND	요청한 리소스가 없을 때 사용
405	METHOD_NOT_ALLOWED	지원하지 않는 HTTP 메서드 사용 시
500	INTERNAL_SERVER_ERROR	서버 내부 로직 오류(API 오류) 발생 시

2.2 @ResponseStatus로 예외 처리

컨트롤러 메서드에 직접 사용: 특정 메서드 실행 시 예외가 발생하면 지정된 코드를 반환합니다.
사용자 정의 예외 클래스에 사용: 특정 예외 클래스가 던져질 때마다 지정된 코드를 반환합니다. (권장)

// [코드 예시 1] 메서드에 선언하는 경우

@ResponseStatus(value = HttpStatus.BAD_REQUEST, reason = "요청에 실패했습니다.")
@GetMapping("/exam01")
public void requestMethod() {
    // 예외 발생 시 400 Bad Request 반환
}

// [코드 예시 2] 예외 클래스에 선언하는 경우
// 사용자 정의 예외를 만들고 어노테이션을 붙여두면, 어디서든 이 예외가 발생할 때 동일한 응답을 보낼 수 있습니다.

@GetMapping("/exam02")
public void requestMethod() throws Exception {
    // 예외 발생 시 
}



@ResponseStatus(value = HttpStatus.NOT_FOUND, reason = "찾을 수 없습니다")
public class UserException extends RuntimeException {
    public UserException(String message) {
        super(message);
    }
}

3. @ExceptionHandler 를 이용한 HTTP 상태 코드 기반 예외 처리

3.1 @ExceptionHandler: 컨트롤러 기반 예외 처리

@ExceptionHandler는 특정 컨트롤러 클래스 내에서 발생하는 예외를 직접 잡아서 처리할 때 사용합니다.

특징: 발생한 예외 정보를 직접 얻을 수 있고, 에러 전용 뷰 페이지로 이동시키거나 상세 메시지를 사용자에게 응답할 수 있습니다.
사용법: 컨트롤러 내부에 별도의 메서드를 만들고 잡고 싶은 예외 클래스를 지정합니다.

// [코드 예시] 컨트롤러 내 예외 처리

@Controller
public class Example03Controller {

    @GetMapping("/exam03")
    public void requestMethod() {
        throw new UserException("UserException 메시지입니다");
    }

    // UserException 발생 시 이 메서드가 실행됨
    @ExceptionHandler(UserException.class)
    public String handleException(UserException ex, Model model) {
        model.addAttribute("data1", ex.getMessage());
        model.addAttribute("data2", ex);
        return "viewPage"; // 에러 전용 뷰 페이지 반환
    }
}

4. @ControllerAdvice 를 이용한 HTTP 상태 코드 기반 예외 처리

4.1 @ControllerAdvice: 전역(Global) 예외 처리

애플리케이션 내의 여러 컨트롤러에서 발생하는 예외를 한곳에서 공통으로 처리하고 싶을 때 사용합니다. 이를 통해 각 컨트롤러마다 예외 처리 코드를 중복해서 작성할 필요가 없어집니다.

범위 설정: basePackages 속성을 통해 특정 패키지 내의 컨트롤러만 관리하도록 설정할 수 있습니다.
지원 기능: @ExceptionHandler뿐만 아니라 @ModelAttribute, @InitBinder가 선언된 메서드도 사용할 수 있습니다.

@ControllerAdvice 주요 속성

요소	타입	설명
annotations	Class<? extends Annotation>[]	특정 애너테이션이 붙은 컨트롤러만 대상
basePackages	String[]	지정한 패키지 및 하위 패키지 대상 (가장 많이 사용)
assignableTypes	Class<?>[]	특정 클래스 타입의 컨트롤러 대상

// [코드 예시] 전역 예외 처리 클래스

@ControllerAdvice(basePackages={"com.springboot"})
public class GlobalException {

    @ExceptionHandler(RuntimeException.class)
    private String handleErrorMessage(Exception ex, Model model) {
        model.addAttribute("data1", "GlobalException 메시지입니다");
        model.addAttribute("data2", ex);
        return "viewPage";
    }
}

5. [도서 쇼핑몰] 예외 처리 페이지 만들기

@ResponseStatus로 예외 처리하기
@ExceptionHandler로 예외 처리하기
@ControllerAdvice로 예외 처리하기

출처 : 송미영, 『 스프링부트 완전정복: 개념부터 실정 프로젝트까지 』길벗캠퍼스 (2024).

[스프링부트 완전정복] 10장. 시큐리티 처리

Tiny Commit — Tue, 16 Dec 2025 15:30:29 +0900

1. 스프링 시큐리티의 개요

시큐리티: 허가된 사용자만 특정 웹페이지에 접근할 수 있도록 제한하는 보안 기능을 쉽게 구현할 수 있다.

1.1 스프링 시큐리티

스프링 시큐리티: 스프링을 기반으로 하는 애플리케이션에서 보안을 담당하는 프레임워크.
- 로그인 및 로그아웃 기능
- 인증 및 승인
- 사용자의 URL 접근 허용 또는 차단
- OAuth 구현
- 통합 인증, 경량 디렉터리 액세스 프로포콜 구현
- 역할 기반 액세스 제공

1.2 기본 설정

Build.gradle파일에 의존 라이브러리를 등록해야 합니다.

dependencies {
    implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity6'
}

2. 시큐리티 세부 구성 설정

@Configuration
@EnableWebSecurity
public class 클래스 이름 {
    @Bean
    // 클래스 세부 사항
}

시큐리티 구성에 주로 등록하는 빈 유형

유형	설명
UserDetailsService	사용자 정보를 가져오는 역할
PasswordEncoder	비밀번호를 암호화하는 역할
SecurityFilterChain	실제 보안 필터 체인을 구성하는 데 사용하며 여러 보안 필터가 어떤 순서로 실행될지 결정하고 보안과 관련한 요청 처리 담당
WebSecurityCustomizer	보안 구성을 조정하고 보안 설정을 사용자 정의하는 데 사용

2.1 접근 권한 설정

httpSecurity는 시큐리티 설정에 필요한 모든 기능을 제공하는 클래스

메서드	설명
authorizeHttpRequests()	HTTP 요청 인가를 설정
requestMatchers()	특정 리소스(경로, URL 패턴)에 대한 인가를 설정
anyRequest()	모든 리소스에 대한 인가를 설정
authenticated()	인증된 사용자의 접근을 허용
fullyAuthenticated()	인증된 사용자의 접근은 허용, rememberMe 인증은 제외
permitAll()	인증 없이 모든 사용자의 접근을 허용
denyAll()	무조건 접근을 허용하지 않음
anonymous()	익명 사용자의 접근을 허용
rememberMe()	기억하기를 통해 인증된 사용자의 접근을 허용
access(String)	지정된 SpEL 표현식에 적합하면 접근을 허용
hasRole(String role)	지정된 역할을 가진 사용자의 접근을 허용
hasAnyRole(String ... roles)	지정된 역할 중 어떤 것이라도 가진 사용자의 접근을 허용
hasAuthority(String authority)	지정된 권한을 가진 사용자의 접근을 허용
hasAnyAuthority(String ... authorities)	지정된 권한 중 어떤 것이라도 가진 사용자의 접근을 허용
hasIpAddress(String)	지정된 IP로부터 요청이 있으면 접근을 허용

@Configuration
@EnableWebSecurity
public class SecurityConfiguration {

    @Bean
    SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

        http.authorizeHttpRequests(
            authorizeHttpRequests -> authorizeHttpRequests
                .requestMatchers("/admin/**").hasAuthority("ROLE_ADMIN")   // 1
                .requestMatchers("/manager/**").hasRole("MANAGER")         // 2
                .requestMatchers("/member/**").authenticated()             // 3
                .anyRequest().permitAll()                                  // 4
        );

        return http.build();
    }
}

웹 요청 URL이 http://.../admin 또는 http://.../admin/main이면 ROLE_ADMIN 권한이 있는 사용자만 접근이 가능합니다.
웹 요청 URL이 http://.../manager/ 또는 http://.../manager/main이면 MANAGER 권한이 있는 사용자만 접근이 가능합니다.
웹 요청 URL이 http://.../member 또는 http://.../member/main이면 인증된 사용자만 접근이 가능합니다.
그 외 요청은 모두 접근 허용(permitAll)입니다.

2.2 사용자 정보 설정

사용자 정보를 저장하기 위해 UserDetails 인터페이스를 사용합니다.

@Configuration
@EnableWebSecurity
public class SecurityConfiguration {

    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails admin = User.builder()
                .username("admin")      // 사용자 이름(계정)
                .password("admin123")   // 사용자 비밀번호
                .roles("ADMIN")         // 사용자 권한
                .build();

        return new InMemoryUserDetailsManager(admin);
    }
}

2.3 사용자 비밀번호의 암호화 설정

사용자 정보 설정에서 사용자 비밀번호를 안전하게 저장할 수 있도록 비밀번호의 단방향 암호화를 지원하는 PasswordEncoder 인터페이스를 빈으로 등록합니다.

@Configuration
@EnableWebSecurity
public class SecurityConfiguration {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(); // BCrypt 해시 암호화 방식
    }

    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails admin = User.builder()
                .username("admin")
                .password(passwordEncoder().encode("admin123"))
                .roles("ADMIN")
                .build();
        return new InMemoryUserDetailsManager(admin);
    }
}

package com.springboot.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public UserDetailsService users() {
        UserDetails user = User.builder()
                .username("guest")
                .password(passwordEncoder().encode("g1234"))
                .roles("USER")
                .build();

        UserDetails manager = User.builder()
                .username("manager")
                .password(passwordEncoder().encode("m1234"))
                .roles("MANAGER")
                .build();

        UserDetails admin = User.builder()
                .username("admin")
                .password(passwordEncoder().encode("a1234"))
                .roles("ADMIN")
                .build();

        return new InMemoryUserDetailsManager(user, manager, admin);
    }

    @Bean
    SecurityFilterChain examMethod01(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/member/**").hasAnyRole("USER", "ADMIN")
                .requestMatchers("/manager/**").hasRole("MANAGER")
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().permitAll()
        )
        .formLogin(); // 기본 로그인 폼 사용

        return http.build();
    }
}

3. 사용자 정보 검색

3.1 컨트롤러에서 사용자 정보 검색

사용자 정보 검색 방법

유형	설명
Principal	getName() 메서드로 사용자 정보 가져오기
Authentication	getName() 메서드로 사용자 정보 가져오기
@AuthenticationPrincipal	UserDetails를 구현한 클래스와 UserDetailsService를 사용할 때 사용자 정보 가져오기

// Principal 인터페이스 사용 예

import java.security.Principal;

@GetMapping("/manager/user")
public String principalMethod(Principal principal, ...) {
    String username = principal.getName(); // 사용자 이름(계정) 가져오기
    ...
}

// Authentication 인터페이스 사용 예 1

import org.springframework.security.core.Authentication;

@GetMapping("/manager/user")
public String authenticationMethod1(Authentication authentication, ...) {
    String username = authentication.getName(); // 사용자 이름(계정) 가져오기
    ...
}

// Authentication 인터페이스 사용 예 2

import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.UserDetails;

@GetMapping("/manager/user")
public String authenticationMethod2(Authentication authentication, ...) {
    UserDetails userDetails = (UserDetails) authentication.getPrincipal();
    String username = userDetails.getUsername();   // 사용자 이름(계정)
    String password = userDetails.getPassword();   // 사용자 비밀번호
    String authority = userDetails.getAuthorities().toString(); // 사용자 권한
    ...
}

// @AuthenticationPrincipal 사용 예

import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.core.userdetails.UserDetails;

@GetMapping("/manager/user4")
public String annotationMethod(@AuthenticationPrincipal UserDetails userDetails, ...) {
    String username = userDetails.getUsername();   // 사용자 이름(계정)
    String password = userDetails.getPassword();   // 사용자 비밀번호
    String authority = userDetails.getAuthorities().toString(); // 사용자 권한
    ...
}

3.2 뷰 페이지에서 사용자 정보 검색

dependencies {
    implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity6'
}

사용자 역할 권한 태그: <sec:authorize>

<!-- 인가 메서드 -->
<HTML 태그 sec:authorize="인가메서드()" />



<!-- 사용자가 설정된 권한일 때 -->
<div sec:authorize="hasRole('ROLE_ADMIN')"></div>

<!-- 사용자가 설정된 권한을 가지고 있지 않을 때 -->
<div sec:authorize="!hasRole('ROLE_ADMIN')"></div>

<!-- 사용자가 둘 중 하나의 권한을 가질 때 -->
<div sec:authorize="hasAnyRole('ROLE_ADMIN','ROLE_MANAGER')"></div>

<!-- 사용자가 로그인 할 때 -->
<div sec:authorize="isAuthenticated()"></div>

<!-- 사용자가 로그인하지 않을 때 -->
<div sec:authorize="isAnonymous()"></div>

사용자 인증 태그: <sec:authentication>

<span sec:authentication="name"/>           <!-- 사용자 이름 -->
<span sec:authentication="authorities"/>    <!-- 사용자 권한 -->
<span sec:authentication="authenticated"/>  <!-- 인증여부 -->

package com.springboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class Example04Controller {

    @GetMapping("/exam04")
    public String requestMethod(Model model) {
        return "viewPage04";
    }

    @GetMapping("/admin/tag")
    public String requestMethod2(Model model) {
        return "viewPage04";
    }
}

<html xmlns:sec="http://www.thymeleaf.org/extras/spring-security">
<head>
<title>Chap10</title>
</head>
<body>
<h3>스프링 시큐리티</h3>

<div sec:authorize="hasRole('ROLE_ADMIN')">
    <b>관리자 권한 화면입니다.</b>
</div>

<div sec:authorize="isAuthenticated()">
    로그인 중입니다.
    <p>사용자 이름: <span sec:authentication="name"/></p>
    <p>사용자 권한: <span sec:authentication="authorities"/></p>
    <p>사용자 인증여부: <span sec:authentication="authenticated"/></p>
    <a href="/exam04">웹 요청 URL /exam04로 이동하기</a>
</div>

<div sec:authorize="isAnonymous()">
    로그인 중이 아닙니다.
    <a href="/admin/tag">웹 요청 URL /admin/tag로 이동하기</a>
</div>
</body>
</html>

4. 로그인과 로그아웃 처리

4.1 로그인 처리

스프링 시큐리티는 폼 페이지에서 사용자 이름과 비밀번호를 가져올 때 HTTP 기본 인증 방식과 폼 기반 인증 방식을 지원.

기본 인증 방식

@Configuration
@EnableWebSecurity
public class SecurityConfiguration {

    @Bean
    public SecurityFilterChain examMethod(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(authorize -> authorize
                .anyRequest().authenticated())
            .httpBasic(Customizer.withDefaults());
        return http.build();
    }
}

사용자의 username:password 를 Base64 인코딩해 Authorization 헤더에 담아 전송하는 인증 방식입니다.

폼 기반 인증 방식

@Configuration
@EnableWebSecurity
public class SecurityConfiguration {

    @Bean
    public SecurityFilterChain examMethod(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(authorize -> authorize
                .anyRequest().authenticated())
            .formLogin(Customizer.withDefaults()); // 로그인 성공 및 실패 처리
        return http.build();
    }
}

메서드	설명
loginPage()	기본 로그인 페이지 대신 커스텀 페이지 경로 설정
loginProcessingUrl()	인증 처리 URL 설정 (form action 속성과 동일)
defaultSuccessUrl()	로그인 성공 시 이동할 기본 경로 설정
successHandler()	로그인 성공 후 추가 처리가 필요할 때 커스텀 핸들러 등록
failureUrl()	로그인 실패 시 이동할 경로 설정 (/login?error)
failureHandler()	로그인 실패 시 커스텀 실패 핸들러 등록
usernameParameter()	로그인 폼에서 사용자 이름 파라미터 설정
passwordParameter()	로그인 폼에서 비밀번호 파라미터 설정

@Bean
public SecurityFilterChain examMethod02(HttpSecurity http) throws Exception {
    http.authorizeHttpRequests(authorize -> authorize
            .anyRequest().authenticated())
        .formLogin(form -> form
            .loginPage("/login")               // ① 커스텀 로그인 페이지
            .loginProcessingUrl("/login")      // ② 인증 처리 요청 경로
            .defaultSuccessUrl("/admin")       // ③ 성공 시 이동 페이지
            .usernameParameter("username")     // ④ 사용자 이름 파라미터
            .passwordParameter("password")     // ⑤ 비밀번호 파라미터
            .failureUrl("/loginfailed")        // ⑥ 실패 시 이동 페이지
        );
    return http.build();
}

4.2 로그아웃 처리

메서드	설명
deleteCookies()	로그아웃 시 쿠키 삭제
invalidateHttpSession()	세션 무효화 여부 설정
logoutUrl()	로그아웃 요청 URL 설정
logoutSuccessUrl()	로그아웃 성공 시 이동할 경로
logoutSuccessHandler()	로그아웃 후 추가 작업 처리용 커스텀 핸들러 등록

@Bean
public SecurityFilterChain examMethod03(HttpSecurity http) throws Exception {
    http.logout(logout -> logout
            .logoutUrl("/logout")             // 로그아웃 처리 요청 URL
            .logoutSuccessUrl("/login"));     // 성공 후 이동할 페이지
    return http.build();
}

5. [도서 쇼핑몰 도서 등록 페이지의 보안 처리하기]

1. 접근 권한 설정하기

2. 로그인 페이지와 로그인 처리 구현하기

3. 로그아웃 처리 구현하기

출처 : 송미영, 『 스프링부트 완전정복: 개념부터 실정 프로젝트까지 』길벗캠퍼스 (2024).

[스프링부트 완전정복] 9. 유효성 검사

Tiny Commit — Fri, 21 Nov 2025 15:25:35 +0900

1. 유효성 검사의 개요

폼데이터를 전달할때 유효하지 않은 값이 전송 될 수 있다. 이를 방지하기 위해
유효성 검사는 폼 페이지의 입력 값이 서버로 전송되기전 정해진 규칙에 따라 입력되어 있는지, 값이 타장한지 검사합니다.

1. 유효성 검사를 위한 설정

@Valid
의존 라이브러리 등록

implementation 'org.springframework.boot:spring-boot-starter-validation'

2. 유효성 검사의 유형

Bean Validation: 특정 도메인 클래스의 멤버 변수 → 제약사항 애너테이션
ConstraintValidation: 멤버 변수에 사용자 정의 애너테이션을 정의 → 유효성 검사 수행, 클래스 제약 조건 부여
Validator: 스프링부트에서 제공하는 Validator 인터페이스 → 애플리케이션의 모든 계층에서 유효성 검사
유효성 검사 폼데이터
- 입력 데이터가 null인가
- 형식에 맞는가 (날짜, 이메일)
- 나이를 숫자로 입력했는가
- 입력 길이를 초과하는가
- 로그인 인증 시 아이디와 패스워드가 유효한가
- 회원가입 시 아이디가 중복되는가

2. Bean Validation을 이용한 유효성 검사

제약사항 애너테이션 선언으로 필드에 대한 유효성 검사
@제약 사항 애너테이션 -> @Valid -> 뷰 페이지 오류 메시지 출력

1. 제약사항 애너테이션

public class 클래스 이름 {
    @제약사항 애너페이션( 속성, [, message = "오류 메시지 [오류 코드]"])
    private String 멤버 변수;

}

2. Bean Validation 제약 조건 어노테이션 유형

유형	설명	주요 속성
@AssertFalse	프로퍼티 값이 거짓(false) 인지 검사	-
@AssertTrue	프로퍼티 값이 참(true) 인지 검사	-
@DecimalMax	프로퍼티 값이 가질 수 있는 최대 실수 값 검사	value (값), inclusive (포함 여부)
@DecimalMin	프로퍼티 값이 가질 수 있는 최소 실수 값 검사	value (값), inclusive (포함 여부)
@Digits	프로퍼티 값이 가진 소수점 위치를 포함하는 정수 및 소수점 자리수 검사	integer (정수 자리수), fraction (소수 자리수)
@Email	이메일 형식인지 검사	-
@Future	프로퍼티 값이 미래 날짜/시간인지 검사	-
@FutureOrPresent	프로퍼티 값이 현재 또는 미래 날짜/시간인지 검사	-
@Max	프로퍼티 값이 가질 수 있는 최대 정수 값 검사	value (최대 값)
@Min	프로퍼티 값이 가질 수 있는 최소 정수 값 검사	value (최소 값)
@Negative	프로퍼티 값이 음수인지 검사	-
@NegativeOrZero	프로퍼티 값이 음수 또는 0인지 검사	-
@NotBlank	프로퍼티 값이 null이 아니고 공백이 아닌 문자를 포함하는지 검사	-
@NotEmpty	프로퍼티 값(문자열, 컬렉션 등)이 비어있지 않은지 검사	-
@NotNull	프로퍼티 값이 null이 아닌지 검사	-
@Null	프로퍼티 값이 Null인지 검사	-
@Past	프로퍼티 값이 과거 날짜/시간인지 검사	-
@PastOrPresent	프로퍼티 값이 과거 또는 현재 날짜/시간인지 검사	-
@Pattern	프로퍼티 값이 정의된 정규 표현식에 일치하는지 검사	regexp (정규 표현식)
@Positive	프로퍼티 값이 양수인지 검사 (0 제외)	-
@PositiveOrZero	프로퍼티 값이 양수 또는 0인지 검사	-
@Size	프로퍼티 값이 가질 수 있는 최대/최소 크기 검사 (문자열 길이, 컬렉션 크기 등)	min (최소 값), max (최대 값)

3. 제약사항 어노테이션의 기본 메시지

제약사항을 위반하면 hibernate-validator-xxx.jar에서 제공하는 메시지 출력
어노테이션들이 message 속성을 지정하지 않았을 때 기본으로 출력하는 오류 메시지를 보여줍니다.

유형	기본 메시지
@AssertFalse	false여야 합니다.
@AssertTrue	true여야 합니다.
@DecimalMax	다음 값 이하여야 합니다({value}).
@DecimalMin	다음 값 이상이어야 합니다({value}).
@Digits	숫자 값이 한계를 초과합니다({fraction}자리)
@Email	올바른 형식의 이메일 주소여야 합니다.
@Future	미래 날짜여야 합니다.
@FutureOrPresent	현재 또는 미래 날짜여야 합니다.
@Max	${value} 이하여야 합니다.
@Min	${value} 이상이어야 합니다.
@Negative	0 미만이어야 합니다.
@NegativeOrZero	0 이하이어야 합니다.
@NotBlank	공백일 수 없습니다.
@NotEmpty	비어 있을 수 없습니다.
@NotNull	null이어서는 안됩니다.
@Null	null이어야 합니다.
@Past	과거 날짜여야 합니다.
@PastOrPresent	과거 또는 현재 날짜여야 합니다.
@Pattern	${regexp}와 일치해야 합니다.
@Positive	0보다 커야 합니다.
@PositiveOrZero	0 이상이어야 합니다.
@Size	크기가 ${min}에서 ${max} 사이여야 합니다.

public class 클래스 이름 {
    @NotEmpty
    @Size(min=4, max=10)
	@Min(value=0)
}

    @PostMapping
    public String submitForm( @Valid @ModelAttribute("product") Product product, // @Valid로 검사 실행
            BindingResult bindingResult) {                     // 검사 결과를 받음

        if(bindingResult.hasErrors()) {
            // 유효성 검사 실패 시, 다시 폼 페이지를 호출 (에러 메시지는 Thymeleaf가 처리)
            return "viewPage01";
        }
        
        // 유효성 검사 성공 시, 결과 페이지 호출
        return "viewPage01_result"; 
    }
}

< !--viewPage01.html-->
<body>
	<h3>유효성 검사</h3>
	
	<form th:object="${product}" action="/exam01"  method="post">
		<p>품명 : <input type="text"   th:field="*{name}"> <span th:errors="*{name}"></span>
		<p>가격 : <input type="text"   th:field="*{price}"> <span th:errors="*{price}"></span>
		<p><input type="submit" value="확인"/> 
		<input type="reset"  value="취소"/>
	</form>
</body>


//viewPage_result01.html
<body>
	<h3>유효성 검사</h3>
	<p>품명 :  [[${product.name}]]
		<p>가격 :  [[${product.price}]]
		
</body>

< !--viewPage01_result.html-->
<body>
	<h3>유효성 검사</h3>
	<p>품명 :  [[${product.name}]]
	<p>가격 :  [[${product.price}]]
		
</body>

4. 제약사항 애너테이션에 사용자 정의 오류 메시지 사용하기

메시지 속성 값에 출력할 오류 메시지를 직접 정의한다.
- 오류코드 = 출력할 오류 메시지

# 제약사항 어노테이션.필드이름 = 출력할 오류 메시지 형식 사용
NotEmpty.product.name = 값을 입력해 주세요
Min.product.price = 0 이상의 값을 입력해 주세요


# 메시지 리소스 파일의 기본 이름 설정 (경로는 src/main/resources가 기본)
spring.messages.basename = messages
# 메시지 리소스 파일의 인코딩을 UTF-8로 설정 (한글 깨짐 방지)
spring.messages.encoding = UTF-8

// Product.java (메시지 리소스 파일 사용 시)
public class Product {
    
    // message를 생략하면 Spring이 messages.properties에서 키를 찾아 출력
    @NotEmpty 
    @Size(min=4, max=10, message="4자~10자 이내로 입력해 주세요") 
    private String name;

    @Min(value=0) // messages.properties의 Min.product.price 키와 매핑됨
    private int price;
}

-> 도매인 클래스의 프로퍼티 값에 대한 중복 여부를 체크할 수 없다.

( 독립적인 라이브러리이기 때문에, 기본적으로 DB나 외부 시스템에 접근하는 로직을 포함하고 있지 않습니다: 아이디 중복 검사 x)

3. ConstraintValidator 인터페이스를 이용한 유효성 검사

1. 사용자 정의 애너체이션 생성

사용자 정의 애너테이션을 이용해 유효성 검사
사용자 정의 애너테이션 선언, 유효성 검사, 오류 메시지

@Target({ElementType.FIELD}) // 1. 애너테이션을 적용할 위치 (필드)
@Retention(RetentionPolicy.RUNTIME) // 2. 런타임까지 유지
@Constraint(validatedBy = {CustomValidator.class}) // 3. 검증 로직을 구현할 클래스 지정
public @interface CustomConstraint {

    // 4. 필수 요소: 오류 메시지 설정
    String message() default "기본 사용자 정의 오류 메시지입니다.";

    // 5. 필수 요소: 유효성 검사 그룹 지정 (기본값)
    Class<?>[] groups() default {};

    // 6. 필수 요소: 페이로드 지정 (기본값)
    Class<? extends Payload>[] payload() default {};
    
    // 7. (선택적) 사용자 정의 속성 추가
    int minLength() default 5;
}

@Constraint : 제약사항을 생성하는 애너테이션
@Retention : 지속 시간 결정
@Target : 적용 위치 결정

2. 구현체 생성

ConstraintValidator 구현체 -> 유효성 검사 클래스
initialize() -> 사용자 정의 애너테이션 정보 초기화
isValid() -> 유효성 검사 로직 수행

// domain

// ConstraintValidator<애너테이션, 검사 대상 타입>
public class CustomValidator implements ConstraintValidator<CustomConstraint, String> {
    
    private int requiredMinLength;

    // 1. 초기화 메서드
    @Override
    public void initialize(CustomConstraint constraintAnnotation) {
        // 정의한 애너테이션의 속성값(여기선 minLength)을 가져와 초기화합니다.
        this.requiredMinLength = constraintAnnotation.minLength();
    }

    // 2. 검증 로직 메서드
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        // null 값은 @NotNull로 처리하는 것이 일반적이므로 여기서는 true 반환
        if (value == null) {
            return true;
        }
        
        // 실제 유효성 검사 로직
        // 입력된 문자열의 길이가 애너테이션에서 설정한 minLength보다 크거나 같으면 true 반환
        return value.length() >= requiredMinLength;
    }
}

public class UserDto {
    
    // @CustomConstraint를 사용
    @CustomConstraint(minLength = 8, message = "아이디는 최소 8자 이상이어야 합니다.")
    private String userId;

}

4. Validator 인터페이스를 이용한 유효성 검사

Valudator인터페이스 구현체생성 -> @InitBinder메서드 추가 -> @Valid를 이용한 유효성 검사 -> 뷰페이지 오류 메시지 출력

1. 구현체 생성

Validator의 인터페이스 메서드
- supports(Class<?> clazz): 지원 여부 확인:
  - 객체를 유효성 검사할 수 있는지 여부를 반환합니다.
  - (Product.class.isAssignableFrom(clazz) 등)
- validate(Object target, Errors errors): 실제 검증 로직: 유효성 검사를 수행.
  - target은 검사 대상 객체(DTO/Entity)이며,
  - errors는 검사 실패 시 오류 정보(에러 코드, 메시지 등)를 담는 객체입니다.
ValidationUtils의 메서드
- rejectIfEmpty(Errors errors, String field, String errorCode):
  - 빈 값 검사:
  - 지정된 field의 값이 null이거나 빈 문자열 ("")인 경우, errors 객체에 errorCode로 오류를 등록합니다.
- rejectIfEmptyOrWhitespace(Errors errors, String field, String errorCode): 빈 값/공백 검사지정된 field의 값이 null, 빈 문자열, 또는 공백 문자(" ")로만 구성되어 있는 경우, errors 객체에 errorCode로 오류를 등록합니다. (가장 흔하게 사용)
- invokeValidator(Validator validator, Object target, Errors errors):
  - 검증기 호출:
  - 다른 Validator 인스턴스를 호출하여 특정 객체에 대한 유효성 검사를 위임하는 데 사용됩니다.

import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
import com.springboot.domain.Product;

public class ProductValidator implements Validator {

    // 1-1. supports(): 이 검증기가 어떤 클래스를 지원하는지 정의
    @Override
    public boolean supports(Class<?> clazz) {
        // Product 클래스 타입인지 확인
        return Product.class.isAssignableFrom(clazz);
    }

    // 1-2. validate(): 실제 유효성 검사 로직 구현
    @Override
    public void validate(Object target, Errors errors) {
        Product product = (Product) target;

        // **(1) ValidationUtils를 이용한 빈 값(NotBlank) 검사**
        // "name" 필드가 비어있으면 "notBlank" 에러 코드를 Errors 객체에 추가
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "notBlank");

        // **(2) 직접 코드를 이용한 특정 조건(Min/Max) 검사**
        if (product.getPrice() < 0 || product.getPrice() > 100000) {
            // "price" 필드가 조건에 맞지 않으면 "priceRange" 에러 코드를 Errors 객체에 추가
            errors.rejectValue("price", "priceRange");
        }
    }
}

2. @initBinder를 선언한 메서드 추가

@initBinder가 선언된 메서드에 Validator을 미리 등록하면 해당 컨트롤러의 모든 메서드에서 유효성 검사를 할 수 있음.

import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.stereotype.Controller;
// ... (다른 import 생략)

@Controller
// @RequestMapping("/exam01")
public class Example01Controller {
    
    // 2. @InitBinder 메서드: 요청 처리 전에 실행되며 검증기를 WebDataBinder에 등록
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        // ProductValidator의 인스턴스를 생성하여 WebDataBinder에 추가
        binder.addValidators(new ProductValidator());
    }

    // ... (GetMapping, PostMapping 메서드)
}

5. [도서 쇼핑몰] 도서 등록 데이터의 유효성 검사하기

1. Bean Validation으로 유효성 검사하기

의존 라이브러리 등록
메시지 리소스 파일 작성 (message.properties)
도서 클래스에 제약사항 애너테이션 설정 (Book.java)
도서 등록 데이터의 우효성 검사 실행 (BookController)
도서 등록 페이지 수정 (addBook.html)

2. ConstraintValidator 인터페이스 유효성 검사하기

메시지 리소스 파일 작성
도서 클래스에 자용사 정의 애너테이션 설정 (Book.java)
사용자 정의 애너페이션 생성 (BookId.java)
도서 아디이의 유효성 검사 클래스 생성 (VookVAlidator.java)

3. Validator 인터헤이스로 유효성 검사하기

메시지 리소스 파일 설정
제약사항의 유효성 검사 클래스 생성 (UnitslnStockValidator.java)
도서 재고수의 유효성 검사 실행 (BookController.java)
도서 등록 페이지 수정 (addBook.html)

4. 제약사항 애너테이션과 VAlidator 인터페이스를 연동한 유효성 검사하기

유효성 검사클래스 생성 (BookValidator.java)
오류 메시지 가져오기 (Book.java)
유효성 검사 실행 (BookController.java)
유효성 검사 연동 (ValidationConfig.java)

연습문제

출처 : 송미영, 『 스프링부트 완전정복: 개념부터 실정 프로젝트까지 』길벗캠퍼스 (2024).

[스프링부트 완전정복] 8. 다국어 처리

Tiny Commit — Sat, 15 Nov 2025 13:04:53 +0900

1. 다국어 처리의 개요

다양한 언어로 작성된 메시지를 웨 브라우저에 따라 각언어에 대당하는 메시지로 표현할 수 있다.

2. MessageSource를 이용한 다국어 처리

1. 메지시 리소스 파일 작성

언어 대한 메시지 리소스 파일(.properties)을 생성하고 출력 메시지를 작성합니다.
- key=value 쌍으로 messages.properties

// 파일이름_ko.properties
Persom.form.Enter.message = 당신의 정보를 입력하세요.

2. 기본 환경 설정

Spring Boot는 MessageSource라는 인터페이스를 제공하며, 이를 통해 messages.properties와 같은 메시지 리소스 파일에서 언어별 메시지를 가져와 출력합니다.
웹 브라우저의 언어 설정(Locale)에 따라 다양한 언어의 메시지를 출력하는 것입니다.
- 한국어 환경: messages_ko.properties (예: Person.form.Enter.message = 당신의 정보를 입력하세요.)
- 영어 환경: messages_en.properties (예: Person.form.Enter.message = Input your information)
- 기본/기타 환경: messages.properties (기본값)
별도의 빈(Bean) 등록 없이도 Spring Boot가 자동으로 ResourceBundleMessageSource를 등록하여 resources 폴더 아래의 messages.properties 파일을 읽어옵니다.

3. 사용자 정의 환경 설정

Spring Boot가 기본으로 설정하는 MessageSource의 속성(파일명, 인코딩 등)을 변경하고 싶을 때 사용합니다.
설정 파일: application.properties 또는 application.yml 파일에 설정합니다.

// application.yml

spring:
  messages:
    # 1. 메시지 리소스 파일의 기본 이름 및 위치 설정
    # resources 폴더 하위 messages/i18n.properties 파일 등을 찾습니다.
    basename: messages/i18n 
    
    # 2. 메시지 리소스 파일의 인코딩을 UTF-8로 지정
    encoding: UTF-8 
    
    # 3. 메시지를 못 찾았을 때 시스템 로케일(Locale)을 사용할지 여부 (사용 안 함)
    fallbackToSystemLocale: false 
    
    # 4. MessageFormat 규칙을 항상 적용할지 여부 (적용)
    alwaysUseMessageFormat: true

// application.properties
spring.messages.basename=messages/i18n
spring.messages.encoding=UTF-8
spring.messages.fallbackToSystemLocale=false
spring.messages.alwaysUseMessageFormat=true

3. LocaleRecolver와 LocaleChangeInterceptor를 이용한 다국어 변경

1. 로케일 설정

정의: 사용자의 언어와 지역(국가) 정보를 통합하여 나타내는 개념입니다. (예: ko_KR = 한국어, 대한민국)
목적: MessageSource가 이 정보를 바탕으로 messages_ko.properties, messages_en.properties 등 적절한 리소스 파일을 선택하게 합니다.
로케일 결정 유형: LocaleResolver
- AcceptHeaderLocaleResolver: HTTP 요청 헤더의 Accept-Language 값(웹 브라우저 설정)을 이용하여 로케일을 결정합니다. 브라우저 설정에 맞는 언어를 자동으로 제공할 때
- CookieLocaleResolver: 로케일 정보를 쿠키(Cookie)에 저장하여 사용자가 나중에 다시 접속해도 이전에 선택한 언어를 유지하게 합니다. 사용자 선택 언어를 장기간 보존할 때
- SessionLocaleResolver: 로케일 정보를 사용자 세션(Session)에 저장하여 사용자가 웹을 사용하는 동안 언어를 유지하게 합니다. 예시 코드에서 사용된 유형이며, 세션이 만료되면 정보가 사라집니다.
- FixedLocaleResolver: 로케일을 특정 언어로 고정합니다. (예: 무조건 영어)특정 지역/언어만 지원하는 서비스나 테스트용

@Configuration
public class MessageConfig implements WebMvcConfigurer {

    @Bean
    public LocaleResolver localeResolver() {
        SessionLocaleResolver resolver = new SessionLocaleResolver();
        // 애플리케이션의 기본 로케일을 영어(Locale.ENGLISH)로 설정
        resolver.setDefaultLocale(Locale.ENGLISH); 
        return resolver;
    }
    
}

2. 로케일 변경

사용자가 URL 파라미터를 통해 로케일을 동적으로 변경할 수 있도록 하는 설정입니다.
- 웹 요청의 파라미터에 로케일 값을 전달하여 손쉽게 로케일을 바꿀 수 있다.
- http://localhost:8080/exam04?language=ko로 요청하면 로케일이 한국어로 변경됩니다.
- http://localhost:8080/exam04?language=en로 요청하면 로케일이 영어로 변경됩니다.


    @Bean
    public LocaleChangeInterceptor localeChangeInterceptor() {
        LocaleChangeInterceptor interceptor = new LocaleChangeInterceptor();
        // 로케일을 변경할 때 사용할 URL 파라미터 이름을 "language"로 지정
        interceptor.setParamName("language");
        return interceptor;
    }

<a href="?language=ko">Korean</a>|<a href="?language=en">English</a>

4. [도서 쇼핑몰] 도서 등록 페이지의 다국어 처리하기

1. 다국어 처리하기

MessageSource의 사용자 환경 설정 (application.properties)
메시지 리소스 파일 작성 (message_ko.properties)
도서 등록 페이지의 메시지 출력 (addBook.html)

2. 다국어 변경을 위한 빈 객체 등록

다국어 변경을 위한 빈 객체 등록 (MeddageConfig)
도서 등록 페이지에 요청 파라미터 추가 (addBook.html)

연습문제

출처 : 송미영, 『 스프링부트 완전정복: 개념부터 실정 프로젝트까지 』길벗캠퍼스 (2024).

[REACT] 반응형 웹 구현하기 (react-responsive)

Tiny Commit — Thu, 13 Nov 2025 21:21:44 +0900

1. 반응형 웹이란?

PC, 태블릿, 모바일 등 다양한 화면 크기에서 보기 좋게 보이도록
다양한 디바이스로 접근이 가능
사용자 편의성이 높은 UI

2. REACT 시작

1. 패키지 설치

npm install react-responsive # npm
yarn add react-responsive    # yarn

2. 기본 사용법

react-responsive는 Media Query를 컴포넌트로 사용할 수록 도와주는 라이브러리입니다.
모바일 화면에서는 특정 컴포넌트를 숨기고, 데스트답에서 다른 컴포넌트를 보여주고 싶을 때 유용하게 쓰인다.

import React from "react";
import { useMediaQuery } from "react-responsive";

const ResponsiveExample = () => {
  const isDesktop = useMediaQuery({ minWidth: 1024 });
  const isTablet = useMediaQuery({ minWidth: 768, maxWidth: 1023 });
  const isMobile = useMediaQuery({ maxWidth: 767 });

  return (
    <div>
      {isDesktop && <h2> 데스크탑 화면입니다.</h2>}
      {isTablet && <h2> 태블릿 화면입니다.</h2>}
      {isMobile && <h2> 모바일 화면입니다.</h2>}
    </div>
  );
};

export default ResponsiveExample;

3. 컴포넌트 분리하기

import { useMediaQuery } from "react-responsive";

export const Desktop = ({ children }) => {
  const isDesktop = useMediaQuery({ minWidth: 1024 });
  return isDesktop ? children : null;
};

export const Tablet = ({ children }) => {
  const isTablet = useMediaQuery({ minWidth: 768, maxWidth: 1023 });
  return isTablet ? children : null;
};

export const Mobile = ({ children }) => {
  const isMobile = useMediaQuery({ maxWidth: 767 });
  return isMobile ? children : null;
};

import React from "react";
import { Desktop, Tablet, Mobile } from "./Responsive";

const App = () => (
  <>
    <Desktop>데스크탑 전용 페이지</Desktop>
    <Tablet>태블릿 전용 페이지</Tablet>
    <Mobile>모바일 전용 페이지</Mobile>
  </>
);

export default App;

[스프링부트 완전정복] 7. 파일 업로드 처리

Tiny Commit — Mon, 10 Nov 2025 12:13:29 +0900

1. 파일 업로드 개요

파일 업로드: 파일을 웹 브라우저에 서버로 전송하여 저장하는 것
텍스트 파일, 바이너리 파일, 이미지 파일, 문서 파일
웹 페이지에서 폼태그를 사용하고, 파일을 서버로 업로드.

1. 파일 업로드를 위한 설정

별도의 라이브러리 추가 없이 application.properties파일에 설정

spring.servlet.multipart.enabled=true			# 멀티 파트 업로드 지원 여부
spring.servlet.multipart.file-size-threshold=2KB	# 파일이 메모리에 기록되는 임계값
spring.servlet.multipart.location=C:/upload		# 업로드된 파일의 임시 저장 공간
spring.servlet.multipart.max-file-size=200MB		# 파일의 최대 크기
spring.servlet.multipart.max-request-size=215MB		# 요청의 최대 크기

2. 파일 업로드를 위한 웹 페이지

웹페이지 -> 서버로 전송하는 폼페이지
- Method는 POST
- enctype은 multipart/form-data
- action은 실행 파일
- type은 file설정

<form method="post" enctype="multipart/form-data" action="viewPage_process.html">
    <p>제목 : <input type="text" name="title"></p>
    <p>파일 : <input type="file" name="fileName"></p>
    <p><input type="submit" value="submit"></p>
</form>

3. 정적 리소스 위치 설정하기

ResourceHttpRequestHandler 클래스: 파일 시스템 접근
- /static
- /public
- /resources
- /META-INF/resources
ResourceHandlerRegistry : 정적 리소스가 저장된 WAR, 파일 시스템 접근
- WAR: 리소스가 저장됨.

@Configuration
@EnableWebMvc
public class MvcConfig implements WebMvcConfigurer {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry
            .addResourceHandler("/resources/**") //외부 URI
            .addResourceLocations("/resources/"); //실제 리소스 경로
    }
}

2. MultupartFile을 이용한 파일 업로드 처리

1. MultipartFile을 이용한 파일 업로드 처리

업로드된 파일과 파일 데이터를 표현할 때 사용
단일, 다중 업로드 가능

메서드	타입	설명
getName()	String	멀티 파트 폼에서 파라미터 이름을 반환
getContentType()	String	파일의 콘텐츠 형식을 반환
getOriginalFilename()	String	클라이언트의 파일 시스템에서 실제 파일 이름을 반환
isEmpty()	boolean	업로드한 파일의 존재 여부를 반환
getSize()	long	바이트의 파일 크기를 반환
getBytes()	byte[]	바이트의 배열로 파일 내용을 반환
getInputStream()	InputStream	파일 폼의 내용을 읽어 InputStream으로 반환
transferTo(File dest)	void	전송된 파일을 지정한 대상 파일로 전송

2. 파일 업로드 유형

MultipartFileServletRequest 인터페이스 이용하기

우선 HttpServletRequest(getParameter()), MultipartRequest(getFile()) 인터페이스를 상속받아야 한다.
요청 전체를 받아 필요한 파라미터와 파일을 직접 꺼내야 합니다. (request.getParameter(), request.getFile())

@Controller
@RequestMapping("/exam01")
public class Example01Controller {

    @GetMapping("/form")
    public String requestForm() {
        return "viewPage";
    }

    @PostMapping("/form")
    public String submitForm(MultipartHttpServletRequest request, Model model) {
        // 1. 폼 페이지의 요청 파라미터 name의 값을 전송받습니다.
        String name = request.getParameter("name");
        
        // 2. 폼 페이지의 요청 파라미터 fileImage의 파일을 전송받습니다.
        MultipartFile file = request.getFile("fileImage");
        
        String filename = file.getOriginalFilename();
        File saveFile = new File("C:\\upload\\" + name + "_" + filename);

        try {
            // 3. 파일을 업로드합니다.
            file.transferTo(saveFile);
            
            model.addAttribute("data1", "MultipartHttpServletRequest 예제");
            model.addAttribute("data2", filename);
            model.addAttribute("data3", saveFile.getName());
        } catch (IOException e) {
            e.printStackTrace();
        }

        return "viewPage_process";
    }
}

@RequestParam

멀티 파트 요청이 들어오면 @RequestParam과 MultipartFile 타입의 매개변수를 사용해야 한다.
파일을 포함한 각 폼 데이터를 @RequestParam을 이용해 개별적으로 필요한 타입(String, MultipartFile)으로 주입받음.

@Controller
@RequestMapping("/exam02")
public class Example02Controller {

    @GetMapping("/form")
    public String requestForm() {
        return "viewPage";
    }

    @PostMapping("/form")
    public String submitForm(
        @RequestParam("name") String name, 
        @RequestParam("fileImage") MultipartFile file, 
        Model model
    ) {
        String filename = file.getOriginalFilename();
        // C:\\upload\\ 경로와 파일 이름 사이에 "_"가 추가된 것
        File saveFile = new File("C:\\upload\\" + name + "_" + filename); 

        try {
            // 파일 업로드
            file.transferTo(saveFile);
            
            model.addAttribute("data1", "@RequestParam 예제");
            model.addAttribute("data2", filename);
            model.addAttribute("data3", saveFile.getName());
        } catch (IOException e) {
            e.printStackTrace();
        }

        return "viewPage_process";
    }
}

@ModelAttribute

매개변수와 동일한 이름으로 커맨드 객체 내에 MultipartFile타입의 프로퍼티를 추가합니다.
요청 메서드는 @ModelAttribute를 선언하여 업로드할 파일을 포함한 요청 파라미터를 전송받음.
폼 데이터와 파일을 객체(Member 클래스)로 한 번에 묶어 받고 싶을 때 사용합니다.

// 커맨드 객체
package com.springboot.domain;

import org.springframework.web.multipart.MultipartFile;
import lombok.Data; // Lombok Data 어노테이션 사용

@Data // Getter, Setter, toString 등을 자동 생성
public class Member {

    private String name;
    private MultipartFile fileImage;
}

//컨트롤러
...
import com.springboot.domain.Member; // 커맨드 객체 import
import java.io.File;
import java.io.IOException;

@Controller
@RequestMapping("/exam03")
public class Example03Controller {

    @GetMapping("/form")
    public String requestForm(Member member) { // @ModelAttribute가 적용
        return "viewPage";
    }

    @PostMapping("/form")
    public String submitForm(@ModelAttribute Member member, Model model) {
        // 1. 폼 페이지의 요청 파라미터 name의 값을 전송받습니다.
        String name = member.getName();
        
        // 2. 폼 페이지의 요청 파라미터 fileImage의 파일을 전송받습니다.
        MultipartFile file = member.getFileImage();
        
        String filename = file.getOriginalFilename();
        File saveFile = new File("C:\\upload\\" + name + "_" + filename);

        try {
            // 3. 파일을 업로드합니다.
            file.transferTo(saveFile);
            
            model.addAttribute("data1", "@ModelAttribute 예제");
            model.addAttribute("data2", filename);
            model.addAttribute("data3", saveFile.getName());
        } catch (IOException e) {
            e.printStackTrace();
        }

        return "viewPage_process";
    }
}

외부 파일 시스템 접근 설정

package com.springboot.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class ResourceConfig implements WebMvcConfigurer {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry
            // URL 패턴: "/images/**"로 요청이 오면
            .addResourceHandler("/images/**")
            // C 드라이브의 "/upload/" 디렉토리에서 파일을 찾습니다.
            .addResourceLocations("file:///C:/upload/");
    }
}

3. [도서 쇼핑몰 도서 이미지 업로드 처리하기]

1. 정적 리소스로 이미지와 부트스트랩 관리하기

정적 리소스 관리 폴더 생성 (src/main/resource/static)
도서 클래스 멤버 변수 추가 (Book.java)
도서 데이터 저장소 클래스 수정 (BookRepositoryImpl)
도서 목록 페이지 수정 (books.html)
도서 상세 정보 페이지 수정 (book.html)

2. 도서 이미지 업로드하기

도서 이미지 파일의 저장 위치 생성
파일 업로드 저장 위치 설정 (application.properties)
파일 시스템에 저장된 이미지에 접근하는 클래스 생성 (ResourceConfig 클래스 생성)
도서 클래스에 멤버 변수 추가 (Book.java)
도서 이미지 파일 업로드 (BookController)
도서 등록 페이지 수정 (addBook.html)

3. 이미지 파일 다운로드

도서 이미지 파일 다운로드 (BookController)
도서 정보 상세 페이지 수정 (book.html)

연습문제

01.다음 중 파일 업로드를 위한 폼 태그의 규칙으로 옳지 않은 것은?

②

02.다음 중 파일을 업로드하는 방법으로 사용되는 클래스(또는 인터페이스)로 옳은 것은?

①

03.다음 중 컨트롤러에 멀티 파트 요청으로 들어오는 업로드된 파일 데이터를 전달받기 위해 MultipartFile 인터페이스와 함께 사용할 수 있는 애너테이션으로 옳은 것은?

④

04.다음 중 MultipartHttpServletRequest에서 MultipartFile 데이터를 전달받는 메서드로 옳은 것은?

①

05.다음 중 MultipartFile 인터페이스의 메서드에 대한 설명으로 옳지 않은 것은?

④

06.다음 중 1에 지정하는 클래스로 옳은 것은?

①

07.다음 중 2에 지정하는 파일을 업로드하는 메서드로 옳은 것은?

④

08.다음 중 앞의 예제에 따라 application.properties 파일에 업로드할 파일의 저장 경로 설정에 해당하는 구문으로 옳은 것은?

③

09.다음 중 앞의 예제에 따라 application.properties 파일에 업로드할 파일의 최대 크기를 200MB로 설정하는 구문으로 옳은 것은?

①

10.다음 중 앞의 예제에 따라 윈도우 운영체제에서 빈칸에 들어가는 정적 리소스 위치 설정에 해당하는 구문으로 옳은 것은?

③

출처 : 송미영, 『 스프링부트 완전정복: 개념부터 실정 프로젝트까지 』길벗캠퍼스 (2024).

[스프링부트 완전정복] 6. 폼 태그

Tiny Commit — Mon, 3 Nov 2025 18:06:39 +0900

1. 폼 태그 개요

폼태그: 사용가의 입력이나 선택 정보를 웹 서보로 전달하는 폼태그

1. 폼

입력 받은 데이터를 서버로 전송하고 서버는 데이터를 처리하고 결과에 따라 다른 웹 페이지로 보여준다.
사용자와의 상호작용: 사용자가 뭘 원하는지 파악 가능

2. <form> 태그 사용법

form 태그의 속성

속성	설명
action	데이터를 받아 처리하는 웹 페이지의 URL 설정
method	데이터를 전송하는 HTTP 방식 설정
name	폼을 식별하는 이름 설정
target	폼 처리 결과를 응답할 프레임 설정
enctype	폼을 전송하는 콘텐츠 MIME 유형 설정
accept-charset	폼 전송에 사용할 문자 인코딩 설정

입력 태그 양식

<input>

속성	값	설명
type	text	한 줄 텍스트 입력
	radio	라디오 버튼으로 열거된 것 중 하나만 선택
	checkbox	체크 박스로 열거된 것 중 여러 개 선택
	password	암호 입력
	hidden	보이지 않고 숨겨서 전송
	file	파일 업로드를 위한 파일 선택
	button	버튼 모양 출력
	reset	폼에 입력된 값을 모두 초기화
	submit	폼에 입력된 값을 서버에 모두 전송
name	텍스트	입력 양식을 식별하는 이름 설정
value	텍스트	입력 양식의 초깃값 설정

<select>

속성	값	설명
name	텍스트	목록 상자의 이름 설정
size	숫자	한 번에 표시할 항목의 개수 설정
multiple		$\mathbf{\text{[Ctrl]}}$ 키를 눌러 다중 선택 설정

하위 태그 <option>

속성	값	설명
value	텍스트	항목의 값 설정
selected		해당 항목을 초깃값으로 선택
disabled		항목을 비활성화

<textarea>

속성	값	설명
name	텍스트	이름 설정
cols	숫자	입력할 텍스트 영역의 너비 (열 크기) 설정
rows	숫자	입력할 텍스트 영역의 높이 (행 크기) 설정
wrap	off	줄 바꿈을 하지 않음
	soft	$\mathbf{\text{[Enter]}}$를 누르지 않아도 입력 행 끝에서 자동 줄 바꿈
	hard	$\mathbf{\text{soft}}$ 상태와 비슷하며, 서버에 전송할 때 캐리지 리턴 문자를 전달

3. 예시

...

        <label for="userId">아이디:</label>
        <input type="text" id="userId" name="id" value="" size="10" required>
        <br><br>

        <label for="userPw">비밀번호:</label>
        <input type="password" id="userPw" name="pw" value="" size="10" required>
        <br><br>

        <p>성별:
        <input type="radio" name="gender" value="male" checked> 남자
        <input type="radio" name="gender" value="female"> 여자
        <br><br>

        <p>취미:
        <input type="checkbox" name="hobby" value="독서"> 독서
        <input type="checkbox" name="hobby" value="운동"> 운동
        <input type="checkbox" name="hobby" value="영화"> 영화
        <br><br>

        <label for="userLoc">거주 지역:</label>
        <select id="userLoc" name="location">
            <option value="">--지역 선택--</option>
            <option value="seoul">서울</option>
            <option value="gyeonggi" selected>경기</option>
            <option value="busan">부산</option>
        </select>
        <br><br>

        <label for="intro">자기소개:</label><br>
        <textarea id="intro" name="introduction" cols="40" rows="5" wrap="soft"></textarea>
        <br><br>
        
        <input type="hidden" name="joinDate" value="2025-11-03">

        <input type="submit" value="가입 완료">
        
        <input type="reset" value="다시 작성">
...

2. @ModelAttribute를 이용한 데이터 바인딩

웹 요청이 URL를 처리하기 전에 커맨드 객체에 데이터를 담는다.
@ModelAttribute

1. 커맨드 객체와 롬복

커맨드 객체: Setter()매서드를 이용해 도메인 객체에 정의된 프로퍼티로 데이터를 바인딩하는 객체
요청 파라미터 이름 == 폼에서 전송된 파라미터 이름
lombok: Getter, Setter자동 생성 (의존성 주입 필요)

compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'

2. 요청 처리 메서드의 매개변수에 적용

@ModelAttribute: 폼 데이터를 커맨드 객체가 매핑하고 데이터를 프로퍼티에 채우는 역할이다.
컨트롤러 안에 @RequestMapping이 적용된 요청 매서드의 매개변수로 설정해서 사용한다.

...
    // URL: /member로 POST 요청이 올 경우 처리
    @PostMapping("/member")
    public String submitForm(@ModelAttribute Member member, Model model) {
        // @ModelAttribute Member member: 폼에서 전송된 데이터(id, passwd, ...)가 Member 객체의 필드(프로퍼티)에 자동으로 바인딩됩니다.
        // Model model: 뷰 페이지(ViewPage02.html)로 데이터를 전달하기 위한 객체
        // 바인딩된 member 객체를 "member"라는 이름으로 model에 추가
        
        model.addAttribute("member", member); 
...

@ModelAttribute를 사용하지 않는 경우

...
    @PostMapping("/member")
    public String submitForm(Member member, Model model) {
        model.addAttribute("member", member); 
...

커맨드 객체 이름을 변경한 경우

...
    @PostMapping("/member")
    public String submitForm(@ModelAttribute("member") Member mem, Model model) {
        model.addAttribute("member", mem); 
...

3. 메서드에 적용

...
    // 1. 요청 처리 메서드: GET 요청을 처리하고 ViewPage03을 반환
    @GetMapping 
    public String showForm() {
        return "ViewPage03";
    }

    // 2. @ModelAttribute 메서드 (모델 속성 이름: "title")
    // @RequestMapping이 없지만 showForm()보다 먼저 호출되어 Model에 데이터를 추가합니다.
    @ModelAttribute("title") // (1) 모델 속성 이름 명시
    public void setTitle(Model model) {
        // Model에 "title"이라는 이름으로 "ModelAttribute 예제" 값을 추가
        model.addAttribute("title", "ModelAttribute 예제"); 
    }

    // 3. @ModelAttribute 메서드 (모델 속성 이름: "color")
    // 메서드의 반환 값이 그대로 Model 속성에 추가됩니다. (속성 이름은 "color")
    @ModelAttribute("color") // (2) 모델 속성 이름 명시
    public List<String> populateColor() {
        // List 객체를 반환하여 Model에 "color"라는 이름으로 자동 추가
        return Arrays.asList("red", "green", "blue");
    }
}

3. @InitBinder를 이용한 커스턴 데이터 바이딩

폼 페이지에서 전송되는 요청 파라미터의 데이터 바인딩을 사용자가 정의

1. 매서드에 적용

@InitBinder는 컨트롤러에서 사용자가 입력한 데이터가 커맨드 객체의 프로퍼티에 매핑되기 전에 데이터 바인딩을 사용자 정의(커스터마이징)하는 데 사용됩니다.
사용자 첨 페이징서 입력 데이터를 커맨드 객체의 프로퍼티로 전체 또는 일부만 전달 가능

@InitBinder

@InitBinder("커맨드 객체")

2. 폼 파라미터의 커스텀 데이터 마인딩

setAllowedFields(): 허용되는 폼 파라미터를 설정

기본값 none
데이터 바인딩을 허용하지 않는 폼 파라미터 설정으로 바인딩 방지 가능

@InitBinder
public void initBinder(WebDataBinder binder) {
    // 명시적으로 "id", "passwd", "city", "sex", "greetings"만 바인딩을 허용
    // 나머지 폼 파라미터(예: hobby)는 바인딩에서 제외됩니다.
    binder.setAllowedFields("id", "passwd", "city", "sex", "greetings");
}

setDisallowedFields():

@InitBinder
public void initBinder(WebDataBinder binder) {
    // 명시적으로 "hobby" 파라미터만 바인딩을 차단
    // 나머지 모든 폼 파라미터(id, passwd, city, sex, greetings 등)는 바인딩이 허용됩니다.
    binder.setDisallowedFields("hobby");
}

4. [도서 쇼핑몰] 도서 등록 페이지 만들기

1. 폼 태그로 도서 등록 페이지 만들기

도서 등록 페이지를 출력하는 요청 처리 메서드 작성 (BookController)
도서 등록 페이지 작성 (addBook.html)

2. @ModelAttribute로 도서 등록 처리하기

lombok 의존 라이브러리 등록
롬복 애너테이션 선언
신규 도서를 등록하는 메서드 정의 & 작성 (BookRepository)
신규 도서를 등록하는 메서드 정의 & 작성 (BookService)
신규 도서 등록하는 메서드 작성 (BookController)
도서 등록 페이지에 제목을 출력하는 메서드 작성 ( BookController )
도서 등록 페이지 작성 (addBook.html)

3. @InitBinder로 커스텀 테이터 메서드 작성

커스텀 데이터 바인딩 메서드 작성 ( BookController )

연습문제

01. 다음 중 input 태그의 type에 대한 설명으로 옳지 않은 것은?

✅ 정답: ③ password: 양을 입력할 때 사용합니다.

02. 다음 중 스프링 폼 태그(form)의 속성에 대한 설명으로 옳지 않은 것은?

✅ 정답: ② action: 데이터를 받아 처리하는 뷰 페이지의 URL을 설정합니다.

03. 다음 중 롬복(lombok)에 대한 설명으로 옳지 않은 것은?

✅ 정답: ④ 파라미터를 받는 일반 생성자를 생성하는 @RequiredArgsConstructor를 제공합니다.

04. 다음 중 폼 요청 URL을 처리하는 요청 처리 메서드가 호출되기 전에 뷰 페이지에서 입력된 커맨드 객체를 미리 담아 주는 어노테이션으로 옳은 것은?

✅ 정답: ③ @ModelAttribute

05. 다음 중 폼 페이지에서 사용자가 입력한 데이터가 커맨드 객체의 프로퍼티에 매핑되어 데이터 바인딩을 사용자 정의(customizing)할 수 있는 어노테이션으로 옳은 것은?

✅ 정답: ④ @InitBinder

06. 다음 중 사용자 요청에 따라 현재 뷰 페이지에서 다른 뷰 페이지로 이동하는 방식으로 옳지 않은 것은?

✅ 정답: ③ return 방식: /요청 URL

07. 다음 중 사용자 요청에 따라 뷰 페이지를 이동하는 redirect 방식에 대한 설명으로 옳지 않은 것은?

✅ 정답: ④ 웹 브라우저가 최초 요청 URL을 유지하면서 응답된 뷰 페이지를 표현하는 방식입니다.

08. 다음 중 메서드 수준의 @ModelAttribute로 뷰 페이지에서 공통으로 사용할 수 있는 커맨드 객체의 프로퍼티를 설정하여 뷰 페이지에 출력하려는 역할을 하는 메서드로 옳은 것은?
✅ 정답: ① requestMovies01()

09. 다음 중 웹 브라우저의 주소창에 http://localhost:8080/movies/add를 입력하면 매핑하여 실행하는 요청 처리 메서드로 옳은 것은?
✅ 정답: ② requestMovies02()

10. 다음 중 요청 처리 메서드 requestMovies03()을 실행한 후 웹 브라우저에 출력되는 뷰 페이지로 옳은 것은?
✅ 정답: ② addMovie.html

출처 : 송미영, 『 스프링부트 완전정복: 개념부터 실정 프로젝트까지 』길벗캠퍼스 (2024).

#2 트러블 슈팅 [스프링부트 완전정복] 6장 실습2

Tiny Commit — Mon, 3 Nov 2025 16:46:55 +0900

교재를 보면서 실습을 따라하는데, 실습1에서 오류가 발생했다 ㅜㅜㅜ

400 Bad Request 오류의 원인

원인:

BookController.java의 submitAddNewBook 메서드는 바인딩 대상인 @ModelAttribute Book book만 받고, 오류를 처리할 BindingResult 파라미터가 없었습니다.

1. BookController.java 수정 (오류 검사 및 모델 속성 추가)

BookController의 POST 메서드를 수정하여 BindingResult를 추가하고, 오류가 발생했을 때 400 에러 대신 폼 페이지(addBook.html)로 다시 포워딩하도록 했습니다.

@GetMapping("/add")
public String requestAddBookForm(Model model) { 
    Book book = new Book();
    model.addAttribute("newBook", book); // ① 빈 객체 모델 추가 (필수)
    return "addBook"; 
}

@PostMapping("/add")
public String submitAddNewBook(@ModelAttribute("newBook") Book book, BindingResult result) {
    if (result.hasErrors()) { // ② BindingResult로 오류 검사
        return "addBook";     // ③ 오류 시 폼으로 복귀 (400 에러 방지)
    }
    // ... (정상 처리)
    bookService.setNewBook(book);
    return "redirect:/books"; 
}

2. addBook.html 수정 (Thymeleaf 바인딩 적용)

BindingResult가 정상적으로 동작하려면, Thymeleaf에게 어떤 폼 필드가 어떤 객체의 필드에 바인딩되는지 명시적으로 알려주어야 합니다.

요소	수정 내용	이유
<form> 태그	<form ... th:object="${newBook}"> 추가	폼이 Book 객체(newBook)와 연결됨을 선언합니다.
<input> 태그	name을 th:field="*{필드명}"으로 변경	Thymeleaf가 필드 간의 바인딩을 관리하고, 오류 발생 시 오류 메시지를 표시하며, 기존 입력 값을 유지할 수 있게 합니다.