서비스 단에서 한 번에 모든 카테고리를 읽어와 서비스단에서 트리를 조립하는 방식으로 N+1 문제를 해결했다.
첫 번째 시도에서 재귀 단계마다 findByParentId()가 호출되어 루트 + 자식 수만큼 SELECT가 반복되는 전형적인 N+1 문제가 있었으나, 전체 카테고리를 한 번에 조회(SELECT 1회)한 뒤, 부모 ID를 기준으로 자식 목록을 매핑하고 재귀적으로 트리를 구성하는 방식으로 변경했다.
단 한번의 쿼리로 전체 트리를 조회할 수 있으나, 이 방식은 모든 카테고리를 한꺼번에 메모리에 올리기 때문에 데이터 규모가 크면 메모리 사용량이 증가하는 단점이 있다. 또한, 전체 데이터를 항상 조회하므로 특정 루트의 하위 트리만 필요할 때도 불필요한 데이터를 읽게 된다.
CategoryService
모든 카테고리 조회 (쿼리 1번)
부모 ID를 키로 하고, 그 부모를 가진 자식 카테고리 목록을 값으로 하는 Map을 만든다.
parentCategory가 없는 카테고리를 골라 루트 목록을 만든다.
루트부터 시작해, Map에서 해당 루트의 자식 목록을 찾아 붙이고, 자식도 똑같이 재귀적으로 처리한다.
DB 조회는 단 한 번만 수행되며, Entity가 아닌 DTO로 변환해 전체 트리 구조를 리턴한다.
@Service
@RequiredArgsConstructor
@Transactional
public class CategoryClosureService {
private final CategoryRepository categoryRepository; // 기본 엔티티용
private final CategoryClosureRepository closureRepository; // 클로저 전용(조회/경로 갱신)
// 새 카테고리 등록: parentId 있으면 그 밑에 붙임
public CategoryResponseDto create(String name, Integer parentId) {
Category c = new Category();
c.setName(name);
if (parentId != null) {
// 프록시만 들고옴(여기선 쿼리 안 나감)
c.setParentCategory(categoryRepository.getReferenceById(parentId));
}
categoryRepository.save(c); // INSERT 후 ID 확보
// 클로저 경로 세팅
closureRepository.insertSelf(c.getCategoryId()); // (자기자신,자기자신,0)
if (parentId != null) {
// 부모 체인 전체를 새 노드 조상으로 연결
closureRepository.linkToParentChain(c.getCategoryId(), parentId);
}
return toDto(c);
}
// 노드 이동: nodeId를 newParentId 밑으로
public void move(int nodeId, int newParentId) {
// 부모 포인터만 먼저 교체
Category n = categoryRepository.getReferenceById(nodeId);
n.setParentCategory(categoryRepository.getReferenceById(newParentId));
// 클로저 경로는 싹 갈아끼움: 기존 경로 지우고 -> 새 부모 체인 기준으로 다시 생성
closureRepository.unlinkOldAncestors(nodeId);
closureRepository.linkToNewParentChain(nodeId, newParentId);
// TODO: 사이클 방지 체크(자기 자손 밑으로 못 가게)
// if (closureRepository.findSubtree(nodeId).stream().anyMatch(c -> c.getCategoryId() == newParentId)) throw ...
}
// 서브트리 통째 삭제
public void deleteSubtree(int nodeId) {
// 클로저로 서브트리 한 방 조회(루트 포함)
List<Category> subtree = closureRepository.findSubtree(nodeId);
// 자식부터 지우자(부모 FK 위반 방지)
for (int i = subtree.size() - 1; i >= 0; i--) {
categoryRepository.delete(subtree.get(i));
}
// FK ON DELETE CASCADE면 클로저 테이블은 자동 정리됨
}
// 루트 기준 트리 조회 -> 트리 DTO로 반환
@Transactional(readOnly = true)
public CategoryResponseDto readTree(int rootId) {
// 클로저 덕분에 서브트리 SELECT 1번
List<Category> flat = closureRepository.findSubtree(rootId);
// parentId -> children 맵
Map<Integer, List<Category>> byParent = flat.stream()
.filter(x -> x.getParentCategory() != null) // 루트 제외
.collect(Collectors.groupingBy(x -> x.getParentCategory().getCategoryId()));
// 루트 찾고
Category root = flat.stream()
.filter(x -> x.getCategoryId() == rootId)
.findFirst()
.orElseThrow();
// 재귀로 붙여서 트리 DTO 만든다
return toDtoTree(root, byParent);
}
// --- DTO 매핑 ---
private CategoryResponseDto toDto(Category c) {
return new CategoryResponseDto(
c.getCategoryId(),
c.getName(),
c.isStatus(),
List.of()
);
}
private CategoryResponseDto toDtoTree(Category c, Map<Integer, List<Category>> byParent) {
List<Category> children = byParent.getOrDefault(c.getCategoryId(), List.of());
return new CategoryResponseDto(
c.getCategoryId(),
c.getName(),
c.isStatus(),
children.stream()
.map(ch -> toDtoTree(ch, byParent))
.collect(Collectors.toList())
);
}
}
CategoryClosureRepository
public interface CategoryClosureRepository extends JpaRepository<CategoryClosure, CategoryClosureId> {
// 서브트리 조회 (루트 포함)
@Query("""
select d from Category d
join CategoryClosure cc on cc.descendantId = d.categoryId
where cc.ancestorId = :rootId
order by cc.depth asc, d.name asc
""")
List<Category> findSubtree(@Param("rootId") int rootId);
// 조상 경로 조회 (루트 -> 대상, 대상 자신 포함)
@Query("""
select a from Category a
join CategoryClosure cc on cc.ancestorId = a.categoryId
where cc.descendantId = :nodeId
order by cc.depth asc
""")
List<Category> findAncestors(@Param("nodeId") int nodeId);
// 새 노드: 자기 자신 경로(depth=0)
@Modifying(clearAutomatically = true, flushAutomatically = true)
@Query(value = """
insert into category_closure(ancestor_id, descendant_id, depth)
values (:n, :n, 0)
""", nativeQuery = true)
void insertSelf(@Param("n") int newId);
// 새 노드: 부모 체인의 모든 조상을 연결
@Modifying(clearAutomatically = true, flushAutomatically = true)
@Query(value = """
insert into category_closure(ancestor_id, descendant_id, depth)
select a.ancestor_id, :n, a.depth + 1
from category_closure a
where a.descendant_id = :p
""", nativeQuery = true)
void linkToParentChain(@Param("n") int newId, @Param("p") int parentId);
// 이동: 기존 조상 경로 제거 (자기 자신(depth=0) 보존)
@Modifying(clearAutomatically = true, flushAutomatically = true)
@Query(value = """
delete cc
from category_closure cc
join (
select descendant_id
from category_closure
where ancestor_id = :n
) s on cc.descendant_id = s.descendant_id
join (
select ancestor_id
from category_closure
where descendant_id = :n
and ancestor_id <> :n -- 자기자신 제외
) a on cc.ancestor_id = a.ancestor_id
""", nativeQuery = true)
void unlinkOldAncestors(@Param("n") int nodeId);
// 이동: 새 부모 체인 × 서브트리 연결 (CTE 제거)
@Modifying(clearAutomatically = true, flushAutomatically = true)
@Query(value = """
insert into category_closure(ancestor_id, descendant_id, depth)
select pa.ancestor_id, s.descendant_id, pa.depth + s.depth + 1
from category_closure pa,
(select descendant_id, depth
from category_closure
where ancestor_id = :n) as s
where pa.descendant_id = :np
""", nativeQuery = true)
void linkToNewParentChain(@Param("n") int nodeId, @Param("np") int newParentId);
}
조회 결과
쿼리 한 번으로 부분 카테고리 조회.
* 국내 도서 조회.
Hibernate:
select
c1_0.category_id,
c1_0.name,
c1_0.category_parent_id,
c1_0.status
from
categories c1_0
join
category_closure cc1_0
on cc1_0.descendant_id=c1_0.category_id
where
cc1_0.ancestor_id=?
order by
cc1_0.depth,
c1_0.name
2025-08-12T17:02:13.100+09:00 INFO 54957 --- [task-service] [nio-8500-exec-1] c.n.t.c.log.QueryCountLoggingFilter : STATUS_CODE: 200, METHOD: GET, URL: /task/categories/closure/tree/15, TIME: 0.072초, QUERY_COUNT: 1
@Configuration
@EnableCaching
public class CacheConfig {
@Bean
public RedisCacheManager redisCacheManager(RedisConnectionFactory cf) {
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofMinutes(10)) // 헤더는 자주 안 바뀌니 10분
.disableCachingNullValues()
.serializeValuesWith(
RedisSerializationContext.SerializationPair
.fromSerializer(new GenericJackson2JsonRedisSerializer())); // JSON 저장
return RedisCacheManager.builder(cf).cacheDefaults(config).build();
}
}
(4) 네이티브 쿼리 작성
// 헤더에 들어갈 카테고리용: 루트 + 루트의 직계만
@Query(value = """
select
r.category_id as root_id,
r.name as root_name,
r.status as root_status,
c.category_id as child_id,
c.name as child_name,
c.status as child_status
from categories r
left join category_closure cc
on cc.ancestor_id = r.category_id
and cc.depth = 1
left join categories c
on c.category_id = cc.descendant_id
where r.category_parent_id is null
order by r.name asc, c.name asc
""", nativeQuery = true)
List<Object[]> findHeaderCategories();
(5) CategoryClosureService
@Cacheable/@CachePut/@CacheEvict -> 저장/갱신/삭제
조회 로직 -> @Cacheable, 삭제 로직 -> @CacheEvict 적용.
@Cacheable(cacheNames = "headerCategories", key = "'v1'", sync = true)
@Transactional(readOnly = true)
public List<CategoryResponseDto> getHeaderCategories() {
List<Object[]> rows = closureRepository.findHeaderCategories();
// rootId -> rootDto
Map<Integer, CategoryResponseDto> roots = new LinkedHashMap<>();
for (Object[] r : rows) {
Integer rootId = (Integer) r[0];
String rootName = (String) r[1];
Boolean rootStatus = (Boolean) r[2]; // status가 tinyint면 Boolean으로 매핑됨
Integer childId = (Integer) r[3]; // 자식 없으면 null
String childName = (String) r[4];
Boolean childStatus= (Boolean) r[5];
// 루트 DTO 없으면 만들기
CategoryResponseDto rootDto = roots.get(rootId);
if (rootDto == null) {
rootDto = new CategoryResponseDto(rootId, rootName, rootStatus != null && rootStatus, new ArrayList<>());
roots.put(rootId, rootDto);
}
// 자식 있으면 붙이기 (직계만)
if (childId != null) {
CategoryResponseDto childDto =
new CategoryResponseDto(childId, childName, childStatus != null && childStatus, new ArrayList<>());
rootDto.getChildren().add(childDto); // 필드명이 children/subCategories 중 뭐든 맞춰서 사용
}
}
return new ArrayList<>(roots.values());
}
DELIMITER $$
DROP PROCEDURE IF EXISTS seed_categories$$
CREATE PROCEDURE seed_categories(
IN p_roots INT, -- 루트 개수
IN p_children_per_root INT, -- 루트당 자식 수
IN p_grand_per_child INT -- 자식당 손자 수
)
BEGIN
DECLARE r INT DEFAULT 1;
DECLARE c INT;
DECLARE g INT;
DECLARE v_root_id INT;
DECLARE v_child_id INT;
WHILE r <= p_roots DO
CALL add_category(CONCAT('Root ', r), NULL);
SET v_root_id = LAST_INSERT_ID();
SET c = 1;
WHILE c <= p_children_per_root DO
CALL add_category(CONCAT('Root ', r, ' - Child ', c), v_root_id);
SET v_child_id = LAST_INSERT_ID();
SET g = 1;
WHILE g <= p_grand_per_child DO
CALL add_category(CONCAT('Root ', r, ' - Child ', c, ' - Grandchild ', g), v_child_id);
-- 손자 id는 필요 없으니 LAST_INSERT_ID() 저장 생략
SET g = g + 1;
END WHILE;
SET c = c + 1;
END WHILE;
SET r = r + 1;
END WHILE;
END$$
DELIMITER ;
(2) 시간 측정
AOP @TimeTrace로 uri, accept, timeMs 로그를 남긴다.
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TimeTrace {
}
@Log4j2
@Component
@Aspect
public class TimeTraceAspect {
@Pointcut("@annotation(com.onebook.frontapi.aop.TimeTrace)")
private void timeTracePointcut() {
}
@Around("timeTracePointcut()")
public Object traceTime(ProceedingJoinPoint joinPoint) throws Throwable {
StopWatch stopWatch = new StopWatch();
try {
stopWatch.start();
return joinPoint.proceed(); // 실제 타겟 호출
} finally {
stopWatch.stop();
String uri = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest().getRequestURI();
log.info("{} uri={} Total time = {}s",
joinPoint.getSignature().toShortString(),
uri,
stopWatch.getTotalTimeSeconds());
}
}
}
SELECT category_id, name, category_parent_id, status
FROM categories
WHERE category_parent_id IS NULL;
2. 각 루트의 직계 자식 조회 (루트마다 2쿼리)
자식 목록
루트 상세(부모 조인 포함 1건)
SELECT category_id, name, category_parent_id, status
FROM categories
WHERE category_parent_id = ?;
SELECT c.category_id, c.name, pc.category_id, pc.name, pc.category_parent_id, pc.status, c.status
FROM categories c
LEFT JOIN categories pc ON pc.category_id = c.category_parent_id
WHERE c.category_id = ?;
3. API 실행 시간
평균 0.0536s (5회 측정)
025-08-14T16:35:54.604+09:00 INFO 71062 --- [front-service] [nio-8100-exec-1] c.onebook.frontapi.aop.TimeTraceAspect : CategoryService.getTopCategories() uri=/ Total time = 0.079048667s
2025-08-14T16:36:42.744+09:00 INFO 71062 --- [front-service] [nio-8100-exec-1] c.onebook.frontapi.aop.TimeTraceAspect : CategoryService.getTopCategories() uri=/ Total time = 0.083739125s
2025-08-14T16:37:02.581+09:00 INFO 71062 --- [front-service] [nio-8100-exec-5] c.onebook.frontapi.aop.TimeTraceAspect : CategoryService.getTopCategories() uri=/ Total time = 0.05020075s
2025-08-14T16:37:51.664+09:00 INFO 71062 --- [front-service] [nio-8100-exec-4] c.onebook.frontapi.aop.TimeTraceAspect : CategoryService.getTopCategories() uri=/ Total time = 0.027883458s
2025-08-14T16:38:09.198+09:00 INFO 71062 --- [front-service] [nio-8100-exec-5] c.onebook.frontapi.aop.TimeTraceAspect : CategoryService.getTopCategories() uri=/ Total time = 0.035098333s
2025-08-14T16:38:24.052+09:00 INFO 71062 --- [front-service] [nio-8100-exec-8] c.onebook.frontapi.aop.TimeTraceAspect : CategoryService.getTopCategories() uri=/ Total time = 0.043667375s
Hibernate:
select
r.category_id as root_id,
r.name as root_name,
r.status as root_status,
c.category_id as child_id,
c.name as child_name,
c.status as child_status
from
categories r
left join
category_closure cc
on cc.ancestor_id = r.category_id
and cc.depth = 1
left join
categories c
on c.category_id = cc.descendant_id
where
r.category_parent_id is null
order by
r.name asc,
c.name asc
2025-08-15T12:53:08.032+09:00 INFO 76506 --- [task-service] [nio-8500-exec-1] c.n.t.c.log.QueryCountLoggingFilter : STATUS_CODE: 200, METHOD: GET, URL: /task/categories/header, TIME: 0.089초, QUERY_COUNT: 1
2025-08-15T12:58:00.315+09:00 INFO 76648 --- [front-service] [nio-8100-exec-1] c.onebook.frontapi.aop.TimeTraceAspect : CategoryService.getTopCategories() uri=/ Total time = 0.150993208s
캐싱 후: 평균 0.0263s (5회 측정)
2025-08-15T12:58:30.129+09:00 INFO 76648 --- [front-service] [nio-8100-exec-3] c.onebook.frontapi.aop.TimeTraceAspect : CategoryService.getTopCategories() uri=/ Total time = 0.037764917s
2025-08-15T12:59:02.733+09:00 INFO 76648 --- [front-service] [nio-8100-exec-5] c.onebook.frontapi.aop.TimeTraceAspect : CategoryService.getTopCategories() uri=/ Total time = 0.040314292s
2025-08-15T13:00:57.152+09:00 INFO 76648 --- [front-service] [io-8100-exec-10] c.onebook.frontapi.aop.TimeTraceAspect : CategoryService.getTopCategories() uri=/ Total time = 0.006964708s
2025-08-15T13:01:50.015+09:00 INFO 76648 --- [front-service] [nio-8100-exec-7] c.onebook.frontapi.aop.TimeTraceAspect : CategoryService.getTopCategories() uri=/ Total time = 0.028782916s
2025-08-15T13:02:43.297+09:00 INFO 76648 --- [front-service] [nio-8100-exec-2] c.onebook.frontapi.aop.TimeTraceAspect : CategoryService.getTopCategories() uri=/ Total time = 0.018001541s
(3) 결과
카테고리 조회 시 N+1 문제 -> 쿼리 1번으로 조회
Redis 캐싱을 활용하여 최초 1회만 DB 쿼리 발생, 이후엔 DB 쿼리 0회(캐시에서 바로 반환)
