농담곰담곰이의곰담농

블로그 이전

브이담곰 — Mon, 5 Jan 2026 21:01:06 +0900

해당 블로그를 대학시절부터 사용하면서 정도 많이 들었는데,

게임 개발자가 아닌 웹 개발자로 전향하게 되면서 새로운 마음으로 새 블로그에 둥지를 틀으려고 합니다!!

https://velog.io/@ramram/posts

[Spring Boot] Interceptor 프로젝트에 적용해보았다.

브이담곰 — Fri, 13 Jun 2025 17:46:56 +0900

간단한 프로젝트에서, CRUD를 구현하다가 작업을 수행할 때마다 업데이트 된 리스트를 보여주어야 하므로, 전체 List를 불러오는 코드가 메서드들에 중복되서 작성되어있다는 것을 알았다.

수업시간에 배운 Interceptor을 이용해서 코드를 깔끔하게 정리할 수 있다고 생각해서, 활용해보기로 했다.

Spring Interceptor란?

Spring 프레임워크에서 제공하는 기능 중 하나로, 클라이언트의 요청을 가로채서 처리하는 역할을 한다. 이를 통해 공통적인 로직(로깅, 성능 측정, 캐싱)을 처리하거나, 보안(인증, 권한)등의 목적으로 조건을 검사하고 해당 요청을 처리하거나, 무시할 수 있다.

특정 요청 URL에만 적용되도록 매핑할 수 있다는 점이 필터와 유사하지만, 필터와 다르게 Interceptor는 스프링 웹 애플리케이션 컨텍스트에 구성하기 때문에 컨테이너의 기능을 자유롭게 활용할 수 있으며 그 내부에 선언된 모든 빈을 참조할 수 있다.

Interceptor을 사용하기 위해 아래와 같은 과정으로 하였다.

1. WebConfig 클래스 생성

Interceptor를 사용하려면 WebMvcConfigurer 인터페이스를 구현하는 설정 클래스를 만들고 addInterceptors() 메소드를 오버라이드해서 등록해야한다. 중요한 점은 등록 순서에 따라 Interceptor가 실행되는 순서를 결정한다는 것이다.

@Configuration // 빈(bean)정의 클래스
public class WebConfig implements WebMvcConfigurer {

    @Autowired // 스프링 컨테이너에 등록된 빈(Bean) 중에서 해당 타입과 일치하는 객체를 찾아서 자동으로 주입
    CategoryListInterceptor categoryListInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(categoryListInterceptor)
                .addPathPatterns("/category/**")
                .excludePathPatterns(
                        "/images/**",
                        "/js/**",
                        "/error"
                );
    }
}

2. Interceptor 생성

HandlerInterceptor 클래스의 구현체를 생성하고 Component로 빈을 등록한다.

postHandler 메소드를 오버라이드해서 구현을 시작한다.

@Component
public class CategoryListInterceptor implements HandlerInterceptor {

    @Autowired
    CategoryService categoryService; // 의존성 주입

    // 메서드가 실행되기 전에 전체 리스트를 업로드 해야하므로 postHandler을 override 한다.
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

        // 카테고리 관련 뷰로 이동할 때만 가로챈다.
        if(modelAndView != null &&
                modelAndView.getViewName() != null &&
                modelAndView.getViewName().equals("category/list")){

            // Category List 조회
            List<CategoryDTO> categoryList = categoryService.findAllCategory();
            modelAndView.addObject("categoryList", categoryList);
        }

    }
}

REST API에서 페이징 처리가 필수인 이유와 실무 구현 방법

브이담곰 — Thu, 12 Jun 2025 12:07:35 +0900

페이징을 알게 된 계기

오늘 REST API에 대해 배우면서 상품 목록을 조회하는 API를 만들어보았다. 그런데 문득 이런 생각이 들었다.

"만약 쇼핑몰에 상품이 10만 개, 100만 개가 있다면 어떻게 될까?"

모든 상품 정보를 한 번에 클라이언트에 보내준다면...

데이터베이스에서 100만 개 데이터를 모두 조회
서버 메모리에 100만 개 객체 로딩
네트워크로 거대한 JSON 전송
브라우저가 100만 개 데이터 처리

분명히 서버도 클라이언트도 감당할 수 없을 것 같았다. 그래서 페이징 응답에 대해 더 자세히 알아보게 되었다.

페이징이 없다면 생기는 문제들

1. 서버 사이드 문제

// ❌ 이렇게 하면 큰일난다!
@GetMapping("/api/products")
public List<ProductDTO> getAllProducts() {
    return productService.findAll(); // 100만 개 상품을 모두 조회!
}

발생하는 문제들:

메모리 부족: 100만 개 객체가 힙 메모리를 점유
응답 시간 지연: 데이터 조회 + 직렬화 + 네트워크 전송 시간 급증
데이터베이스 부하: 한 번에 모든 데이터를 읽어야 함
서버 비용 증가: 불필요한 리소스 소모

2. 클라이언트 사이드 문제

브라우저 렌더링 지연: 100만 개 DOM 요소 생성?
메모리 사용량 폭증: 모바일에서는 더욱 심각
사용자 경험 저하: 페이지가 멈춘 것처럼 보임
불필요한 데이터: 사용자는 처음 20개 정도만 봄

3. 네트워크 문제

대역폭 낭비: 수 MB~GB 급 응답 크기
모바일 데이터 소모: 사용자 요금 폭탄
응답 시간 증가: 네트워크 전송 시간 기하급수적 증가

✅ 페이징의 해결책

Before: 100만 개 한 번에

Client ← [상품1, 상품2, ..., 상품1000000] ← Server
          100MB 응답, 30초 대기

After: 20개씩 나누어서

Client ← [상품1~20] + 페이징정보 ← Server
        ✨ 50KB 응답, 0.1초 완료

핵심 아이디어: "사용자는 보통 처음 1~2페이지만 본다!"

️ 실무에서 사용하는 페이징 구조

1. 기본적인 페이징 파라미터

GET /api/products?page=0&size=20&sort=createdAt,desc

파라미터 설명 기본값

page	페이지 번호 (0부터 시작)	0
size	페이지 크기	20
sort	정렬 기준	createdAt,desc

2. Spring Data JPA로 구현하기

Repository Layer

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    // JpaRepository가 기본 페이징 기능 제공
    Page<Product> findAll(Pageable pageable);
    
    // 조건부 페이징도 쉽게 구현
    Page<Product> findByCategory(String category, Pageable pageable);
    Page<Product> findByNameContaining(String keyword, Pageable pageable);
}

Service Layer

@Service
public class ProductService {
    
    @Autowired
    private ProductRepository productRepository;
    
    public PageResponse<ProductDTO> getProducts(int page, int size) {
        // Pageable 객체 생성
        Pageable pageable = PageRequest.of(page, size, 
            Sort.by(Sort.Direction.DESC, "createdAt"));
        
        // 페이징 조회
        Page<Product> productPage = productRepository.findAll(pageable);
        
        // DTO 변환
        List<ProductDTO> productDTOs = productPage.getContent()
            .stream()
            .map(this::convertToDTO)
            .collect(Collectors.toList());
        
        // 페이징 응답 생성
        return PageResponse.<ProductDTO>builder()
            .content(productDTOs)
            .totalElements(productPage.getTotalElements())
            .totalPages(productPage.getTotalPages())
            .currentPage(productPage.getNumber())
            .size(productPage.getSize())
            .hasNext(productPage.hasNext())
            .hasPrevious(productPage.hasPrevious())
            .build();
    }
}

