[Spring] Layered Architecture

Layered Architecture
복잡한 소프트웨어를 구조적으로 나눠서 유지보수와 확장, 테스트, 협업을 더 쉽게 하려고 만들어진 설계 방식이다.

코드 엉킴(Spaghetti code)문제를 해결하기 위해 입력/처리/저장/출력 등을 각 단계로 역할별로 분리하여 구성한다. 
이점으로는 아래와 같다
1) 입력,처리, 출력 로직을 나눠서 복잡도를 낮춤
2) 기능 추가나 수정 시 영향 범위가 줄어듦
3) 각 레이어 단위로 단위 테스트가 가능함
4) 공통 로직을 Service나 Repository로 분리해서 재사용 가능함
5) UI, DB 등 특정 레이어 기술을 바꾸기 쉬움(예: JDBC->JPA)

참고로 데이터 흐름은 아래와 같다.
클라이언트 ↔ (HTTP) ↔ Controller→ Service→ Repository→ Database

 

 

이해를 돕기 위한 예시

 

레스토랑 주문

 

[역할에 따른 분류]
고객
웨이터 - Controller
주방장 - Service
창고 - Repository
접시/박스 - Response

 

1. 고객, 웨이터, 주방장, 창고, 접시/박스가 존재한다.
2. 고객이 "피자 한 판 주세요" 주문. ->웹 브라우저,앱에서 HTTP요청
3. 주문서를 받고 주방장에게 전달 -> @Controller/ @RestController
4. 레시피대로 피자를 만들고 소스, 토핑을 준비한다 -> 비즈니스 로직(검증, 계산, 트랜잭션)
5. 밀가루, 치즈 같은 재료를 꺼내는 곳 -> DB에서 Entity 꺼내기, 저장하기
6. 손님에게 음식을 담아 내오는 그릇, 포장박스  -> View템플릿 렌더링 또는 JSON응답

 

위 순서를 기반으로 더 자세히 빗대어 보겠다.

 

1. 고객이 주문서 (Request DTO)를 작성

{ "menu": "피자", "size": "L", "toppings": ["치즈","페퍼로니"] }

 

2. 웨이터(Controller)가 주문서를 받음

매장 식사용이면 그릇에 담아줌 -> 뷰 반환

포장 주문이면 박스에 담아줌-> JSON반환

 

3. 웨이터가 주방장(Service)에게

"이 손님 피자 만들어주세요"

 

4. 주방장(Service)은

재료가 충분한지 확인(Validation)

창고(Repository)에서 밀가루와 치즈를 꺼내고

레시피(비즈니스 로직)에 따라 피자 완성.

만들어진 피자를 다시 웨이터에게 전달한다.

 

5. 매장 식사면 템플릿 이름을 알려주거나 

포장 주문이면 JSON으로 포장 박스에 실어 손님에게 돌려준다.

 

 

위 예시를 기반으로 코드에 대입해 보겠다.

 

 

---

// 1) 웨이터(Controller)
@RestController              // “포장 주문 전문” (@Controller + @ResponseBody)
@RequestMapping("/orders")    // /orders/** 기본 경로
public class OrderController {
    private final OrderService svc;
    public OrderController(OrderService svc) { this.svc = svc; }

    @PostMapping                // 손님이 POST /orders 로 주문서 전송
    public OrderResponseDto order(
        @RequestBody OrderRequestDto req  // JSON 주문서 → OrderRequestDto
    ) {
        return svc.placeOrder(req);      // 주방장에게 주문서 건네고 결과 받음
    }
}

 

// 2) 주방장(Service)
@Service
@Transactional
public class OrderService {
    private final IngredientRepo repo;
    public OrderService(IngredientRepo repo) { this.repo = repo; }

    public OrderResponseDto placeOrder(OrderRequestDto req) {
        // 2-1) 재료 창고에서 필요한 재료 꺼내기
        Ingredient dough = repo.findByName("밀가루").get();
        // 2-2) 레시피대로 피자 만들기(검증·계산 등)
        Pizza pizza = new Pizza(dough, req.getToppings());
        // 2-3) 피자 완성 → 손님에게 전달할 DTO 생성
        return new OrderResponseDto("주문 완료!", pizza.getSize());
    }
}

 

// 3) 창고(Repository)
@Repository
public interface IngredientRepo extends JpaRepository<Ingredient, Long> {
    Optional<Ingredient> findByName(String name);
}

 

이때 요점으로는

1. Controller(웨이터)

주문서 받기 -> Service에 전달 -> 결과 받아서 손님에게 돌려줌

@RestController면 자동으로 JSON포장 박스에 담아줌

 

2. Service(주방장)

재료 확인, 검증, 조리(비즈니스 로직) -> 안전하게 트랜잭션 처리

 

3. Repository (창고)

DB에서 Entity(재료) 꺼내주기, 보관하기

 

4. DTO vs Entity

DTO: 주문서, 박스(Controller <-> Service)

Entity: 창고 속 실제 재료(Service <-> Repository)

 

---

 

 

