Spring 03: IoC/DI 원리와 Spring Container

문제 상황: 결제 서비스 변경

// IoC 없이 직접 생성하는 경우
public class OrderService {
    // TossPaymentService를 직접 생성
    private PaymentService payment = new TossPaymentService();
}

public class SubscriptionService {
    // 여기서도 TossPaymentService를 직접 생성
    private PaymentService payment = new TossPaymentService();
}

public class RefundService {
    // 여기서도...
    private PaymentService payment = new TossPaymentService();
}

// 문제: TossPaymentService -> KakaoPayService로 변경하려면?
// 모든 클래스를 찾아서 수정해야 함!

// IoC를 사용하면?
@Configuration
public class PaymentConfig {
    @Bean
    public PaymentService paymentService() {
        // 여기만 수정하면 모든 곳에 적용됨
        return new KakaoPayService();
    }
}

@Service
public class OrderService {
    
    // final로 선언 - 불변성 보장
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    private final EventPublisher eventPublisher;
    
    // 생성자 주입
    // 생성자가 하나면 @Autowired 생략 가능 (Spring 4.3+)
    public OrderService(
            OrderRepository orderRepository,
            PaymentService paymentService,
            InventoryService inventoryService,
            EventPublisher eventPublisher) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
        this.inventoryService = inventoryService;
        this.eventPublisher = eventPublisher;
    }
    
    public Order createOrder(CreateOrderCommand command) {
        // 모든 의존성이 주입된 상태에서 비즈니스 로직 실행
        inventoryService.checkStock(command.getItems());
        Order order = Order.create(command);
        orderRepository.save(order);
        paymentService.process(order);
        eventPublisher.publish(new OrderCreatedEvent(order));
        return order;
    }
}

// Lombok 사용 시 더 간결하게
@Service
@RequiredArgsConstructor  // final 필드에 대한 생성자 자동 생성
public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    private final EventPublisher eventPublisher;
    
    // 생성자가 자동 생성됨
    // 비즈니스 로직만 작성하면 됨
}

@Service
public class NotificationService {
    
    // final이 아님 - 변경 가능
    private EmailSender emailSender;
    private SmsSender smsSender;
    
    // Setter 주입
    @Autowired
    public void setEmailSender(EmailSender emailSender) {
        this.emailSender = emailSender;
    }
    
    // 선택적 의존성 - 없어도 됨
    @Autowired(required = false)
    public void setSmsSender(SmsSender smsSender) {
        this.smsSender = smsSender;
    }
    
    public void notify(String message) {
        // emailSender는 필수
        emailSender.send(message);
        
        // smsSender는 선택적 - null 체크 필요
        if (smsSender != null) {
            smsSender.send(message);
        }
    }
}

// 선택적 의존성의 더 나은 처리 방법
@Service
public class NotificationService {
    
    private final EmailSender emailSender;
    private final Optional<SmsSender> smsSender;
    
    public NotificationService(
            EmailSender emailSender,
            Optional<SmsSender> smsSender) {  // Optional로 선택적 의존성
        this.emailSender = emailSender;
        this.smsSender = smsSender;
    }
    
    public void notify(String message) {
        emailSender.send(message);
        smsSender.ifPresent(sender -> sender.send(message));
    }
}

@Service
public class OrderService {
    
    @Autowired  // 필드에 직접 주입
    private OrderRepository orderRepository;
    
    @Autowired
    private PaymentService paymentService;
    
    @Autowired
    private InventoryService inventoryService;
    
    // 생성자 없음 - Spring이 리플렉션으로 주입
}

// 같은 인터페이스의 여러 구현체
public interface PaymentGateway {
    PaymentResult process(PaymentRequest request);
}

@Component
@Primary  // 기본으로 선택됨
public class TossPaymentGateway implements PaymentGateway {
    @Override
    public PaymentResult process(PaymentRequest request) {
        // Toss 결제 처리
    }
}

@Component("kakao")  // Bean 이름 지정
public class KakaoPayGateway implements PaymentGateway {
    @Override
    public PaymentResult process(PaymentRequest request) {
        // KakaoPay 결제 처리
    }
}

@Component("naver")
public class NaverPayGateway implements PaymentGateway {
    @Override
    public PaymentResult process(PaymentRequest request) {
        // NaverPay 결제 처리
    }
}

// 사용하는 곳
@Service
public class PaymentService {
    
    // 방법 1: @Primary가 붙은 TossPaymentGateway가 주입됨
    public PaymentService(PaymentGateway gateway) {
        this.gateway = gateway;
    }
    
    // 방법 2: @Qualifier로 특정 구현체 지정
    public PaymentService(@Qualifier("kakao") PaymentGateway gateway) {
        this.gateway = gateway;
    }
    
    // 방법 3: 모든 구현체를 List로 주입
    private final List<PaymentGateway> gateways;
    
    public PaymentService(List<PaymentGateway> gateways) {
        this.gateways = gateways;  // 3개 모두 주입됨
    }
    
    // 방법 4: Map으로 주입 (Bean 이름이 key)
    private final Map<String, PaymentGateway> gatewayMap;
    
    public PaymentService(Map<String, PaymentGateway> gatewayMap) {
        this.gatewayMap = gatewayMap;
        // {"tossPaymentGateway": Toss, "kakao": Kakao, "naver": Naver}
    }
    
    public PaymentResult process(String gatewayName, PaymentRequest request) {
        PaymentGateway gateway = gatewayMap.get(gatewayName);
        if (gateway == null) {
            throw new IllegalArgumentException("Unknown gateway: " + gatewayName);
        }
        return gateway.process(request);
    }
}

Container의 역할

방법 1: 컴포넌트 스캔 (@Component)