Controller Layer

@RestController
@RequestMapping("/api/products")
public class ProductController {
    
    @GetMapping
    public ResponseEntity<ApiResponse<PageResponse<ProductDTO>>> getProducts(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size) {
        
        PageResponse<ProductDTO> pageResponse = productService.getProducts(page, size);
        
        return ResponseEntity.ok(ApiResponse.<PageResponse<ProductDTO>>builder()
            .success(true)
            .message("상품 목록 조회 성공")
            .data(pageResponse)
            .build());
    }
}

3. 커스텀 PageResponse 클래스

@Getter
@Builder
public class PageResponse<T> {
    // 실제 데이터
    private List<T> content;
    
    // 페이징 정보
    private long totalElements;    // 전체 데이터 개수
    private int totalPages;        // 전체 페이지 수
    private int currentPage;       // 현재 페이지 (0부터 시작)
    private int size;             // 페이지 크기
    
    // 편의 정보
    private boolean hasNext;       // 다음 페이지 존재 여부
    private boolean hasPrevious;   // 이전 페이지 존재 여부
    private boolean first;         // 첫 번째 페이지 여부
    private boolean last;          // 마지막 페이지 여부
    
    // 실제 표시되는 데이터 개수
    private int numberOfElements;
}

프론트엔드가 받는 JSON 응답

성공적인 페이징 응답

{
  "success": true,
  "message": "상품 목록 조회 성공",
  "data": {
    "content": [
      {
        "id": 1,
        "name": "맥북 프로 16인치",
        "price": 3500000,
        "category": "노트북",
        "imageUrl": "/images/macbook-pro-16.jpg",
        "createdAt": "2024-06-11T10:30:00"
      },
      {
        "id": 2,
        "name": "아이폰 15 Pro",
        "price": 1500000,
        "category": "스마트폰",
        "imageUrl": "/images/iphone-15-pro.jpg",
        "createdAt": "2024-06-11T09:15:00"
      }
    ],
    "totalElements": 1547,
    "totalPages": 78,
    "currentPage": 0,
    "size": 20,
    "hasNext": true,
    "hasPrevious": false,
    "first": true,
    "last": false,
    "numberOfElements": 20
  }
}

프론트엔드에서 활용하기

async function loadProducts(page = 0) {
    try {
        const response = await fetch(`/api/products?page=${page}&size=20`);
        const result = await response.json();
        
        if (result.success) {
            const { content, totalElements, currentPage, totalPages, hasNext, hasPrevious } = result.data;
            
            // 상품 목록 렌더링
            renderProducts(content);
            
            // 페이지 정보 표시
            document.getElementById('page-info').textContent = 
                `${currentPage + 1} / ${totalPages} 페이지 (총 ${totalElements.toLocaleString()}개 상품)`;
            
            // 페이징 버튼 상태 관리
            document.getElementById('prev-btn').disabled = !hasPrevious;
            document.getElementById('next-btn').disabled = !hasNext;
            
        } else {
            console.error('상품 로딩 실패:', result.message);
        }
        
    } catch (error) {
        console.error('네트워크 에러:', error);
    }
}

// 이전/다음 페이지 이동
let currentPage = 0;

document.getElementById('prev-btn').onclick = () => {
    if (currentPage > 0) {
        currentPage--;
        loadProducts(currentPage);
    }
};

document.getElementById('next-btn').onclick = () => {
    currentPage++;
    loadProducts(currentPage);
};

고급 페이징: 검색과 필터링

실무에서는 단순 페이징보다는 검색 + 필터링 + 페이징이 함께 사용된다.

검색 요청 DTO

@Getter
@Setter
public class ProductSearchRequest {
    // 페이징 파라미터
    private int page = 0;
    private int size = 20;
    
    // 정렬 파라미터
    private String sortBy = "createdAt";
    private String sortDirection = "DESC";
    
    // 검색 및 필터 파라미터
    private String keyword;        // 상품명 검색
    private String category;       // 카테고리 필터
    private Integer minPrice;      // 최소 가격
    private Integer maxPrice;      // 최대 가격
    private Boolean inStock;       // 재고 있는 상품만
}

복합 조건 쿼리

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    
    @Query("SELECT p FROM Product p WHERE " +
           "(:keyword IS NULL OR LOWER(p.name) LIKE LOWER(CONCAT('%', :keyword, '%'))) AND " +
           "(:category IS NULL OR p.category = :category) AND " +
           "(:minPrice IS NULL OR p.price >= :minPrice) AND " +
           "(:maxPrice IS NULL OR p.price <= :maxPrice) AND " +
           "(:inStock IS NULL OR (:inStock = true AND p.stockQuantity

Thymeleaf 문법

브이담곰 — Wed, 11 Jun 2025 17:30:19 +0900

Thymeleaf는 Spring Boot에서 가장 많이 사용되는 템플릿 엔진입니다. HTML과 자연스럽게 통합되어 서버사이드 렌더링을 지원한다.

기본 설정

HTML 템플릿 기본 구조

<!DOCTYPE html>
<html lang="ko" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Thymeleaf 예제</title>
</head>
<body>
    <!-- Thymeleaf 문법 사용 -->
</body>
</html>

Controller에서 데이터 전달

@Controller
public class HomeController {

    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("message", "안녕하세요!");
        model.addAttribute("user", new User("김철수", 25));
        model.addAttribute("products", Arrays.asList("상품1", "상품2", "상품3"));
        return "index";
    }
}

기본 문법

1. 텍스트 출력 (`th:text`)

<!-- 기본 텍스트 출력 -->
<p th:text="${message}">기본 메시지</p>
<!-- 결과: <p>안녕하세요!</p> -->

<!-- 객체의 속성 접근 -->
<p th:text="${user.name}">사용자 이름</p>
<!-- 결과: <p>김철수</p> -->

<!-- 표현식과 문자열 결합 -->
<p th:text="'안녕하세요, ' + ${user.name} + '님!'">인사말</p>
<!-- 결과: <p>안녕하세요, 김철수님!</p> -->

2. HTML 출력 (`th:utext`)

<!-- HTML 태그가 포함된 텍스트 -->
<div th:utext="${htmlContent}">기본 내용</div>
<!-- htmlContent = "<strong>굵은 글씨</strong>" -->
<!-- 결과: <div><strong>굵은 글씨</strong></div> -->

<!-- th:text와 비교 -->
<div th:text="${htmlContent}">기본 내용</div>
<!-- 결과: <div>&lt;strong&gt;굵은 글씨&lt;/strong&gt;</div> -->

3. 속성 값 설정 (`th:속성명`)

<!-- value 속성 설정 -->
<input type="text" th:value="${user.name}" />
<!-- 결과: <input type="text" value="김철수" /> -->

<!-- href 속성 설정 -->
<a th:href="'/user/' + ${user.id}">사용자 상세</a>
<!-- 결과: <a href="/user/123">사용자 상세</a> -->

<!-- class 속성 설정 -->
<div th:class="${user.active} ? 'active' : 'inactive'">상태</div>

<!-- id 속성 설정 -->
<div th:id="'user-' + ${user.id}">사용자 정보</div>
<!-- 결과: <div id="user-123">사용자 정보</div> -->