이해가 됐으니 이제 본격적으로 이어가 보겠다.

전체 아키텍처 개요

클라이언트 ↔ (HTTP) ↔ Controller → Service → Repository → Database

구현 로드맵 (단계별 순서)

1) DTO 정의 (Controller ↔ Service)
2) Entity 정의 (Service ↔ Repository)
3) Repository 인터페이스 작성
4) Service 로직 구현
5) Controller 엔드포인트 구현

 

위 구현 로드맴에 따라 순서대로 설명하고자 한다.

 

1) DTO 정의 (Controller ↔ Service)

 

// src/main/java/com/example/demo/dto/OrderRequestDto.java
package com.example.demo.dto;

/**
 * 클라이언트(고객)가 서버에 보내는 주문서 DTO
 */
public record OrderRequestDto(
    String menu,         // 주문할 상품명, e.g. "피자"
    String size,         // 메뉴 크기, e.g. "L"
    List<String> toppings // 추가 토핑 목록
) {}

 

// src/main/java/com/example/demo/dto/OrderResponseDto.java
package com.example.demo.dto;

/**
 * 서버(주방)가 클라이언트에게 돌려주는 응답 DTO
 */
public record OrderResponseDto(
    String status,       // 처리 결과 메시지, e.g. "주문 완료!"
    String size          // 완성된 피자 크기 확인용
) {}

 

• OrderRequestDto: Controller가 클라이언트로부터 받은 JSON을 매핑
• OrderResponseDto: Service 결과를 Controller가 JSON으로 반환

 

2) Entity 정의 (Service ↔ Repository)

// src/main/java/com/example/demo/entity/Ingredient.java
package com.example.demo.entity;

import jakarta.persistence.*;

/**
 * 창고(Repository)에서 관리하는 실제 재료 엔티티
 * - DB의 ingredients 테이블과 1:1 매핑됨
 */
@Entity
public class Ingredient {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;            // PK

    private String name;        // 재료명, 예: "밀가루", "치즈"
    private int quantity;       // 재고 수량

    // JPA 스펙상 반드시 필요한 기본 생성자 (protected 권장)
    protected Ingredient() {}

    /**
     * 신규 재고 추가·생성용 생성자
     * @param name 재료명
     * @param quantity 초기 재고 수량
     */
    public Ingredient(String name, int quantity) {
        this.name = name;
        this.quantity = quantity;
    }

    // ————— 접근자 메서드 —————
    public Long getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public int getQuantity() {
        return quantity;
    }

    // ————— 도메인 로직 메서드 —————
    /**
     * 재고를 차감할 때 사용하는 메서드
     * @param amount 차감할 수량
     * @throws IllegalArgumentException 재고가 부족하면 예외 발생
     */
    public void decrease(int amount) {
        if (amount < 0 || amount > this.quantity) {
            throw new IllegalArgumentException("재고가 부족합니다. 현재 수량: " + this.quantity);
        }
        this.quantity -= amount;
    }
}

 

• 이 클래스는 Service에서 꺼내온 Ingredient 객체를 가지고
  실제 재고를 검증·차감하는 비즈니스 로직(도메인 메서드)을 포함한다.
• JPA 어노테이션(@Entity, @Id, @GeneratedValue)으로
  DB 테이블 매핑 정보를 선언한다.

3) Repository 인터페이스 작성

// src/main/java/com/example/demo/repository/IngredientRepository.java
package com.example.demo.repository;

import com.example.demo.entity.Ingredient;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.Optional;

/**
 * 창고(Repository) 역할을 수행하는 인터페이스
 * - JpaRepository를 확장해 기본 CRUD 기능 제공
 * - 필요한 경우 메서드 시그니처만 선언하면 Spring Data JPA가 구현체 자동 생성
 */
@Repository
public interface IngredientRepository extends JpaRepository<Ingredient, Long> {
    /**
     * 재료 이름으로 검색
     * @param name 재료명
     * @return 재료 엔티티 Optional
     */
    Optional<Ingredient> findByName(String name);
}

 

• JpaRepository<Ingredient, Long>
  → save(), findById(), findAll(), delete() 등 CRUD 메서드 기본 제공
• findByName(String) 시그니처만 선언하면, Spring Data JPA가 내부적으로 SELECT * FROM ingredient WHERE name = ? 쿼리를 생성해 준다.

4) Service 로직 구현

// src/main/java/com/example/demo/service/OrderService.java
package com.example.demo.service;

import com.example.demo.dto.OrderRequestDto;
import com.example.demo.dto.OrderResponseDto;
import com.example.demo.entity.Ingredient;
import com.example.demo.repository.IngredientRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * 주방장(Service) 역할을 하는 클래스
 * - @Service: 스프링 빈으로 등록
 * - @Transactional: 메서드 전체를 하나의 트랜잭션으로 묶어,
 *                   중간에 예외 발생 시 자동 롤백 처리
 */
@Service
@Transactional
public class OrderService {

    private final IngredientRepository ingredientRepository;