// 스테레오타입 어노테이션 - 모두 @Component의 특수화
@Component      // 일반 컴포넌트
@Service        // 비즈니스 로직 계층
@Repository     // 데이터 접근 계층 (예외 변환 기능 포함)
@Controller     // 웹 MVC 컨트롤러
@RestController // REST API 컨트롤러 (@Controller + @ResponseBody)
@Configuration  // 설정 클래스

// 예시
@Service
public class OrderService {
    // Spring이 자동으로 Bean 등록
    // Bean 이름: "orderService" (클래스명의 첫 글자를 소문자로)
}

@Repository
public class JpaOrderRepository implements OrderRepository {
    // Spring이 자동으로 Bean 등록
    // + DataAccessException으로 예외 변환
}

// 컴포넌트 스캔 범위 설정
@SpringBootApplication
@ComponentScan(basePackages = "com.shop")  // 기본값: 이 클래스의 패키지
public class ShopApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShopApplication.class, args);
    }
}

방법 2: Java Config (@Bean)

@Configuration
public class AppConfig {
    
    // 메서드 이름이 Bean 이름이 됨
    @Bean
    public OrderService orderService(OrderRepository repository) {
        return new OrderService(repository);
    }
    
    @Bean
    public OrderRepository orderRepository(EntityManager em) {
        return new JpaOrderRepository(em);
    }
    
    // 외부 라이브러리 클래스를 Bean으로 등록
    // @Component를 붙일 수 없는 클래스에 사용
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplateBuilder()
            .setConnectTimeout(Duration.ofSeconds(5))
            .setReadTimeout(Duration.ofSeconds(10))
            .build();
    }
    
    @Bean
    public ObjectMapper objectMapper() {
        return new ObjectMapper()
            .registerModule(new JavaTimeModule())
            .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    }
    
    // 조건부 Bean 등록
    @Bean
    @ConditionalOnProperty(name = "cache.enabled", havingValue = "true")
    public CacheManager cacheManager() {
        return new CaffeineCacheManager();
    }
    
    // Profile별 Bean 등록
    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .build();
    }
    
    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl("jdbc:mysql://prod-db:3306/shop");
        return ds;
    }
}

Scope 사용 예시

// Singleton (기본값) - 대부분의 Bean
@Service
public class OrderService {
    // Container에 하나만 존재
    // 상태를 가지면 안 됨 (Stateless)
}

// Prototype - 매번 새로운 인스턴스
@Component
@Scope("prototype")
public class ShoppingCart {
    private List<CartItem> items = new ArrayList<>();
    
    public void addItem(CartItem item) {
        items.add(item);
    }
}

// Request Scope - HTTP 요청마다 새로운 인스턴스
@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, 
       proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestContext {
    private String requestId;
    private LocalDateTime requestTime;
    private String userId;
    
    @PostConstruct
    public void init() {
        this.requestId = UUID.randomUUID().toString();
        this.requestTime = LocalDateTime.now();
    }
}

// Singleton Bean에서 Prototype Bean 사용 시 주의
@Service
public class OrderService {
    
    // 잘못된 방법 - ShoppingCart가 Singleton처럼 동작
    // private final ShoppingCart cart;
    
    // 올바른 방법 1: ObjectProvider 사용
    private final ObjectProvider<ShoppingCart> cartProvider;
    
    public void addToCart(CartItem item) {
        ShoppingCart cart = cartProvider.getObject();  // 매번 새로운 인스턴스
        cart.addItem(item);
    }
    
    // 올바른 방법 2: ApplicationContext 사용
    private final ApplicationContext context;
    
    public void addToCart2(CartItem item) {
        ShoppingCart cart = context.getBean(ShoppingCart.class);
        cart.addItem(item);
    }
}

방법 1: @PostConstruct / @PreDestroy (권장)

@Service
@Slf4j
public class CacheService {
    
    private final RedisTemplate<String, Object> redisTemplate;
    private LoadingCache<String, Product> localCache;
    
    public CacheService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
        // 생성자에서는 아직 다른 Bean이 준비 안 됐을 수 있음
        // 복잡한 초기화는 @PostConstruct에서
    }
    
    @PostConstruct  // 의존성 주입 완료 후 호출
    public void init() {
        log.info("CacheService 초기화 시작");
        
        // 로컬 캐시 설정
        this.localCache = Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(Duration.ofMinutes(10))
            .recordStats()
            .build(this::loadFromRedis);
        
        // 캐시 워밍 (자주 조회되는 데이터 미리 로드)
        warmUpCache();
        
        log.info("CacheService 초기화 완료");
    }
    
    @PreDestroy  // Container 종료 전 호출
    public void cleanup() {
        log.info("CacheService 정리 시작");
        
        // 캐시 통계 로깅
        CacheStats stats = localCache.stats();
        log.info("캐시 통계 - hitRate: {}, evictionCount: {}", 
                 stats.hitRate(), stats.evictionCount());
        
        // 리소스 정리
        localCache.invalidateAll();
        
        log.info("CacheService 정리 완료");
    }
    
    private Product loadFromRedis(String key) {
        return (Product) redisTemplate.opsForValue().get(key);
    }
    
    private void warmUpCache() {
        // 인기 상품 미리 로드
        List<String> popularKeys = List.of("product:1", "product:2", "product:3");
        localCache.getAll(popularKeys);
    }
}

방법 2: @Bean의 initMethod / destroyMethod

@Configuration
public class DataSourceConfig {
    
    @Bean(initMethod = "init", destroyMethod = "close")
    public HikariDataSource dataSource(DataSourceProperties properties) {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl(properties.getUrl());
        ds.setUsername(properties.getUsername());
        ds.setPassword(properties.getPassword());
        ds.setMaximumPoolSize(10);
        ds.setMinimumIdle(5);
        ds.setConnectionTimeout(30000);
        return ds;
        // init() 메서드가 자동 호출됨
        // 애플리케이션 종료 시 close() 메서드가 자동 호출됨
    }
}