<!-- 여러 속성 동시 설정 -->
<input th:attr="type='text',value=${user.name},placeholder='이름을 입력하세요'" />

URL 생성 (`@{...}`)

기본 URL 생성

<!-- 정적 URL -->
<a th:href="@{/home}">홈으로</a>
<!-- 결과: <a href="/home">홈으로</a> -->

<!-- 동적 URL (경로 변수) -->
<a th:href="@{/user/{id}(id=${user.id})}">사용자 상세</a>
<!-- 결과: <a href="/user/123">사용자 상세</a> -->

<!-- 쿼리 파라미터 -->
<a th:href="@{/search(keyword=${keyword},page=${page})}">검색</a>
<!-- 결과: <a href="/search?keyword=spring&page=1">검색</a> -->

<!-- 경로 변수 + 쿼리 파라미터 -->
<a th:href="@{/user/{id}/orders(id=${user.id},status=${orderStatus})}">주문 목록</a>
<!-- 결과: <a href="/user/123/orders?status=PENDING">주문 목록</a> -->

폼 action URL

<!-- 기본 폼 -->
<form th:action="@{/user/save}" method="post">
    <input type="text" name="name" th:value="${user.name}" />
    <input type="submit" value="저장" />
</form>

<!-- 동적 폼 action -->
<form th:action="@{/user/{id}/update(id=${user.id})}" method="post">
    <input type="text" name="name" th:value="${user.name}" />
    <input type="submit" value="수정" />
</form>

조건문 (`th:if`, `th:unless`, `th:switch`)

if/unless 조건문

<!-- th:if - 조건이 true일 때 렌더링 -->
<div th:if="${user.age >= 18}">
    성인 사용자입니다.
</div>

<!-- th:unless - 조건이 false일 때 렌더링 -->
<div th:unless="${user.age >= 18}">
    미성년 사용자입니다.
</div>

<!-- 복합 조건 -->
<div th:if="${user != null and user.active}">
    활성 사용자입니다.
</div>

<!-- 문자열 비교 -->
<div th:if="${user.role == 'ADMIN'}">
    관리자 메뉴
</div>

<!-- null 체크 -->
<div th:if="${user?.email != null}">
    이메일: <span th:text="${user.email}"></span>
</div>

switch/case 조건문

<div th:switch="${user.role}">
    <p th:case="'ADMIN'">관리자입니다.</p>
    <p th:case="'USER'">일반 사용자입니다.</p>
    <p th:case="'GUEST'">게스트입니다.</p>
    <p th:case="*">알 수 없는 역할입니다.</p>
</div>

반복문 (`th:each`)

기본 반복문

<!-- 리스트 반복 -->
<ul>
    <li th:each="product : ${products}" th:text="${product}">상품명</li>
</ul>
<!-- 결과:
<ul>
    <li>상품1</li>
    <li>상품2</li>
    <li>상품3</li>
</ul>
-->

<!-- 객체 리스트 반복 -->
<table>
    <tr th:each="user : ${users}">
        <td th:text="${user.id}">ID</td>
        <td th:text="${user.name}">이름</td>
        <td th:text="${user.email}">이메일</td>
    </tr>
</table>

반복 상태 변수 (Status Variable)

<table>
    <tr th:each="user, status : ${users}">
        <td th:text="${status.index}">인덱스</td>      <!-- 0부터 시작 -->
        <td th:text="${status.count}">순번</td>        <!-- 1부터 시작 -->
        <td th:text="${user.name}">이름</td>
        <td th:text="${status.odd} ? '홀수' : '짝수'">순서</td>
        <td th:if="${status.first}">첫 번째</td>
        <td th:if="${status.last}">마지막</td>
    </tr>
</table>

Map 반복

<!-- Map 순회 -->
<div th:each="entry : ${userMap}">
    <p>키: <span th:text="${entry.key}"></span></p>
    <p>값: <span th:text="${entry.value}"></span></p>
</div>

폼 처리

기본 폼 바인딩

<!-- 객체 바인딩 -->
<form th:action="@{/user/save}" th:object="${user}" method="post">
    <input type="text" th:field="*{name}" placeholder="이름" />
    <input type="email" th:field="*{email}" placeholder="이메일" />
    <input type="number" th:field="*{age}" placeholder="나이" />
    <select th:field="*{role}">
        <option value="USER">사용자</option>
        <option value="ADMIN">관리자</option>
    </select>
    <input type="submit" value="저장" />
</form>

체크박스와 라디오 버튼

<!-- 체크박스 -->
<input type="checkbox" th:field="*{active}" />
<label th:for="${#ids.prev('active')}">활성 상태</label>

<!-- 여러 체크박스 -->
<div th:each="hobby : ${hobbies}">
    <input type="checkbox" th:field="*{selectedHobbies}" th:value="${hobby}" />
    <label th:for="${#ids.prev('selectedHobbies')}" th:text="${hobby}">취미</label>
</div>

<!-- 라디오 버튼 -->
<div th:each="gender : ${genders}">
    <input type="radio" th:field="*{gender}" th:value="${gender}" />
    <label th:for="${#ids.prev('gender')}" th:text="${gender}">성별</label>
</div>

선택 옵션 (Select)

<!-- 기본 셀렉트 -->
<select th:field="*{categoryId}">
    <option value="">카테고리 선택</option>
    <option th:each="category : ${categories}" 
            th:value="${category.id}" 
            th:text="${category.name}">카테고리</option>
</select>

<!-- 선택된 값 표시 -->
<select th:field="*{role}">
    <option th:each="role : ${roles}" 
            th:value="${role}" 
            th:text="${role}"
            th:selected="${role == user.role}">역할</option>
</select>

CSS 클래스와 스타일

동적 클래스 적용

<!-- 조건부 클래스 -->
<div th:class="${user.active} ? 'active' : 'inactive'">상태</div>

<!-- 기존 클래스에 추가 -->
<div class="base-class" th:classappend="${user.premium} ? 'premium' : ''">
    사용자 정보
</div>

<!-- 클래스 제거 -->
<div class="default error" th:classremove="${user.valid} ? 'error' : ''">
    입력 필드
</div>

동적 스타일 적용

<!-- 인라인 스타일 -->
<div th:style="'background-color: ' + ${user.favoriteColor}">배경색</div>

<!-- 조건부 스타일 -->
<div th:style="${user.online} ? 'color: green;' : 'color: gray;'">
    온라인 상태
</div>

유틸리티 객체

날짜 처리 (`#dates`)

<!-- 현재 날짜 -->
<p th:text="${#dates.createNow()}">현재 시간</p>

<!-- 날짜 포맷팅 -->
<p th:text="${#dates.format(user.createdAt, 'yyyy-MM-dd HH:mm:ss')}">
    생성일시
</p>

<!-- 날짜 계산 -->
<p th:text="${#dates.daysBetween(startDate, endDate)}">일수 차이</p>

문자열 처리 (`#strings`)

<!-- 문자열 길이 -->
<p th:text="${#strings.length(user.name)}">이름 길이</p>

<!-- 문자열 자르기 -->
<p th:text="${#strings.substring(user.description, 0, 50)}">설명</p>

<!-- 대소문자 변환 -->
<p th:text="${#strings.toUpperCase(user.name)}">대문자 이름</p>