    // 생성자 주입: IngredientRepository 빈이 자동 주입됨
    public OrderService(IngredientRepository ingredientRepository) {
        this.ingredientRepository = ingredientRepository;
    }

    /**
     * 주문 처리 비즈니스 로직
     * 1) 도우 재료 조회 및 재고 차감
     * 2) 토핑 재료 조회 및 재고 차감
     * 3) 주문 사이즈 확인 (추가 계산·할인 로직 등 확장 가능)
     * 4) 주문 완료 메시지 + 사이즈를 담은 응답 DTO 반환
     */
    public OrderResponseDto placeOrder(OrderRequestDto request) {
        // 1) 도우 재료(밀가루) 조회 → 예외 처리 → 재고 차감
        Ingredient dough = ingredientRepository.findByName("밀가루")
            .orElseThrow(() -> new IllegalArgumentException("도우 재료가 없습니다: 밀가루"));
        dough.decrease(1);
        ingredientRepository.save(dough);

        // 2) 요청된 각 토핑마다 동일 처리
        for (String toppingName : request.toppings()) {
            Ingredient topping = ingredientRepository.findByName(toppingName)
                .orElseThrow(() -> new IllegalArgumentException("토핑 재료가 없습니다: " + toppingName));
            topping.decrease(1);
            ingredientRepository.save(topping);
        }

        // 3) 주문 크기 확인 (여기에 추가 로직을 붙일 수 있음)
        String size = request.size();

        // 4) 최종 응답 DTO 생성
        return new OrderResponseDto(
            "주문 완료! " + size + " 사이즈 피자 준비되었습니다.",
            size
        );
    }
}

 

• @Service: 비즈니스 로직 계층(Service Layer)을 나타냄.
• @Transactional: 메서드가 하나의 트랜잭션으로 실행되며, 중간에 예외가 터지면 모든 DB 변경을 롤백.
• ingredientRepository.findByName(...): 재고 조회 → 없으면 IllegalArgumentException 발생.
• decrease(1): Ingredient 엔티티의 도메인 메서드로 재고 차감, 부족 시 예외 발생.
• ingredientRepository.save(...): 변경된 재고를 DB에 반영.
• 반복문 안에서 요청된 모든 토핑도 동일하게 처리하며, 이후 OrderResponseDto를 만들어 Controller에 반환한다.

5) Controller 엔드포인트 구현

// src/main/java/com/example/demo/controller/OrderController.java
package com.example.demo.controller;

import com.example.demo.dto.OrderRequestDto;
import com.example.demo.dto.OrderResponseDto;
import com.example.demo.service.OrderService;
import org.springframework.web.bind.annotation.*;

/**
 * 웨이터(Controller) 역할을 수행하는 클래스
 * - @RestController: JSON API 전용 컨트롤러
 * - @RequestMapping("/orders"): 공통 URL 기본 경로 설정
 */
@RestController
@RequestMapping("/orders")
public class OrderController {

    private final OrderService orderService;

    // 생성자 주입: OrderService 빈이 자동으로 주입됨
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }

    /**
     * 주문 생성 엔드포인트
     * POST /orders
     * - @RequestBody: 들어온 JSON 요청 바디를 OrderRequestDto로 매핑
     * - 반환값 OrderResponseDto는 자동으로 JSON 직렬화되어 응답 바디에 담김
     */
    @PostMapping
    public OrderResponseDto createOrder(
        @RequestBody OrderRequestDto requestDto
    ) {
        // Service 계층에 주문 처리 로직 위임 → 결과 DTO 반환
        return orderService.placeOrder(requestDto);
    }

    /**
     * (선택) 전체 재고 조회 예시 엔드포인트
     * GET /orders/ingredients
     * - 요청 없이 호출 시, Service에서 재고 목록을 조회해 올 수 있음
     * - 아래 예시는 Optional; 반드시 필요하지는 않음
     */
    // @GetMapping("/ingredients")
    // public List<IngredientDto> getAllIngredients() {
    //     return orderService.listAllIngredients();
    // }
}

 

 

• @RestController
  → @Controller + @ResponseBody
• @RequestMapping("/orders")
  → 이 클래스 내부의 모든 메서드는 /orders 경로를 기준으로 매핑
• @PostMapping
  → HTTP POST 요청(POST /orders)을 처리
• @RequestBody OrderRequestDto requestDto
  → 클라이언트가 보낸 JSON 주문서가 OrderRequestDto로 자동 변환
• return orderService.placeOrder(requestDto)
  → Service에서 처리된 OrderResponseDto를 JSON으로 응답

 

 

Postman(또는 curl)으로 테스트

 

주문 생성 (POST /orders)

• URL: http://localhost:8080/orders
• Method: POST
• Header: Content-Type: application/json
• Body (raw JSON):

 

{
  "menu": "피자",
  "size": "L",
  "toppings": ["치즈", "페퍼로니"]
}

 

예상 응답 (200 OK):

 

{
  "status": "주문 완료! L 사이즈 피자 준비되었습니다.",
  "size": "L"
}