// 외부 라이브러리 클래스에 @PostConstruct를 붙일 수 없을 때 유용
public class ExternalLibraryClient {
    public void init() {
        // 연결 설정
    }
    
    public void close() {
        // 연결 종료
    }
}

방법 3: InitializingBean / DisposableBean 인터페이스

@Component
public class ConnectionPool implements InitializingBean, DisposableBean {
    
    private List<Connection> connections;
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // 초기화 로직
        connections = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            connections.add(createConnection());
        }
    }
    
    @Override
    public void destroy() throws Exception {
        // 정리 로직
        for (Connection conn : connections) {
            conn.close();
        }
    }
    
    private Connection createConnection() {
        // 연결 생성
        return null;
    }
}

// 참고: 이 방식은 Spring에 의존하게 되므로
// @PostConstruct/@PreDestroy 사용을 권장

@Service
@RequiredArgsConstructor
@Slf4j
public class ProductCacheService {
    
    private final ProductRepository productRepository;
    private final CategoryRepository categoryRepository;
    
    private Map<Long, Product> productCache;
    private Map<Long, List<Product>> categoryProductCache;
    
    @PostConstruct
    public void warmUpCache() {
        log.info("상품 캐시 워밍 시작...");
        long startTime = System.currentTimeMillis();
        
        // 1. 인기 상품 캐시
        List<Product> popularProducts = productRepository
            .findTop100ByOrderBySalesCountDesc();
        
        this.productCache = popularProducts.stream()
            .collect(Collectors.toConcurrentMap(
                Product::getId,
                Function.identity()
            ));
        
        log.info("인기 상품 {}개 캐시 완료", productCache.size());
        
        // 2. 카테고리별 상품 캐시
        List<Category> mainCategories = categoryRepository.findMainCategories();
        
        this.categoryProductCache = new ConcurrentHashMap<>();
        for (Category category : mainCategories) {
            List<Product> products = productRepository
                .findTop20ByCategoryOrderBySalesCountDesc(category);
            categoryProductCache.put(category.getId(), products);
        }
        
        log.info("카테고리 {}개의 상품 캐시 완료", categoryProductCache.size());
        
        long elapsed = System.currentTimeMillis() - startTime;
        log.info("상품 캐시 워밍 완료 - 소요시간: {}ms", elapsed);
    }
    
    public Optional<Product> getFromCache(Long productId) {
        return Optional.ofNullable(productCache.get(productId));
    }
    
    public List<Product> getProductsByCategory(Long categoryId) {
        return categoryProductCache.getOrDefault(categoryId, List.of());
    }
    
    // 캐시 갱신 (스케줄러에서 호출)
    @Scheduled(fixedRate = 300000)  // 5분마다
    public void refreshCache() {
        log.info("캐시 갱신 시작");
        warmUpCache();
    }
    
    @PreDestroy
    public void clearCache() {
        log.info("캐시 정리");
        productCache.clear();
        categoryProductCache.clear();
    }
}

// 여러 초기화 방법을 함께 사용할 경우 실행 순서
@Component
public class MultiCallbackBean implements InitializingBean, DisposableBean {
    
    // 1. 생성자
    public MultiCallbackBean() {
        System.out.println("1. 생성자");
    }
    
    // 2. @PostConstruct
    @PostConstruct
    public void postConstruct() {
        System.out.println("2. @PostConstruct");
    }
    
    // 3. InitializingBean.afterPropertiesSet()
    @Override
    public void afterPropertiesSet() {
        System.out.println("3. afterPropertiesSet");
    }
    
    // 4. @Bean(initMethod = "customInit")
    public void customInit() {
        System.out.println("4. customInit");
    }
    
    // 소멸 순서도 동일: @PreDestroy -> destroy() -> destroyMethod
}

E-commerce 계층 구조

// Controller -> Service -> Repository 계층 구조

// 1. Controller 계층
@RestController
@RequestMapping("/api/orders")
@RequiredArgsConstructor
public class OrderController {
    
    private final OrderService orderService;
    private final OrderQueryService orderQueryService;  // CQRS 패턴
    
    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(
            @Valid @RequestBody CreateOrderRequest request,
            @AuthenticationPrincipal UserDetails user) {
        
        OrderResult result = orderService.createOrder(
            user.getUsername(), 
            request.toCommand()
        );
        
        return ResponseEntity
            .created(URI.create("/api/orders/" + result.getOrderId()))
            .body(OrderResponse.from(result));
    }
    
    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDetailResponse> getOrder(
            @PathVariable Long orderId,
            @AuthenticationPrincipal UserDetails user) {
        
        return orderQueryService.findOrderDetail(orderId, user.getUsername())
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }
}

// 2. Service 계층
@Service
@RequiredArgsConstructor
@Transactional
public class OrderService {
    
    private final OrderRepository orderRepository;
    private final ProductRepository productRepository;
    private final MemberRepository memberRepository;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    private final ApplicationEventPublisher eventPublisher;
    
    public OrderResult createOrder(String username, CreateOrderCommand command) {
        // 1. 회원 조회
        Member member = memberRepository.findByUsername(username)
            .orElseThrow(() -> new MemberNotFoundException(username));
        
        // 2. 상품 조회 및 재고 확인
        List<OrderLine> orderLines = command.getItems().stream()
            .map(item -> {
                Product product = productRepository.findById(item.getProductId())
                    .orElseThrow(() -> new ProductNotFoundException(item.getProductId()));
                
                inventoryService.checkStock(product.getId(), item.getQuantity());
                
                return OrderLine.create(product, item.getQuantity());
            })
            .toList();
        
        // 3. 주문 생성
        Order order = Order.create(member, orderLines, command.getShippingAddress());
        orderRepository.save(order);
        
        // 4. 재고 차감
        orderLines.forEach(line -> 
            inventoryService.decreaseStock(line.getProductId(), line.getQuantity())
        );
        
        // 5. 이벤트 발행
        eventPublisher.publishEvent(new OrderCreatedEvent(order));
        
        return OrderResult.from(order);
    }
}