<!-- 문자열 체크 -->
<div th:if="${#strings.isEmpty(user.email)}">이메일이 없습니다.</div>
<div th:if="${#strings.contains(user.name, '김')}">김씨입니다.</div>

숫자 처리 (`#numbers`)

<!-- 숫자 포맷팅 -->
<p th:text="${#numbers.formatDecimal(product.price, 0, 'COMMA', 0, 'POINT')}">
    가격: 1,000
</p>

<!-- 퍼센트 -->
<p th:text="${#numbers.formatPercent(rate, 1, 2)}">비율</p>

컬렉션 처리 (`#lists`, `#sets`, `#maps`)

<!-- 리스트 크기 -->
<p th:text="'총 ' + ${#lists.size(products)} + '개의 상품'">상품 개수</p>

<!-- 리스트 비어있는지 확인 -->
<div th:if="${#lists.isEmpty(products)}">상품이 없습니다.</div>

<!-- 리스트 포함 여부 -->
<div th:if="${#lists.contains(favoriteProducts, product.id)}">
    즐겨찾기 상품입니다.
</div>

국제화 (i18n)

메시지 사용

<!-- 기본 메시지 -->
<p th:text="#{welcome.message}">환영 메시지</p>

<!-- 파라미터가 있는 메시지 -->
<p th:text="#{welcome.user(${user.name})}">사용자 환영 메시지</p>

<!-- 조건부 메시지 -->
<p th:text="#{${user.gender == 'M'} ? 'male.message' : 'female.message'}">
    성별별 메시지
</p>

properties 파일 예시

# messages.properties
welcome.message=환영합니다!
welcome.user=환영합니다, {0}님!
male.message=남성 사용자입니다.
female.message=여성 사용자입니다.

프래그먼트 (Fragment)

프래그먼트 정의

<!-- header.html -->
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head th:fragment="head">
    <meta charset="UTF-8">
    <title>공통 헤더</title>
    <link rel="stylesheet" href="/css/common.css">
</head>
<body>
    <header th:fragment="header">
        <nav>
            <a href="/">홈</a>
            <a href="/products">상품</a>
            <a href="/about">소개</a>
        </nav>
    </header>
</body>
</html>

프래그먼트 사용

<!-- main.html -->
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="~{header :: head}"></head>
<body>
    <!-- 헤더 포함 -->
    <div th:replace="~{header :: header}"></div>

    <!-- 메인 컨텐츠 -->
    <main>
        <h1>메인 페이지</h1>
        <p>내용...</p>
    </main>

    <!-- 푸터 포함 -->
    <div th:include="~{footer :: footer}"></div>
</body>
</html>

파라미터가 있는 프래그먼트

<!-- components.html -->
<div th:fragment="card(title, content)">
    <div class="card">
        <h3 th:text="${title}">제목</h3>
        <p th:text="${content}">내용</p>
    </div>
</div>

<!-- 사용 -->
<div th:replace="~{components :: card('공지사항', '새로운 기능이 추가되었습니다.')}">
</div>

표현식 언어

변수 표현식 (`${...}`)

<!-- 기본 변수 -->
<p th:text="${user.name}">이름</p>

<!-- 중첩 객체 -->
<p th:text="${user.address.city}">도시</p>

<!-- 메서드 호출 -->
<p th:text="${user.getFullName()}">전체 이름</p>

<!-- null 안전 연산자 -->
<p th:text="${user?.address?.city}">도시 (null 안전)</p>

선택 변수 표현식 (`*{...}`)

<!-- th:object와 함께 사용 -->
<div th:object="${user}">
    <p th:text="*{name}">이름</p>
    <p th:text="*{email}">이메일</p>
    <p th:text="*{age}">나이</p>
</div>

링크 표현식 (`@{...}`)

<!-- 상대 URL -->
<a th:href="@{/user/list}">사용자 목록</a>

<!-- 절대 URL -->
<a th:href="@{http://www.example.com}">외부 링크</a>

<!-- 컨텍스트 상대 URL -->
<a th:href="@{~/documents/report.pdf}">문서</a>

메시지 표현식 (`#{...}`)

<!-- 기본 메시지 -->
<p th:text="#{home.welcome}">환영 메시지</p>

<!-- 변수가 있는 메시지 -->
<p th:text="#{user.greeting(${user.name})}">인사말</p>

고급 기능

조건부 렌더링

<!-- Elvis 연산자 -->
<p th:text="${user.name} ?: '이름 없음'">기본 이름</p>

<!-- 삼항 연산자 -->
<p th:text="${user.age >= 18} ? '성인' : '미성년자'">연령대</p>

<!-- No-Operation 토큰 -->
<p th:text="${user.description} ?: _">
    기본 설명입니다. (user.description이 null이면 이 텍스트 유지)
</p>

데이터 속성 추가

<!-- 동적 데이터 속성 -->
<div th:data-user-id="${user.id}" 
     th:data-user-role="${user.role}">
    사용자 정보
</div>
<!-- 결과: <div data-user-id="123" data-user-role="ADMIN">사용자 정보</div> -->

인라인 처리

<!-- 텍스트 인라인 -->
<p>안녕하세요, [[${user.name}]]님!</p>

<!-- JavaScript 인라인 -->
<script th:inline="javascript">
    var user = /*[[${user}]]*/ {};
    var userName = /*[[${user.name}]]*/ 'default';
    console.log('사용자:', userName);
</script>

<!-- CSS 인라인 -->
<style th:inline="css">
    .user-color {
        color: /*[[${user.favoriteColor}]]*/ blue;
    }
</style>

실전 예제

완전한 사용자 목록 페이지

<!DOCTYPE html>
<html lang="ko" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title th:text="#{page.user.list}">사용자 목록</title>
    <link rel="stylesheet" href="/css/bootstrap.min.css">
