// 도메인 객체
public class Order {
  // 취소 도메인 기능
  // 외부 서비스를 실행하기 위해 도메인 서비스를 파라메터로 전달받음
  public void cancel(RefundService refundService) {
      verifyNotYetShipping();
      this.state = OrderState.CNACELED;
      
      this.refundStatus = State.REFUND_STARTED;
      
      try {
          refundService.refund(getPaymentID()); // 외부 서비스 성능에 직접적인 영향을 받음
          this.refundStatus = State.REFUND_COMPLETED;
      } catch (Exception e) {
          // ???
          // 외부 환불 시스템에서 오류가 난 경우 어떻게 할 것인가?
      }
  }
}

@RequiredArgsConstructor
public class CancelOrderService {
    private RefundService refundService;
    
    @Transactional
    public void cancel(OrderNo orderNo) {
        Order order = findOrder(orderNo);
        order.cancel();

        order.refundStarted();
        
        try {
            refundService.refund(order.getPaymentId()); // 외부 서비스 성능에 직접적인 영향을 받음
            order.refundCompleted();
        } catch (Exception e) {
            // ??? 
            // 외부 환불 시스템에서 오류가 난 경우 어떻게 할 것인가?
        }
    }
}

// 도메인 객체
public class Order {
  public void cancel(RefundService refundService) {
      // 주문 로직
      verifyNotYetShipping();
      this.state = OrderState.CNACELED;
      
      // 결제 로직
      this.refundStatus = State.REFUND_STARTED;
      try {
          refundService.refund(getPaymentID()); // 외부 서비스 성능에 직접적인 영향을 받음
          this.refundStatus = State.REFUND_COMPLETED;
      } catch (Exception e) {
      }
  }
}

public class Order {
    // 기능을 추가할 때마다 파라메터가 추가되면 다른 로직이 더 많이 섞이고 트랜잭션 처리가 복잡해짐
  public void cancel(RefundService refundService, NotiService notiService) {
      verifyNotYetShipping();
      this.state = OrderState.CNACELED;
   
      // 주문 + 결제 + 통지 로직이 섞임
      // refundService 는 성공하고 notiService 는 실패했을 경우 어떻게 처리할 것인지?
      // refundService 와 notiService 중 어떤 것을 먼저 처리할지?
  }
}

package com.assu.study.order.command.domain;

import lombok.Getter;

// 배송지 변경 시 발생하는 이벤트
@Getter
public class ShippingInfoChangedEvent {
  private final OrderNo number;
  private final ShippingInfo newShippingInfo;
  private long timestamp;

  public ShippingInfoChangedEvent(OrderNo number, ShippingInfo newShippingInfo) {
    super();
    this.number = number;
    this.newShippingInfo = newShippingInfo;
    this.timestamp = System.currentTimeMillis();
  }
}

public class Order {
    // ...
    public void changeShippingInfo(ShippingInfo newShippingInfo) {
      // 배송지 변경 가능 여부 확인
      verifyNotYetShipped();
      setShippingInfo(newShippingInfo);
      Events.raise(new ShippingInfoChangedEvent(number, newShippingInfo));
    }
}

public class ShippingInfoChangedHandler {
  @EventListener(ShippingInfoChangedEvent.class)
  public void handle(ShippingInfoChangedEvent evt) {
        shippingInfoSynchronizer.sync(
                evt.getNumber(),
                evt.getNewShippingInfo()
        );
    }
}

public class ShippingInfoChangedHandler {
  @EventListener(ShippingInfoChangedEvent.class)
  public void handle(ShippingInfoChangedEvent evt) {
       // 필요한 데이터가 없을 경우 직접 조회 
        Order order = orderRepository.findById(evt.getNumber());
      
        shippingInfoSynchronizer.sync(
                evt.getNumber(),
                order.getShippingInfo()
        );
    }
}

// 도메인 객체
public class Order {
  public void cancel(RefundService refundService) {
      // 주문 로직
      verifyNotYetShipping();
      this.state = OrderState.CNACELED;
      
      // 결제 로직 (구매 취소 로직)
      this.refundStatus = State.REFUND_STARTED;
      try {
          refundService.refund(getPaymentID()); // 외부 서비스 성능에 직접적인 영향을 받음
          this.refundStatus = State.REFUND_COMPLETED;
      } catch (Exception e) {
      }
  }
}