// 3. Repository 계층
public interface OrderRepository extends JpaRepository<Order, Long> {
    
    @Query("SELECT o FROM Order o " +
           "JOIN FETCH o.member " +
           "JOIN FETCH o.orderLines ol " +
           "JOIN FETCH ol.product " +
           "WHERE o.id = :orderId")
    Optional<Order> findByIdWithDetails(@Param("orderId") Long orderId);
    
    List<Order> findByMemberIdOrderByCreatedAtDesc(Long memberId);
    
    @Query("SELECT o FROM Order o WHERE o.status = :status " +
           "AND o.createdAt < :threshold")
    List<Order> findOldOrdersByStatus(
        @Param("status") OrderStatus status,
        @Param("threshold") LocalDateTime threshold
    );
}

결제 서비스 인터페이스

// 인터페이스 정의
public interface PaymentService {
    PaymentResult processPayment(PaymentRequest request);
    PaymentResult cancelPayment(String paymentId);
    PaymentStatus getPaymentStatus(String paymentId);
}

// 구현체 1: 카드 결제
@Service
@Primary  // 기본 구현체로 지정
@RequiredArgsConstructor
@Slf4j
public class CardPaymentService implements PaymentService {
    
    private final CardPaymentGateway gateway;
    private final PaymentRepository paymentRepository;
    
    @Override
    @Transactional
    public PaymentResult processPayment(PaymentRequest request) {
        log.info("카드 결제 처리: {}", request.getOrderId());
        
        // 외부 PG사 API 호출
        CardPaymentResponse response = gateway.requestPayment(
            request.getCardNumber(),
            request.getAmount(),
            request.getOrderId()
        );
        
        // 결제 정보 저장
        Payment payment = Payment.builder()
            .orderId(request.getOrderId())
            .amount(request.getAmount())
            .method(PaymentMethod.CARD)
            .status(response.isSuccess() ? PaymentStatus.COMPLETED : PaymentStatus.FAILED)
            .transactionId(response.getTransactionId())
            .build();
        
        paymentRepository.save(payment);
        
        return PaymentResult.from(payment);
    }
    
    @Override
    public PaymentResult cancelPayment(String paymentId) {
        // 취소 로직
        return null;
    }
    
    @Override
    public PaymentStatus getPaymentStatus(String paymentId) {
        return paymentRepository.findByTransactionId(paymentId)
            .map(Payment::getStatus)
            .orElse(PaymentStatus.NOT_FOUND);
    }
}

// 구현체 2: 가상계좌 결제
@Service("virtualAccountPayment")
@RequiredArgsConstructor
public class VirtualAccountPaymentService implements PaymentService {
    
    private final VirtualAccountGateway gateway;
    private final PaymentRepository paymentRepository;
    
    @Override
    @Transactional
    public PaymentResult processPayment(PaymentRequest request) {
        // 가상계좌 발급
        VirtualAccountResponse response = gateway.issueVirtualAccount(
            request.getAmount(),
            request.getOrderId()
        );
        
        Payment payment = Payment.builder()
            .orderId(request.getOrderId())
            .amount(request.getAmount())
            .method(PaymentMethod.VIRTUAL_ACCOUNT)
            .status(PaymentStatus.PENDING)  // 입금 대기
            .virtualAccountNumber(response.getAccountNumber())
            .virtualAccountBank(response.getBankCode())
            .build();
        
        paymentRepository.save(payment);
        
        return PaymentResult.from(payment);
    }
    
    // ... 나머지 메서드
}

여러 구현체 주입받기

@Service
@RequiredArgsConstructor
public class PaymentFacade {
    
    // 방법 1: @Primary가 붙은 기본 구현체 주입
    private final PaymentService defaultPaymentService;
    
    // 방법 2: @Qualifier로 특정 구현체 지정
    @Qualifier("virtualAccountPayment")
    private final PaymentService virtualAccountService;
    
    // 방법 3: 모든 구현체를 Map으로 주입
    private final Map<String, PaymentService> paymentServices;
    
    // 방법 4: 모든 구현체를 List로 주입
    private final List<PaymentService> allPaymentServices;
    
    public PaymentResult processPayment(PaymentRequest request) {
        // Map에서 결제 방식에 맞는 서비스 선택
        String serviceName = request.getPaymentMethod().getServiceName();
        PaymentService service = paymentServices.get(serviceName);
        
        if (service == null) {
            throw new UnsupportedPaymentMethodException(request.getPaymentMethod());
        }
        
        return service.processPayment(request);
    }
}

// 결제 방식 Enum
public enum PaymentMethod {
    CARD("cardPaymentService"),
    VIRTUAL_ACCOUNT("virtualAccountPayment"),
    KAKAO_PAY("kakaoPayService"),
    NAVER_PAY("naverPayService");
    
    private final String serviceName;
    
    PaymentMethod(String serviceName) {
        this.serviceName = serviceName;
    }
    
    public String getServiceName() {
        return serviceName;
    }
}

순환 의존성 예시와 해결

// 문제: 순환 의존성
@Service
public class OrderService {
    private final MemberService memberService;  // OrderService -> MemberService
}

@Service
public class MemberService {
    private final OrderService orderService;  // MemberService -> OrderService
    // 순환 참조 발생!
}

// 해결 방법 1: 설계 변경 - 공통 서비스 추출
@Service
public class OrderService {
    private final MemberQueryService memberQueryService;  // 조회 전용
}

@Service
public class MemberService {
    private final OrderQueryService orderQueryService;  // 조회 전용
}

@Service
public class MemberQueryService {
    private final MemberRepository memberRepository;
    
    public Member findById(Long id) {
        return memberRepository.findById(id).orElseThrow();
    }
}

// 해결 방법 2: 이벤트 기반 통신
@Service
@RequiredArgsConstructor
public class OrderService {
    private final ApplicationEventPublisher eventPublisher;
    