</head>
<body>
    <div class="container">
        <h1 th:text="#{page.user.list}">사용자 목록</h1>

        <!-- 검색 폼 -->
        <form th:action="@{/users}" method="get" class="mb-3">
            <div class="row">
                <div class="col-md-4">
                    <input type="text" name="search" 
                           th:value="${param.search}" 
                           placeholder="이름 또는 이메일 검색" 
                           class="form-control">
                </div>
                <div class="col-md-2">
                    <select name="role" class="form-control">
                        <option value="">전체 역할</option>
                        <option th:each="role : ${roles}" 
                                th:value="${role}" 
                                th:text="${role}"
                                th:selected="${param.role == role}">역할</option>
                    </select>
                </div>
                <div class="col-md-2">
                    <button type="submit" class="btn btn-primary">검색</button>
                </div>
            </div>
        </form>

        <!-- 사용자 목록 -->
        <div th:if="${#lists.isEmpty(users)}" class="alert alert-info">
            등록된 사용자가 없습니다.
        </div>

        <table th:unless="${#lists.isEmpty(users)}" class="table table-striped">
            <thead>
                <tr>
                    <th>#</th>
                    <th>이름</th>
                    <th>이메일</th>
                    <th>역할</th>
                    <th>상태</th>
                    <th>가입일</th>
                    <th>액션</th>
                </tr>
            </thead>
            <tbody>
                <tr th:each="user, status : ${users}">
                    <td th:text="${status.count}">순번</td>
                    <td>
                        <a th:href="@{/users/{id}(id=${user.id})}" 
                           th:text="${user.name}">이름</a>
                    </td>
                    <td th:text="${user.email}">이메일</td>
                    <td>
                        <span class="badge" 
                              th:classappend="${user.role == 'ADMIN'} ? 'badge-danger' : 'badge-primary'"
                              th:text="${user.role}">역할</span>
                    </td>
                    <td>
                        <span th:if="${user.active}" class="text-success">활성</span>
                        <span th:unless="${user.active}" class="text-danger">비활성</span>
                    </td>
                    <td th:text="${#dates.format(user.createdAt, 'yyyy-MM-dd')}">가입일</td>
                    <td>
                        <a th:href="@{/users/{id}/edit(id=${user.id})}" 
                           class="btn btn-sm btn-outline-primary">수정</a>
                        <a th:href="@{/users/{id}/delete(id=${user.id})}" 
                           class="btn btn-sm btn-outline-danger"
                           onclick="return confirm('정말 삭제하시겠습니까?')">삭제</a>
                    </td>
                </tr>
            </tbody>
        </table>

        <!-- 페이징 -->
        <nav th:if="${totalPages > 1}">
            <ul class="pagination justify-content-center">
                <li class="page-item" th:classappend="${currentPage == 0} ? 'disabled'">
                    <a class="page-link" 
                       th:href="@{/users(page=0, search=${param.search}, role=${param.role})}">
                        첫 페이지
                    </a>
                </li>
                <li class="page-item" th:classappend="${currentPage == 0} ? 'disabled'">
                    <a class="page-link" 
                       th:href="@{/users(page=${currentPage - 1}, search=${param.search}, role=${param.role})}">
                        이전
                    </a>
                </li>

                <li th:each="pageNum : ${#numbers.sequence(0, totalPages - 1)}"
                    class="page-item" 
                    th:classappend="${pageNum == currentPage} ? 'active'">
                    <a class="page-link" 
                       th:href="@{/users(page=${pageNum}, search=${param.search}, role=${param.role})}"
                       th:text="${pageNum + 1}">페이지</a>
                </li>

                <li class="page-item" th:classappend="${currentPage == totalPages - 1} ? 'disabled'">
                    <a class="page-link" 
                       th:href="@{/users(page=${currentPage + 1}, search=${param.search}, role=${param.role})}">
                        다음
                    </a>
                </li>
                <li class="page-item" th:classappend="${currentPage == totalPages - 1} ? 'disabled'">
                    <a class="page-link" 
                       th:href="@{/users(page=${totalPages - 1}, search=${param.search}, role=${param.role})}">
                        마지막 페이지
                    </a>
                </li>
            </ul>
        </nav>
    </div>
</body>
</html>

이 가이드를 통해 Thymeleaf의 주요 문법들을 실전에서 바로 활용할 수 있습니다!

@PathVariable vs @RequestParam 완벽 가이드

브이담곰 — Wed, 11 Jun 2025 17:16:03 +0900

Spring Framework에서 HTTP 요청의 데이터를 받는 두 가지 주요 어노테이션인 @PathVariable과 @RequestParam의 차이점과 사용법을 알아보자.

@PathVariable

URL 경로의 일부를 변수로 추출하는 어노테이션

기본 문법

@GetMapping("/users/{id}")
public String getUser(@PathVariable Long id) {
    // id는 URL 경로에서 추출됨
}

특징

URL 경로 자체가 데이터
RESTful API 설계에 적합
필수 데이터 (경로의 일부이므로 생략 불가)
보통 리소스 식별자로 사용

사용 예시

1. 기본 사용법

@Controller
@RequestMapping("/menu")
public class MenuController {

    // URL: /menu/123
    @GetMapping("/{id}")
    public String getMenu(@PathVariable Long id, Model model) {
        MenuDTO menu = menuService.findById(id);
        model.addAttribute("menu", menu);
        return "menu/detail";
    }

    // URL: /menu/delete/456
    @PostMapping("/delete/{menuId}")
    public String deleteMenu(@PathVariable("menuId") Long id) {
        menuService.deleteMenu(id);
        return "redirect:/menu/list";
    }
}

2. 여러 개의 PathVariable

// URL: /users/123/orders/456
@GetMapping("/users/{userId}/orders/{orderId}")
public String getUserOrder(@PathVariable Long userId, 
                          @PathVariable Long orderId, 
                          Model model) {
    OrderDTO order = orderService.findByUserAndOrder(userId, orderId);
    model.addAttribute("order", order);
    return "order/detail";
}

3. Optional PathVariable

// URL: /products 또는 /products/electronics
@GetMapping({"/products", "/products/{category}"})
public String getProducts(@PathVariable(required = false) String category, 
                         Model model) {
    if (category != null) {
        // 카테고리별 상품 조회
        model.addAttribute("products", productService.findByCategory(category));
    } else {
        // 전체 상품 조회
        model.addAttribute("products", productService.findAll());
    }
    return "product/list";
}

@RequestParam

URL의 쿼리 파라미터나 폼 데이터를 추출하는 어노테이션.

기본 문법

@GetMapping("/search")
public String search(@RequestParam String keyword) {
    // ?keyword=값 에서 값을 추출
}

특징

URL 뒤에 ?key=value 형태
선택적 파라미터 (기본값 설정 가능)
필터링, 검색, 페이징에 주로 사용
폼 데이터도 받을 수 있음

사용 예시

1. 기본 사용법

@Controller
@RequestMapping("/menu")
public class MenuController {

    // URL: /menu/search?keyword=햄버거
    @GetMapping("/search")
    public String searchMenu(@RequestParam String keyword, Model model) {
        List<MenuDTO> menus = menuService.searchByKeyword(keyword);
        model.addAttribute("menus", menus);
        return "menu/search-result";
    }

    // URL: /menu/list?page=1&size=10
    @GetMapping("/list")
    public String getMenuList(@RequestParam(defaultValue = "1") int page,
                             @RequestParam(defaultValue = "10") int size,
                             Model model) {
        PageResult<MenuDTO> result = menuService.findMenus(page, size);
        model.addAttribute("menus", result);
        return "menu/list";
    }
}

2. 선택적 파라미터와 기본값

// URL: /products?category=electronics&minPrice=100&maxPrice=500
@GetMapping("/products")
public String getProducts(@RequestParam(required = false) String category,
                         @RequestParam(defaultValue = "0") int minPrice,
                         @RequestParam(defaultValue = "999999") int maxPrice,
                         @RequestParam(defaultValue = "name") String sortBy,
                         Model model) {

    ProductSearchCriteria criteria = ProductSearchCriteria.builder()
        .category(category)
        .minPrice(minPrice)
        .maxPrice(maxPrice)
        .sortBy(sortBy)
        .build();

    List<ProductDTO> products = productService.search(criteria);
    model.addAttribute("products", products);
    return "product/list";
}

3. 폼 데이터 받기

// HTML 폼에서 POST 요청
@PostMapping("/register")
public String registerMenu(@RequestParam String name,
                          @RequestParam int price,
                          @RequestParam String category,
                          @RequestParam(defaultValue = "Y") String status) {

    MenuDTO menu = MenuDTO.builder()
        .name(name)
        .price(price)
        .category(category)
        .status(status)
        .build();

    menuService.register(menu);
    return "redirect:/menu/list";
}

4. 배열/리스트 파라미터