public class Order {
  public void cancel() {
    verifyNotYetShipped();
    this.state = OrderState.CANCELED;
    
    Events.raise(new OrderCanceledEvent(number.getNumber()));
  }
}

package com.assu.study.order.command.domain;

import com.assu.study.common.event.Event;
import lombok.Getter;

@Getter
public class OrderCanceledEvent extends Event {
    // 이벤트는 핸들러에서 이벤트를 처리하는데 필요한 데이터를 포함함
    private String orderNumber;

    public OrderCanceledEvent(String orderNumber) {
        super();
        this.orderNumber = orderNumber;
    }
}

package com.assu.study.common.event;

import lombok.Getter;

@Getter
public abstract class Event {
    private long timestamp;

    public Event() {
        this.timestamp = System.currentTimeMillis();
    }
}

package com.assu.study.common.event;

import lombok.Getter;

// 모든 이벤트가 공통으로 갖는 프로퍼티를 갖는 공통 추상 클래스
@Getter
public abstract class Event {
    private long timestamp;

    public Event() {
        this.timestamp = System.currentTimeMillis();
    }
}

package com.assu.study.order.command.domain;

import com.assu.study.common.event.Event;
import lombok.Getter;

// 발생 시간이 필요한 이벤트 클래스는 Event 클래스를 상속받아 구현함
@Getter
public class OrderCanceledEvent extends Event {
    // 이벤트는 핸들러에서 이벤트를 처리하는데 필요한 데이터를 포함함
    private String orderNumber;

    public OrderCanceledEvent(String orderNumber) {
        super();
        this.orderNumber = orderNumber;
    }
}

package com.assu.study.common.event;

import org.springframework.context.ApplicationEventPublisher;

public class Events {
    private static ApplicationEventPublisher publisher;

    // Events 클래스가 사용할 ApplicationEventPublisher 객체는 setPublisher() 를 통해 전달받음
    static void setPublisher(ApplicationEventPublisher publisher) {
        Events.publisher = publisher;
    }

    // ApplicationEventPublisher 가 제공하는 publishEvent() 메서드를 이용하여 이벤트 발생
    public static void raise(Object event) {
        if (publisher != null) {
            publisher.publishEvent(event);
        }
    }
}

package com.assu.study.common.event;

import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@RequiredArgsConstructor
@Configuration
public class EventsConfig {
  private final ApplicationContext applicationContext;

  // InitializingBean 타입 객체를 빈으로 설정
  // 이 타입은 스프링 빈 객체를 초기화할 때 사용하는 인터페이스로 
  // 이 기능을 사용해서 Events 클래스를 초기화함
  @Bean
  public InitializingBean eventInitializer() {
    // ApplicationContext 는 ApplicationEventPublisher 를 상속하고 있으므로 
    // Events 클래스 초기화 시 ApplicationContext 전달
    return () -> Events.setPublisher(applicationContext);
  }
}

public class Order {
  // 주문 취소
  public void cancel() {
    verifyNotYetShipped();
    this.state = OrderState.CANCELED;

    Events.raise(new OrderCanceledEvent(number.getNumber()));
  }
}

package com.assu.study.order.infra;

import com.assu.study.order.command.application.RefundService;
import com.assu.study.order.command.domain.OrderCanceledEvent;
import lombok.RequiredArgsConstructor;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Service;

// OrderCanceledEvent 처리하는 핸들러
@RequiredArgsConstructor
@Service
public class OrderCanceledEventHandler {
    private final RefundService refundService;

    @EventListener(OrderCanceledEvent.class)
    public void handle(OrderCanceledEvent event) {
        refundService.refund(event.getOrderNumber());
    }
}

package com.assu.study.order.command.application;

public interface RefundService {
    void refund(String orderNumber);
}

package com.assu.study.order.infra.paygate;

import com.assu.study.order.command.application.RefundService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class ExternalRefundService implements RefundService {
    @Override
    public void refund(String orderNumber) {
        log.info("refund order: {}", orderNumber);
    }
}