    public void completeOrder(Long orderId) {
        // 주문 완료 처리
        Order order = findById(orderId);
        order.complete();
        
        // 이벤트 발행 (MemberService가 구독)
        eventPublisher.publishEvent(new OrderCompletedEvent(order));
    }
}

@Service
@RequiredArgsConstructor
public class MemberService {
    
    @EventListener
    public void handleOrderCompleted(OrderCompletedEvent event) {
        // 포인트 적립 등 처리
        Member member = findById(event.getMemberId());
        member.addPoints(event.getEarnedPoints());
    }
}

// 해결 방법 3: @Lazy 사용 (권장하지 않음)
@Service
public class OrderService {
    private final MemberService memberService;
    
    public OrderService(@Lazy MemberService memberService) {
        this.memberService = memberService;  // 프록시 주입, 실제 사용 시 초기화
    }
}

@Configuration
public class NotificationConfig {
    
    // 프로퍼티 값에 따른 조건부 등록
    @Bean
    @ConditionalOnProperty(
        name = "notification.email.enabled",
        havingValue = "true",
        matchIfMissing = false
    )
    public EmailNotificationService emailNotificationService() {
        return new EmailNotificationService();
    }
    
    // 클래스 존재 여부에 따른 조건부 등록
    @Bean
    @ConditionalOnClass(name = "com.google.firebase.messaging.FirebaseMessaging")
    public PushNotificationService pushNotificationService() {
        return new FirebasePushNotificationService();
    }
    
    // Bean 존재 여부에 따른 조건부 등록
    @Bean
    @ConditionalOnMissingBean(NotificationService.class)
    public NotificationService defaultNotificationService() {
        return new LoggingNotificationService();  // 기본 구현
    }
    
    // Profile에 따른 조건부 등록
    @Bean
    @Profile("!prod")  // prod가 아닐 때만
    public NotificationService mockNotificationService() {
        return new MockNotificationService();
    }
}

// 커스텀 Condition
public class OnKafkaEnabledCondition implements Condition {
    
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String enabled = context.getEnvironment()
            .getProperty("kafka.enabled", "false");
        return "true".equalsIgnoreCase(enabled);
    }
}

@Configuration
@Conditional(OnKafkaEnabledCondition.class)
public class KafkaConfig {
    // Kafka 관련 Bean들
}

Profile 활성화 방법

# 1. application.yml에서 설정
spring:
  profiles:
    active: dev

# 2. 환경 변수로 설정
export SPRING_PROFILES_ACTIVE=prod

# 3. JVM 옵션으로 설정
java -jar app.jar -Dspring.profiles.active=prod

# 4. 프로그래밍 방식
SpringApplication app = new SpringApplication(MyApp.class);
app.setAdditionalProfiles("prod");
app.run(args);

# 5. 테스트에서 설정
@SpringBootTest
@ActiveProfiles("test")
class OrderServiceTest {
    // test profile로 실행
}

파일 구조

src/main/resources/
├── application.yml           # 공통 설정
├── application-dev.yml       # 개발 환경
├── application-test.yml      # 테스트 환경
├── application-staging.yml   # 스테이징 환경
└── application-prod.yml      # 운영 환경

application.yml (공통)

spring:
  application:
    name: shop-api
  
  # 기본 profile 설정
  profiles:
    active: dev
    
  # JPA 공통 설정
  jpa:
    open-in-view: false
    properties:
      hibernate:
        default_batch_fetch_size: 100

# 서버 공통 설정
server:
  port: 8080
  servlet:
    context-path: /api

# 로깅 공통 설정
logging:
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"

application-dev.yml (개발)

spring:
  datasource:
    url: jdbc:h2:mem:shopdb
    username: sa
    password:
    driver-class-name: org.h2.Driver
  
  h2:
    console:
      enabled: true
      path: /h2-console
  
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true
    properties:
      hibernate:
        format_sql: true

# 개발용 로깅 - 상세하게
logging:
  level:
    root: INFO
    com.shop: DEBUG
    org.hibernate.SQL: DEBUG
    org.hibernate.type.descriptor.sql: TRACE

# 개발용 외부 서비스 (Mock)
payment:
  gateway:
    url: http://localhost:8081/mock-payment
    
notification:
  email:
    enabled: false  # 개발 시 이메일 발송 비활성화

application-prod.yml (운영)

spring:
  datasource:
    url: jdbc:mysql://${DB_HOST}:3306/shopdb?useSSL=true
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
    driver-class-name: com.mysql.cj.jdbc.Driver
    hikari:
      maximum-pool-size: 20
      minimum-idle: 10
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
  
  jpa:
    hibernate:
      ddl-auto: validate  # 운영에서는 스키마 변경 금지
    show-sql: false

# 운영 로깅 - 최소화
logging:
  level:
    root: WARN
    com.shop: INFO
  file:
    name: /var/log/shop-api/application.log
  logback:
    rollingpolicy:
      max-file-size: 100MB
      max-history: 30

# 운영 외부 서비스
payment:
  gateway:
    url: https://api.payment-gateway.com
    api-key: ${PAYMENT_API_KEY}
    
notification:
  email:
    enabled: true
    smtp-host: ${SMTP_HOST}

# 운영 보안 설정
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: never

// 개발 환경 전용 Bean
@Configuration
@Profile("dev")
public class DevConfig {
    
    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .addScript("schema.sql")
            .addScript("dev-data.sql")  // 개발용 테스트 데이터
            .build();
    }
    
    @Bean
    public PaymentService paymentService() {
        return new MockPaymentService();  // Mock 결제 서비스
    }
}

// 운영 환경 전용 Bean
@Configuration
@Profile("prod")
public class ProdConfig {
    
    @Bean
    @ConfigurationProperties("spring.datasource.hikari")
    public HikariDataSource dataSource() {
        return new HikariDataSource();
    }
    