// URL: /menu/delete?ids=1&ids=2&ids=3
@PostMapping("/delete")
public String deleteMenus(@RequestParam("ids") List<Long> menuIds) {
    menuService.deleteMenus(menuIds);
    return "redirect:/menu/list";
}

// URL: /products?tags=sale&tags=new&tags=popular
@GetMapping("/products")
public String getProductsByTags(@RequestParam List<String> tags, Model model) {
    List<ProductDTO> products = productService.findByTags(tags);
    model.addAttribute("products", products);
    return "product/list";
}

⚖️ 언제 무엇을 사용할까?

@PathVariable 사용 시기

리소스 식별: /users/{id}, /orders/{orderId}
계층 구조: /users/{userId}/orders/{orderId}
RESTful API: CRUD 작업의 대상 지정
필수 데이터: 반드시 있어야 하는 값

// ✅ 좋은 예시
@GetMapping("/users/{id}")           // 특정 사용자 조회
@PutMapping("/products/{id}")        // 특정 상품 수정
@DeleteMapping("/orders/{id}")       // 특정 주문 삭제
@GetMapping("/categories/{categoryId}/products/{productId}") // 계층 구조

@RequestParam 사용 시기

검색/필터링: 검색어, 필터 조건
페이징: page, size, sort
선택적 옵션: 기본값이 있는 설정들
폼 데이터: 사용자 입력 데이터

// ✅ 좋은 예시
@GetMapping("/products?category=electronics&minPrice=100")  // 필터링
@GetMapping("/users?page=1&size=20&sort=name")             // 페이징
@GetMapping("/search?keyword=맛있는&type=korean")            // 검색
@PostMapping("/contact")  // 폼 데이터                      // 폼 전송

혼합 사용 예시

실제 프로젝트에서는 두 어노테이션을 함께 사용하는 경우가 많다.

@Controller
@RequestMapping("/api/v1")
public class ProductController {

    // 특정 카테고리의 상품들을 페이징과 정렬로 조회
    // URL: /api/v1/categories/electronics/products?page=1&size=20&sort=price&order=asc
    @GetMapping("/categories/{categoryId}/products")
    public ResponseEntity<PageResult<ProductDTO>> getCategoryProducts(
            @PathVariable Long categoryId,                    // 카테고리 ID (필수)
            @RequestParam(defaultValue = "1") int page,       // 페이지 번호 (선택)
            @RequestParam(defaultValue = "20") int size,      // 페이지 크기 (선택)
            @RequestParam(defaultValue = "name") String sort, // 정렬 기준 (선택)
            @RequestParam(defaultValue = "asc") String order  // 정렬 순서 (선택)
    ) {
        PageResult<ProductDTO> result = productService.findByCategoryId(
            categoryId, page, size, sort, order
        );
        return ResponseEntity.ok(result);
    }

    // 특정 사용자의 주문들을 상태별로 필터링
    // URL: /api/v1/users/123/orders?status=PENDING&startDate=2024-01-01&endDate=2024-12-31
    @GetMapping("/users/{userId}/orders")
    public ResponseEntity<List<OrderDTO>> getUserOrders(
            @PathVariable Long userId,                        // 사용자 ID (필수)
            @RequestParam(required = false) String status,    // 주문 상태 (선택)
            @RequestParam(required = false) String startDate, // 시작 날짜 (선택)
            @RequestParam(required = false) String endDate    // 종료 날짜 (선택)
    ) {
        OrderSearchCriteria criteria = OrderSearchCriteria.builder()
            .userId(userId)
            .status(status)
            .startDate(startDate)
            .endDate(endDate)
            .build();

        List<OrderDTO> orders = orderService.searchOrders(criteria);
        return ResponseEntity.ok(orders);
    }
}

요약 비교표

구분	@PathVariable	@RequestParam
위치	URL 경로 안	URL 쿼리 파라미터 (?key=value)
필수성	필수 (경로의 일부)	선택적 (required 속성으로 제어)
기본값	설정 불가	defaultValue로 설정 가능
용도	리소스 식별, RESTful API	검색, 필터링, 페이징, 폼 데이터
예시 URL	`/users/123`	`/search?keyword=spring`
여러 값	여러 개 가능	배열/리스트로 받기 가능

베스트 프랙티스

1. RESTful API 설계

// ✅ 권장
@GetMapping("/users/{id}")              // 사용자 조회
@GetMapping("/users/{id}/orders")       // 사용자의 주문 목록
@GetMapping("/users?search=name&page=1") // 사용자 검색

// ❌ 비권장
@GetMapping("/getUser?id=123")          // 비RESTful
@GetMapping("/user-orders?userId=123")  // 계층 구조 미표현

2. 의미있는 변수명 사용

// ✅ 권장
@GetMapping("/products/{productId}")
public String getProduct(@PathVariable("productId") Long id) { }

// ✅ 권장 (변수명이 같으면 value 생략 가능)
@GetMapping("/products/{id}")
public String getProduct(@PathVariable Long id) { }

3. 유효성 검사 추가

@GetMapping("/users/{id}")
public String getUser(@PathVariable @Min(1) Long id) {
    // id는 1 이상이어야 함
}

@GetMapping("/search")
public String search(@RequestParam @Size(min=2, max=50) String keyword) {
    // 검색어는 2자 이상 50자 이하
}

이렇게 @PathVariable과 @RequestParam을 적절히 사용하면 깔끔하고 이해하기 쉬운 API를 만들 수 있다.

크래프톤 정글 6기 TIL - Review | 트라이( Trie )

브이담곰 — Wed, 8 Jan 2025 00:27:12 +0900

정글 공부 키워드를 복습하며.. 모른척 했던 주제에 맞서 보려고 한다.. 그것은

트라이.. 2주차 째 Optional 이라 되어있지만 등장하는 걸 보아선..미루면 안된다..

유튭 강의를 하나 슥 볼랬는데 바킹독님 마지막 강의가 트라이였다.

내 최애 남잔데, 그의 최애 알고리즘이 트라이라 그래서 호감도 급 상승..

렛츠 기릿..

진심으로 바킹독님..넘 멋지다..

트라이( Trie )

문자를 효율적으로 처리하기 위한 트리 자료구조

✅ 장점 : 단어의 저장 개수와 무관하게 삽입,탐색, 삭제가 O(|S|)의 시간 복잡도를 가진다.
✅ 단점 : 메모리를 많이 차지한다. 트리의 정점의 index를 기록해야해서 int의 4바이트* |S| 만큼 메모리를 더 사용한다.

다른 자료구조와 비교!
이진 검색 트리 : 삽입, 탐색, 삭제가 O(logN) 이지만, 문자열을 검색할 경우 단어의 길이 S 만큼 대조를 해야하기 때문에,
최악의 경우 O( S * logN ) 이 걸린다.

해시 : 삽입, 탐색, 삭제가 O(1) 이지만, 문자열을 검색할 경우 O( |S| )이 걸리고, 해시 충돌에 따라 성능이 저하 될 수 있다.

다른 자료구조와 비교했을 때 확실히 트라이가 시간이 빨라보이지만,

실제로 구현해보면 일반적인 문자열의 삽입, 탐색, 삭제를 수행하는 상황에서

트라이보다 해시나 이진 검색트리가 메모리, 시간 측에서 모두 효율적이다.

트라이 삽입 로직

노란색 : 현재 노드( 정점 )

초록색 : 문자열 끝을 알려주는 트리거

현재 노드의 자식으로 단어를 추가해주면서

정점이 갱신된다.

마지막 글자는 트리거를 갱신해 주면서, 탐색 할 때 글자의 끝임을 알려준다.

트라이 검색 로직

정점을 이동하며 글자를 비교한다.

트리거를 통해 단어의 끝임을 알고,

해당 단어가 존재함을 알 수 있다.

트라이 삭제 로직

트리의 구조를 변경하면 안되는 트라이 특성상

삭제 작업을 할 때, 정점을 직접적으로 삭제할 수 없다.

따라서 트리거를 지움으로 써 단어가 존재함을 간접적으로 삭제한다.

따라서 불필요한 단어가 트리에 남아 있을 수 있으므로,

⭐메모리 측면에서 비효율적일 수 있다.

트라이는 삭제가 많은 작업에서는 굉장히 높은 공간 복잡도를 가질 수 있음을 알 수 있다.

✏ 트라이 구현

앞서서 말했 듯, 정점의 자식을 관리하는 배열들은

정점의 인덱스로 관리되기 때문에 int 자료형을 사용한다.

따라서 단순히 char 배열이라면 문자의 수 N 만큼의 1 * 1 * 단어 개수 byte의 메모리가 사용되겠지만

int 자료형을 사용하기 때문에 4 * 4byte * 단어 개수 의 메모리가 사용된다.

( 26개의 문자를 사용한다면 그 4배인, 104 * 단어 개수 byte배 만큼 사용된다. )

메모리 절약 방법
출처 : https://blog.encrypted.gg/1059( BaaaaaaaarkingDog Trie 블로그 글 )

출처 : https://blog.encrypted.gg/1059( BaaaaaaaarkingDog Trie 블로그 글 )

가정한 시간, 공간 복잡도와

실제 시간과 메모리 사용정도는 확연히 다름을 볼 수 있다.

일단 정적배열은 당연히 시간은 적게 걸리지만 메모리가 많이 사용되었고,

동적 배열과 연결리스트는 정점 리스트를 검색 할 때 O(1)이 아닌 O(26) 만큼 시간이 걸리기 떄문에 기하급수적으로 오래 걸리는 것을 볼 수 있다.

이진 검색트리는 메모리는 정적 배열과 비슷하지만 시간은 정적 배열보다 훨씬 느린 것을 볼 수 있다.

반면, 해시는 충격적인 결과가...나왔는데. 이는 아무래도 단어를 저장하는데 각각의 문자는 중복됨이 많으니 아마 해시 충돌의 발생률이 높아져서 시간이 오래 걸린 것 같다는 생각이 든다.

공간 복잡도도,, 뭐 애초에 이걸 해시로 구현하는데 웃김..( 쓰기 귀찮아서 이렇게 쓰는건 아님 )

크래프톤 정글 6기 TIL - Review | 보이어-무어 알고리즘

브이담곰 — Tue, 7 Jan 2025 17:27:28 +0900

진짜 오랜만에 쓴다..

정글 중반기에 들어가면서,, 할게 너무 많고 블로그에 "정리"를 하는거 자체도 힘들어서.. 공부하면서 노션에다 기록했더니 TIL을 안쓰는 사람처럼 보여버렸다..

수료를 하고나서~ 좀 쉬다가!!

정글 콤파스 보면서 놓쳤던 부분들 복습하는 중인데, 여기다가 정리를 해보려구 한다.

나름 복습할 때 도움이 많이 되었다! 키키

✅ 보이어 - 무어를 공부하기 전에....

1. 부르투 포스 알고리즘

2. KMP 알고리즘

에 대해 먼저 공부하는 것을 추천 !

Boyer - Moore algorithm( 보이어 무어 알고리즘 )

문자열 검색에 사용되는 알고리즘이다.

불필요한 것을 건너뛰고. 검색을 빠르게 하는 것이 주 목표.

워드 검색 기능에서 사용된다.

보이어-무어 알고리즘은 보통 상황에서 문자열은 앞부분보다는

뒷부분에서 불일치가 일어날 확률이 높다는 성질을 활용한다.

그래서 오른쪽끝부터 비교하게 된다!

Bad Character Rule

- 주어진 Text에서 특정 Pattern의 문자열을 찾는 방법.

- 일일이 비교하는 brute-force method보다 효율적.

- 찾고자 하는 문자열 Pattern에 대한 문자열내 저장위치를 알아야 함.

- 앞의 문자부터 비교하지 않고 뒤의 문자부터 비교.

- 문자(Character)가 일치하지 않을 때 사용.

아래와 같이 Text안에서 Pattern(P)가 있는지 검색을 해본다고 하자.

1. Skip Table을 만든다.

문자를 비교하다가 문자가 일치 하지 않을 때

얼만큼 패턴을 이동시킬지 결정하는 테이블이다.

Patter의 길이는 4 이니까, 위와 같이 계산해준다.

2. Pattern의 우측부터 차례로 비교를 한다.

불일치 할 경우 Text의 문자가 Pattern에 있는지 검색을 한다.

만약, Pattern에 없을 경우 Skip table의 * 일 경우 만큼 문자를 이동한다.

3. 다시 우측부터 비교를 하는데,

T, A는 일치하고 다음 A는 일치하지 않는다.

여기서 A가 패턴에 존재 하는지 검사를 하는데, 현재 남은 패턴 문자들 내에서는 존재하지 않기 때문에

일치 하지 않는 문자의 개수 만큼 Pattern을 이동시킨다.

4. 다시 우측부터 비교를 한다.

C와 T는 일치하지 않지만, Text의 C는 Pattern에 존재한다.

Skip Table에서 C의 값 만큼 이동한다.

5. 다시 우측부터 비교를 한다.

모두 일치하므로 검색은 종료된다.

Boyer-Moore: Bad Character Rule 효율

1 ) Brute-Force 방법과 달리 모든 문자를 순회하면서 비교하지 않아도 되므로 더 효율적인 비교 가능.
2 ) 선형적 시간 복잡도를 가짐에도 다른 패턴 매칭 알고리즘에 비해 우수한 성능을 가짐.
3 ) Text 길이가 N개의 문자열일 때, 패턴의 길이 M만큼 비교 수행.

O(N*M)

10844 쉬운 계단 수

브이담곰 — Wed, 14 Aug 2024 15:50:55 +0900

https://www.acmicpc.net/status?user_id=yuu_ta&problem_id=10844&from_mine=1

✔ 유형 : DP

✔ 문제 풀이: 일의 자리 수에 어떤 수가 오느냐에 따라 경우의 수가 달라짐을 알고, 점화식을 세워 배열을 채워나간다.

코드

import sys
input = sys.stdin.readline

MOD = 1000000000

N = int(input())

# 1 <= N <= 100
DP = [[0 for _ in range(10)] for _ in range(N+1)] # 수의 길이와 올수있는 숫자종류 0~9 

# 초기 조건 설정 (1자리 숫자)
for i in range(1, 10):  # 0으로 시작하는 수는 계단 수가 아니므로 1부터 시작
    DP[1][i] = 1

if N >= 2:
    for i in range(2, N+1):
        DP[i][0] = DP[i-1][1] % MOD
        
        for j in range(1, 9):
            DP[i][j] = (DP[i-1][j-1] + DP[i-1][j+1]) % MOD
        
        DP[i][9] = DP[i-1][8] % MOD