    @Bean
    public PaymentService paymentService(PaymentGatewayClient client) {
        return new RealPaymentService(client);  // 실제 결제 서비스
    }
}

// 여러 Profile에서 사용
@Service
@Profile({"dev", "test"})  // dev 또는 test에서만 활성화
public class MockEmailService implements EmailService {
    
    @Override
    public void send(Email email) {
        log.info("Mock 이메일 발송: {}", email);
        // 실제 발송하지 않음
    }
}

// 특정 Profile 제외
@Service
@Profile("!prod")  // prod가 아닌 모든 환경
public class DebugService {
    // 디버깅용 서비스
}

타입 안전한 설정 바인딩

// application.yml
payment:
  gateway:
    url: https://api.payment.com
    api-key: secret-key
    timeout:
      connect: 5000
      read: 10000
    retry:
      max-attempts: 3
      delay: 1000

// Properties 클래스
@ConfigurationProperties(prefix = "payment.gateway")
@Validated  // 유효성 검증 활성화
public class PaymentGatewayProperties {
    
    @NotBlank
    private String url;
    
    @NotBlank
    private String apiKey;
    
    private Timeout timeout = new Timeout();
    private Retry retry = new Retry();
    
    // Getters, Setters
    
    public static class Timeout {
        private int connect = 5000;
        private int read = 10000;
        // Getters, Setters
    }
    
    public static class Retry {
        private int maxAttempts = 3;
        private long delay = 1000;
        // Getters, Setters
    }
}

// 활성화
@Configuration
@EnableConfigurationProperties(PaymentGatewayProperties.class)
public class PaymentConfig {
    
    @Bean
    public PaymentGatewayClient paymentGatewayClient(
            PaymentGatewayProperties properties) {
        
        return PaymentGatewayClient.builder()
            .baseUrl(properties.getUrl())
            .apiKey(properties.getApiKey())
            .connectTimeout(properties.getTimeout().getConnect())
            .readTimeout(properties.getTimeout().getRead())
            .maxRetries(properties.getRetry().getMaxAttempts())
            .build();
    }
}

// 사용
@Service
@RequiredArgsConstructor
public class PaymentService {
    
    private final PaymentGatewayProperties properties;
    
    public void processPayment() {
        log.info("결제 게이트웨이: {}", properties.getUrl());
        // ...
    }
}

이벤트 사용 장점

이벤트 클래스 정의

// 주문 생성 이벤트
public class OrderCreatedEvent {
    private final Long orderId;
    private final Long memberId;
    private final BigDecimal totalAmount;
    private final List<OrderLineDto> orderLines;
    private final LocalDateTime occurredAt;
    
    public OrderCreatedEvent(Order order) {
        this.orderId = order.getId();
        this.memberId = order.getMember().getId();
        this.totalAmount = order.getTotalAmount();
        this.orderLines = order.getOrderLines().stream()
            .map(OrderLineDto::from)
            .toList();
        this.occurredAt = LocalDateTime.now();
    }
    
    // Getters
}

// 주문 취소 이벤트
public class OrderCancelledEvent {
    private final Long orderId;
    private final Long memberId;
    private final String cancelReason;
    private final BigDecimal refundAmount;
    private final LocalDateTime occurredAt;
    
    // 생성자, Getters
}

// 결제 완료 이벤트
public class PaymentCompletedEvent {
    private final Long orderId;
    private final String paymentId;
    private final BigDecimal amount;
    private final PaymentMethod method;
    private final LocalDateTime paidAt;
    
    // 생성자, Getters
}

이벤트 발행

@Service
@RequiredArgsConstructor
@Transactional
public class OrderService {
    
    private final OrderRepository orderRepository;
    private final ApplicationEventPublisher eventPublisher;
    
    public OrderResult createOrder(CreateOrderCommand command) {
        // 1. 주문 생성 (핵심 로직)
        Order order = Order.create(
            command.getMember(),
            command.getOrderLines(),
            command.getShippingAddress()
        );
        orderRepository.save(order);
        
        // 2. 이벤트 발행 (부가 로직은 리스너에서 처리)
        eventPublisher.publishEvent(new OrderCreatedEvent(order));
        
        return OrderResult.from(order);
    }
    
    public void cancelOrder(Long orderId, String reason) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
        
        order.cancel(reason);
        
        // 취소 이벤트 발행
        eventPublisher.publishEvent(new OrderCancelledEvent(order, reason));
    }
}

@EventListener 사용

// 알림 서비스 - 주문 이벤트 구독
@Component
@RequiredArgsConstructor
@Slf4j
public class OrderNotificationListener {
    
    private final NotificationService notificationService;
    private final MemberRepository memberRepository;
    
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        log.info("주문 생성 이벤트 수신: orderId={}", event.getOrderId());
        
        Member member = memberRepository.findById(event.getMemberId())
            .orElseThrow();
        
        // 주문 확인 알림 발송
        notificationService.sendOrderConfirmation(
            member.getEmail(),
            event.getOrderId(),
            event.getTotalAmount()
        );
    }
    
    @EventListener
    public void handleOrderCancelled(OrderCancelledEvent event) {
        log.info("주문 취소 이벤트 수신: orderId={}", event.getOrderId());
        
        // 취소 알림 발송
        notificationService.sendOrderCancellation(
            event.getMemberId(),
            event.getOrderId(),
            event.getCancelReason()
        );
    }
}

// 포인트 서비스 - 주문 이벤트 구독
@Component
@RequiredArgsConstructor
public class PointEventListener {
    
    private final PointService pointService;
    
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 포인트 적립 (결제 금액의 1%)
        BigDecimal earnedPoints = event.getTotalAmount()
            .multiply(new BigDecimal("0.01"));
        
        pointService.earnPoints(
            event.getMemberId(),
            earnedPoints,
            "주문 적립 - 주문번호: " + event.getOrderId()
        );
    }
    
    @EventListener
    public void handleOrderCancelled(OrderCancelledEvent event) {
        // 적립 포인트 회수
        pointService.revokePoints(
            event.getMemberId(),
            event.getOrderId()
        );
    }
}

// 재고 서비스 - 주문 이벤트 구독
@Component
@RequiredArgsConstructor
public class InventoryEventListener {
    
    private final InventoryService inventoryService;
    
    @EventListener
    public void handleOrderCancelled(OrderCancelledEvent event) {
        // 재고 복구
        event.getOrderLines().forEach(line ->
            inventoryService.increaseStock(
                line.getProductId(),
                line.getQuantity()
            )
        );
    }
}

트랜잭션 단계별 이벤트 처리

@Component
@RequiredArgsConstructor
@Slf4j
public class TransactionalOrderListener {
    
    private final NotificationService notificationService;
    private final ExternalApiClient externalApiClient;
    
    // 트랜잭션 커밋 후 실행 (기본값)
    // 트랜잭션이 성공적으로 완료된 후에만 실행
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handleOrderCreatedAfterCommit(OrderCreatedEvent event) {
        log.info("트랜잭션 커밋 후 - 주문 알림 발송");
        
        // 이메일 발송 - 트랜잭션 성공 후에만 발송
        notificationService.sendOrderConfirmation(event);
        
        // 외부 시스템 연동
        externalApiClient.notifyOrderCreated(event);
    }
    
    // 트랜잭션 커밋 전 실행
    // 리스너에서 예외 발생 시 트랜잭션 롤백
    @TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
    public void validateBeforeCommit(OrderCreatedEvent event) {
        log.info("트랜잭션 커밋 전 - 추가 검증");
        
        // 재고 최종 확인 등
        if (!inventoryService.validateStock(event.getOrderLines())) {
            throw new InsufficientStockException();  // 트랜잭션 롤백
        }
    }
    
    // 트랜잭션 롤백 후 실행
    @TransactionalEventListener(phase = TransactionPhase.AFTER_ROLLBACK)
    public void handleRollback(OrderCreatedEvent event) {
        log.warn("트랜잭션 롤백 - 주문 실패 처리: orderId={}", event.getOrderId());
        
        // 실패 로깅, 모니터링 알림 등
        monitoringService.alertOrderFailed(event);
    }
    
    // 트랜잭션 완료 후 실행 (커밋/롤백 상관없이)
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMPLETION)
    public void handleCompletion(OrderCreatedEvent event) {
        log.info("트랜잭션 완료 - 정리 작업");
        
        // 임시 데이터 정리 등
    }
}

TransactionPhase 정리

// 비동기 설정 활성화
@Configuration
@EnableAsync
public class AsyncConfig {
    
    @Bean
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("async-event-");
        executor.initialize();
        return executor;
    }
}

// 비동기 이벤트 리스너
@Component
@RequiredArgsConstructor
@Slf4j
public class AsyncOrderListener {
    
    private final EmailService emailService;
    private final SmsService smsService;
    
    // 비동기로 실행 - 메인 스레드 블로킹 없음
    @Async
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void sendNotificationsAsync(OrderCreatedEvent event) {
        log.info("비동기 알림 발송 시작 - thread: {}", 
                 Thread.currentThread().getName());
        
        try {
            // 이메일 발송 (시간이 오래 걸릴 수 있음)
            emailService.sendOrderConfirmation(event);
            
            // SMS 발송
            smsService.sendOrderNotification(event);
            
        } catch (Exception e) {
            log.error("알림 발송 실패: orderId={}", event.getOrderId(), e);
            // 재시도 로직 또는 Dead Letter Queue로 전송
        }
    }
    
    // 여러 작업을 병렬로 처리
    @Async
    @EventListener
    public void processAnalytics(OrderCreatedEvent event) {
        // 분석 데이터 수집 (비동기)
        analyticsService.trackOrder(event);
    }
}

AOP 용어

로깅 Aspect

@Aspect
@Component
@Slf4j
public class LoggingAspect {
    
    // Service 계층 모든 메서드에 적용
    @Pointcut("execution(* com.shop.service..*(..))")
    public void serviceLayer() {}
    
    // 메서드 실행 전
    @Before("serviceLayer()")
    public void logBefore(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        log.info(">>> {} 호출, 파라미터: {}", methodName, Arrays.toString(args));
    }
    
    // 메서드 정상 완료 후
    @AfterReturning(pointcut = "serviceLayer()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        log.info("<<< {} 완료, 결과: {}", methodName, result);
    }
    
    // 예외 발생 시
    @AfterThrowing(pointcut = "serviceLayer()", throwing = "ex")
    public void logAfterThrowing(JoinPoint joinPoint, Exception ex) {
        String methodName = joinPoint.getSignature().getName();
        log.error("!!! {} 예외 발생: {}", methodName, ex.getMessage());
    }
    
    // 메서드 실행 전후 (가장 강력)
    @Around("serviceLayer()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        long startTime = System.currentTimeMillis();
        
        try {
            Object result = joinPoint.proceed();  // 실제 메서드 실행
            
            long elapsed = System.currentTimeMillis() - startTime;
            log.info("{} 실행 시간: {}ms", methodName, elapsed);
            
            return result;
        } catch (Exception e) {
            log.error("{} 실행 중 예외: {}", methodName, e.getMessage());
            throw e;
        }
    }
}

성능 측정 Aspect

// 커스텀 어노테이션
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Timed {
    String value() default "";
}

// Aspect 구현
@Aspect
@Component
@RequiredArgsConstructor
public class TimedAspect {
    
    private final MeterRegistry meterRegistry;
    