result = sum(DP[N]) % MOD
        
print(result)

11053 가장 긴 증가하는 부분의 수열

브이담곰 — Tue, 13 Aug 2024 12:42:31 +0900

https://www.acmicpc.net/problem/11053

✔ 유형 : DP(LIS)

✔ 문제 풀이:

LIS(Longest Increase Sequence) 의 로직과 비슷하다.

DP[i] 를 i 번째 까지 가장 긴 증가하는 부분 수열의 개수라고 정의했을 때.

i보다 앞쪽에 있는 원소들과 비교해서 i번째의 수보다 작을 때 개수를 업데이트 한다.

정리하자면,

DP[i] : 현재까지 계산된 i위치에서의 LIS의 길이

DP[j] + 1 : j위치까지 LIS에 현재 원소를 추가한 길이

그리고 D[i] 는 위의 두 경우의 수 중 최대값으로 업데이트 해주어야한다.

따라서, "현재 원소를 이전 LIS 에 추가했을 때 더 긴 LIS가 되는가?"를 조건을 생각해주면 되는것이다.

코드

import sys
input = sys.stdin.readline

N = int(input())
arr = list(map(int, input().split()))

DP = [1] * N  # 모든 원소의 최소 길이는 1

for i in range(1, N):
    for j in range(i):
        if arr[i] > arr[j]:
            DP[i] = max(DP[i], DP[j] + 1)

print(max(DP))

2156 포도주 시식

브이담곰 — Sat, 10 Aug 2024 11:23:27 +0900

https://www.acmicpc.net/problem/2156

✔ 유형 : DP

✔ 문제 풀이:

위의 규칙을 따라서 마실 포도주를 선택해야한다.

점화식을 세우는 접근방식은 다음과 같다

1. 맨 마지막 포도주를 무조건 선택한다 했을 때, 연속 두개를 선택하고 싶다면,

arr[i] ( 마지막 포도주 ) , arr[i-1]( 마지막에서 두번째 포도주), 그리고 3개를 연속해서 선택할 수 없으므로

arr[i-2]는 선택하지 않는다.

2. 맨 마지막 포도주를 무조건 선택하고, 그 전 포도주는 선택하지 않을 때,

arr[i] ( 마지막 포도주 )를 선택하고, arr[i-1]는 선택하지 않는다.

3. 맨 마지막 포도주를 절대 선택하지 않을 때

DP[i-1] 포도주의 개수가 N-1때의 최대값을 반영하면 된다.

이를 일반화 하면

DP[i]는 세가지의 경우의 수로 일반화 하여 식을 세울 수 있다.

DP[i] = arr[i] + arr[i-1] + DP[i-3]

DP[i] = arr[i] + DP[i-2]

DP[i] = DP[i-1]

마실 수 있는 최대 포도주의 값을 구해야 하므로 세가지 경우의 수의 값 중 가장 큰 값을 반영하면 된다.

따라서,

DP[i] = max( arr[i] + arr[i-1] + DP[i-3] , rr[i] + DP[i-2] , DP[i-1] )로 점화식을 세울 수 있다.

코드

import sys
input = sys.stdin.readline

N = int(input())

arr = [ 0 for _ in range(N+1)] # arr도 1부터 시작

for _ in range(1,N+1):
    arr[_] = int(input())

DP = [ 0 for _ in range(N+1)]
DP[1] = arr[1]

# 초기값 예외처리
if N >= 2:
    DP[2] = DP[1] + arr[2] 

if N >= 3:
    for i in range(3, N+1):
        DP[i] = max(DP[i-1],DP[i-2] + arr[i] , DP[i-3] + arr[i] + arr[i-1])
        
print(DP[N])

이번 문제는 silver3 문제인 계단 오르기문제와 비슷하다고 느꼈는데, 아래 문제도 함께 생각해보면 좋을 것 같다.

2579 계단 오르기

https://www.acmicpc.net/problem/2579✔ 유형 : DP✔ 문제 풀이: 계단을 오를 때, 앞에서부터 계산해서 최대값을 구하는 것이 아닌, 최종 도착지를 정해놓고 그전 계단을 밟았을때 밟지 않았을 때 중의 최댓

damgom.dev

농담곰담곰이의곰담농

블로그 이전

[Spring Boot] Interceptor 프로젝트에 적용해보았다.

Spring Interceptor란?

1. WebConfig 클래스 생성

2. Interceptor 생성

REST API에서 페이징 처리가 필수인 이유와 실무 구현 방법

페이징을 알게 된 계기

페이징이 없다면 생기는 문제들

1. 서버 사이드 문제

2. 클라이언트 사이드 문제

3. 네트워크 문제

✅ 페이징의 해결책

Before: 100만 개 한 번에

After: 20개씩 나누어서

️ 실무에서 사용하는 페이징 구조

1. 기본적인 페이징 파라미터

2. Spring Data JPA로 구현하기

3. 커스텀 PageResponse 클래스

프론트엔드가 받는 JSON 응답

성공적인 페이징 응답

프론트엔드에서 활용하기

고급 페이징: 검색과 필터링

검색 요청 DTO

복합 조건 쿼리

Thymeleaf 문법

기본 설정

HTML 템플릿 기본 구조

Controller에서 데이터 전달

기본 문법

1. 텍스트 출력 (th:text)

2. HTML 출력 (th:utext)

3. 속성 값 설정 (th:속성명)

URL 생성 (@{...})

기본 URL 생성

폼 action URL

조건문 (th:if, th:unless, th:switch)

if/unless 조건문

switch/case 조건문

반복문 (th:each)

기본 반복문

반복 상태 변수 (Status Variable)

Map 반복

폼 처리

기본 폼 바인딩

체크박스와 라디오 버튼

선택 옵션 (Select)

CSS 클래스와 스타일

동적 클래스 적용

동적 스타일 적용

유틸리티 객체

날짜 처리 (#dates)

문자열 처리 (#strings)

숫자 처리 (#numbers)

컬렉션 처리 (#lists, #sets, #maps)

국제화 (i18n)

메시지 사용

properties 파일 예시

프래그먼트 (Fragment)

프래그먼트 정의

프래그먼트 사용

파라미터가 있는 프래그먼트

표현식 언어

변수 표현식 (${...})

선택 변수 표현식 (*{...})

링크 표현식 (@{...})

메시지 표현식 (#{...})

고급 기능

조건부 렌더링

데이터 속성 추가

인라인 처리

실전 예제

완전한 사용자 목록 페이지

@PathVariable vs @RequestParam 완벽 가이드

@PathVariable

기본 문법

특징

사용 예시

1. 기본 사용법

2. 여러 개의 PathVariable

1. 텍스트 출력 (`th:text`)

2. HTML 출력 (`th:utext`)

3. 속성 값 설정 (`th:속성명`)

URL 생성 (`@{...}`)

조건문 (`th:if`, `th:unless`, `th:switch`)

반복문 (`th:each`)

날짜 처리 (`#dates`)

문자열 처리 (`#strings`)

숫자 처리 (`#numbers`)

컬렉션 처리 (`#lists`, `#sets`, `#maps`)

변수 표현식 (`${...}`)

선택 변수 표현식 (`*{...}`)

링크 표현식 (`@{...}`)

메시지 표현식 (`#{...}`)