    @Around("@annotation(timed)")
    public Object measureTime(ProceedingJoinPoint joinPoint, Timed timed) 
            throws Throwable {
        
        String metricName = timed.value().isEmpty() 
            ? joinPoint.getSignature().getName() 
            : timed.value();
        
        Timer.Sample sample = Timer.start(meterRegistry);
        
        try {
            return joinPoint.proceed();
        } finally {
            sample.stop(Timer.builder(metricName)
                .tag("class", joinPoint.getTarget().getClass().getSimpleName())
                .tag("method", joinPoint.getSignature().getName())
                .register(meterRegistry));
        }
    }
}

// 사용
@Service
public class OrderService {
    
    @Timed("order.create")
    public OrderResult createOrder(CreateOrderCommand command) {
        // 실행 시간이 자동으로 측정됨
    }
}

트랜잭션 기본 사용

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)  // 클래스 레벨: 기본 읽기 전용
public class OrderService {
    
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    
    // 읽기 전용 트랜잭션 (클래스 레벨 설정 사용)
    public Order findById(Long orderId) {
        return orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
    }
    
    public List<Order> findByMemberId(Long memberId) {
        return orderRepository.findByMemberId(memberId);
    }
    
    // 쓰기 트랜잭션 (메서드 레벨에서 오버라이드)
    @Transactional  // readOnly = false (기본값)
    public OrderResult createOrder(CreateOrderCommand command) {
        // 1. 재고 차감
        command.getItems().forEach(item ->
            inventoryService.decreaseStock(item.getProductId(), item.getQuantity())
        );
        
        // 2. 주문 생성
        Order order = Order.create(command);
        orderRepository.save(order);
        
        // 3. 결제 처리
        paymentService.processPayment(order);
        
        return OrderResult.from(order);
        // 메서드 종료 시 커밋 (예외 발생 시 롤백)
    }
    
    @Transactional
    public void cancelOrder(Long orderId) {
        Order order = findById(orderId);
        order.cancel();
        
        // 재고 복구
        order.getOrderLines().forEach(line ->
            inventoryService.increaseStock(line.getProductId(), line.getQuantity())
        );
        
        // 결제 취소
        paymentService.cancelPayment(order.getPaymentId());
    }
}

트랜잭션 속성

@Transactional(
    // 전파 속성: 트랜잭션이 이미 있을 때 어떻게 동작할지
    propagation = Propagation.REQUIRED,  // 기본값: 있으면 참여, 없으면 생성
    
    // 격리 수준: 동시 트랜잭션 간 데이터 가시성
    isolation = Isolation.DEFAULT,  // DB 기본값 사용
    
    // 타임아웃: 트랜잭션 최대 실행 시간 (초)
    timeout = 30,
    
    // 읽기 전용: 최적화 힌트
    readOnly = false,
    
    // 롤백 조건: 어떤 예외에서 롤백할지
    rollbackFor = Exception.class,
    noRollbackFor = BusinessException.class
)
public void complexOperation() {
    // ...
}

// 전파 속성 예시
@Service
public class PaymentService {
    
    // REQUIRED: 기존 트랜잭션에 참여 (기본값)
    @Transactional(propagation = Propagation.REQUIRED)
    public void processPayment(Order order) {
        // OrderService의 트랜잭션에 참여
        // 여기서 예외 발생 시 전체 롤백
    }
    
    // REQUIRES_NEW: 항상 새 트랜잭션 생성
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void savePaymentLog(PaymentLog log) {
        // 별도 트랜잭션으로 실행
        // 메인 트랜잭션이 롤백되어도 로그는 저장됨
        paymentLogRepository.save(log);
    }
    
    // NOT_SUPPORTED: 트랜잭션 없이 실행
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public PaymentStatus checkExternalStatus(String paymentId) {
        // 외부 API 호출 - 트랜잭션 불필요
        return externalApi.getStatus(paymentId);
    }
}

Self-Invocation 문제와 해결

@Service
public class OrderService {
    
    // 문제: 내부 호출 시 @Transactional 무시됨
    public void processOrders(List<Long> orderIds) {
        for (Long orderId : orderIds) {
            processOrder(orderId);  // 내부 호출 - 트랜잭션 적용 안 됨!
        }
    }
    
    @Transactional
    public void processOrder(Long orderId) {
        // 트랜잭션이 적용되지 않음
    }
}

// 해결 방법 1: 별도 서비스로 분리 (권장)
@Service
@RequiredArgsConstructor
public class OrderService {
    
    private final OrderProcessor orderProcessor;
    
    public void processOrders(List<Long> orderIds) {
        for (Long orderId : orderIds) {
            orderProcessor.processOrder(orderId);  // 외부 호출
        }
    }
}

@Service
public class OrderProcessor {
    
    @Transactional
    public void processOrder(Long orderId) {
        // 트랜잭션 정상 적용
    }
}

// 해결 방법 2: Self-injection (비권장)
@Service
public class OrderService {
    
    @Autowired
    private OrderService self;  // 자기 자신 주입
    
    public void processOrders(List<Long> orderIds) {
        for (Long orderId : orderIds) {
            self.processOrder(orderId);  // 프록시를 통한 호출
        }
    }
    
    @Transactional
    public void processOrder(Long orderId) {
        // 트랜잭션 적용됨
    }
}

Checked Exception 롤백

// 기본적으로 Checked Exception은 롤백하지 않음
@Transactional
public void createOrder() throws IOException {
    orderRepository.save(order);
    
    // IOException 발생해도 롤백되지 않음 (Checked Exception)
    fileService.saveReceipt(order);
}

// 해결: rollbackFor 지정
@Transactional(rollbackFor = Exception.class)
public void createOrder() throws IOException {
    orderRepository.save(order);
    
    // 이제 IOException도 롤백됨
    fileService.saveReceipt(order);
}

// 또는 RuntimeException으로 감싸기
@Transactional
public void createOrder() {
    try {
        orderRepository.save(order);
        fileService.saveReceipt(order);
    } catch (IOException e) {
        throw new OrderProcessingException("영수증 저장 실패", e);
    }
}