package com.springtour.example.chapter12.service;

@Slf4j
@Service
public class UserService {

    @Autowired
    private EventService eventService;
    
    public Boolean createUser(String userName, String emailAddress) {
        // 사용자 생성 로직 생략
        eventService.sendEventMail(eventAddress);
        return Boolean.TRUE;
    }
}

import org.springframework.context.ApplicationEvent;

// 이벤트 메시지 클래스
// 불변(immutable) 클래스 이어야 하므로 Setter 는 없음
// 유저를 생성/삭제할 때 게시할 목적으로 사용됨
@Getter
public final class UserEvent extends ApplicationEvent {   // 이벤트 메시지 클래스이므로 ApplicationEvent 상속
    private final Type type;
    private final Long userId;
    private final String email;

    private UserEvent(Object source, Type type, Long userId, String email) {
        // Object source 는 이벤트를 게시하는 클래스의 객체를 의미
        // 예를 들어 UserService 클래스에서 UserEvent 객체를 생성/게시할 때 UserService 객체를 Object source 인자로 넘김
        // ApplicationEvent 객체에 할당된 Object source 는 Object getSource() 로 참조 가능
        super(source);

        this.type = type;
        this.userId = userId;
        this.email = email;
    }

    // 정적 팩토리 메서드
    public static UserEvent created(Object source, Long userId, String email) {
        return new UserEvent(source, Type.CREATE, userId, email);
    }

    public enum Type {
      CREATE, DELETE
    }
}

package com.assu.study.chap12.event;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;

// 게시 클래스
@Slf4j
@Component
public class UserEventPublisher {
    // ApplicationEventPublisher 스프링 빈 주입받음
    private final ApplicationEventPublisher applicationEventPublisher;

    public UserEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    // 이벤트가 발생하는 클래스에서 호출
    public void publishUserCreated(Long userId, String email) {
        UserEvent userEvent = UserEvent.created(this, userId, email);
        log.info("Publish user created event.");
        
        // UserEvent 이벤트 메시지 객체 게시
        applicationEventPublisher.publishEvent(userEvent);
    }
}

import com.assu.study.chap12.event.UserEventPublisher;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class UserService {
    private final UserEventPublisher userEventPublisher;

    public UserService(UserEventPublisher userEventPublisher) {
        this.userEventPublisher = userEventPublisher;
    }

    public Boolean createUser(String userName, String email) {
        // 사용자 생성 로직 생략
        log.info("created user. {}, {}", userName, email);

        userEventPublisher.publishUserCreated(11111L, email);
        log.info("done create user event publish.");

        return Boolean.TRUE;
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class EventService {
    public void sendEventEmail(String email) {
        // 이메일 발송
        log.info("Send Email~, {}", email);
    }
}

import com.assu.study.chap12.service.EventService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

// 구독 클래스
@Slf4j
@Component
public class UserEventListener implements ApplicationListener<UserEvent> {  // ApplicationListener 의 제네릭 클래스 타입은 구독할 이벤트의 클래스 타입

    // 기능을 실행할 스프링 빈 주입
    // UserEventListener 구독 클래스는 UserEvent 를 구독하는 기능만 담당하고, 실제 이벤트 처리는 별도의 클래스(EventService)에 위임
    private final EventService eventService;

    public UserEventListener(EventService eventService) {
        this.eventService = eventService;
    }

    @Override
    public void onApplicationEvent(UserEvent event) {
        if (UserEvent.Type.CREATE == event.getType()) {
            log.info("Listen CREATE event. {}, {}", event.getUserId(), event.getEmail());
            // 메일 발송
            eventService.sendEventEmail(event.getEmail());
        } else if (UserEvent.Type.DELETE == event.getType()) {
            log.info("Listen DELETE event.");
        } else {
            log.error("Unsupported event type. {}", event.getType());
        }
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;

@Slf4j
public class ApplicationEventListener implements ApplicationListener<ApplicationReadyEvent> {
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        long timestamp = event.getTimestamp();
        LocalDateTime eventTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault());

        log.info("Application is Ready. {}", eventTime);
    }
}

package com.assu.study.chap12;

import com.assu.study.chap12.server.ApplicationEventListener;
import com.assu.study.chap12.service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class Chap12SyncApplication {
  public static void main(String[] args) {
    // SpringApplication 객체와 ApplicationContext 를 설정할 수 있는 메서드를 제공하는 SpringApplicationBuilder 클래스 사용
    SpringApplicationBuilder builder = new SpringApplicationBuilder(Chap12SyncApplication.class);
    // build() 를 호출하여 SpringApplication 객체 생성
    SpringApplication application = builder.build();
    // addListener() 는 하나 이상의 ApplicationListener 객체들을 받음
    application.addListeners(new ApplicationEventListener());

    // run() 을 이용하여 스프링 부트 애플리케이션 실행
    ConfigurableApplicationContext ctxt = application.run(args);

    UserService userService = ctxt.getBean(UserService.class);
    userService.createUser("Assu", "assu@test.com");
  }
}

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
  public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
  // ...
  private ApplicationEventMulticaster applicationEventMulticaster;
}

package com.assu.study.chap12.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ApplicationEventMulticaster;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
public class AsyncEventConfig {
    @Bean("applicationEventMulticaster")    // 반드시 AbstractApplicationContext 에서 지정한 스프링 빈 이름으로 설정
    public ApplicationEventMulticaster applicationEventMulticaster(TaskExecutor asyncEventTaskExecutor) {
        SimpleApplicationEventMulticaster eventMulticaster = new SimpleApplicationEventMulticaster();
        eventMulticaster.setTaskExecutor(asyncEventTaskExecutor);   // 스레드 풀 설정
        return eventMulticaster;
    }

    @Bean
    public TaskExecutor asyncEventTaskExecutor() {
        ThreadPoolTaskExecutor asyncEventTaskExecutor = new ThreadPoolTaskExecutor();
        // 스레드 풀의 개수는 최대 10개까지 늘어남
        asyncEventTaskExecutor.setMaxPoolSize(10);
        // 스레드 풀의 이름은 eventExecutor- 로 시작함
        asyncEventTaskExecutor.setThreadNamePrefix("eventExecutor-");
        // 컨테이너가 모든 속성값을 적용한 후 initialize() 호출
        asyncEventTaskExecutor.afterPropertiesSet();

        return asyncEventTaskExecutor;
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@EnableAsync    // 비동기 기능 활성화
@Configuration
public class AsyncExecutionConfig implements AsyncConfigurer {
    // 프레임워크가 스레드 풀을 설정할 때 사용하는 콜백 메서드
    @Override
    public Executor getAsyncExecutor() {
        return getExecutor();
    }

    private Executor getExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        // 기본 개수는 10개
        threadPoolTaskExecutor.setCorePoolSize(10);
        // 최대 10개까지 늘어남
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("asyncExecutor-");
        // 컨테이너가 모든 속성값을 적용한 후 initialize() 호출
        threadPoolTaskExecutor.afterPropertiesSet();
        return threadPoolTaskExecutor;
    }

    @Bean("asyncExecutor")
    public Executor asyncExecutor() {
        return getExecutor();
    }
}

//@Configuration
public class AsyncEventConfig {
  //@Bean("applicationEventMulticaster")    // 반드시 AbstractApplicationContext 에서 지정한 스프링 빈 이름으로 설정
  public ApplicationEventMulticaster applicationEventMulticaster(TaskExecutor asyncEventTaskExecutor) {
    SimpleApplicationEventMulticaster eventMulticaster = new SimpleApplicationEventMulticaster();
    eventMulticaster.setTaskExecutor(asyncEventTaskExecutor);   // 스레드 풀 설정
    return eventMulticaster;
  }
  // ...
}

// 구독 클래스
@Slf4j
@Component
public class UserEventListener implements ApplicationListener<UserEvent> {  // ApplicationListener 의 제네릭 클래스 타입은 구독할 이벤트의 클래스 타입

// ...
    @Async
    @Override
    public void onApplicationEvent(UserEvent event) {
        if (UserEvent.Type.CREATE == event.getType()) {
            log.info("Listen CREATE event. {}, {}", event.getUserId(), event.getEmail());
            // 메일 발송
            eventService.sendEventEmail(event.getEmail());
        } else if (UserEvent.Type.DELETE == event.getType()) {
            log.info("Listen DELETE event.");
        } else {
            log.error("Unsupported event type. {}", event.getType());
        }
    }
}

package com.assu.study.chap12.event.hotel;

import lombok.Getter;
import lombok.ToString;

// 이벤트 메시지 클래스
// 불변(immutable) 클래스 이어야 하므로 Setter 는 없음
@Getter
@ToString
public final class HotelCreateEvent {
    private final Long hotelId;
    private final String hotelAddr;

    private HotelCreateEvent(Long hotelId, String hotelAddr) {
        this.hotelId = hotelId;
        this.hotelAddr = hotelAddr;
    }

    // 정적 팩토리 메서드 패턴
    public static HotelCreateEvent of(Long hotelId, String hotelAddr) {
        return new HotelCreateEvent(hotelId, hotelAddr);
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;

// 게시 클래스
@Slf4j
@Component
public class HotelEventPublisher {
    // ApplicationEventPublisher 스프링 빈 주입받음
    private final ApplicationEventPublisher applicationEventPublisher;

    public HotelEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }
    
    // 이벤트가 발생하는 클래스에서 호출
    public void publishHotelCreated(Long hotelId, String addr) {
        HotelCreateEvent event = HotelCreateEvent.of(hotelId, addr);
        log.info("Publish hotel created event.");
        
        // HotelCreateEvent 이벤트 메시지 객체 게시
        applicationEventPublisher.publishEvent(event);
    }
}

import com.assu.study.chap12.event.hotel.HotelEventPublisher;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class HotelService {
    private final HotelEventPublisher hotelEventPublisher;

    public HotelService(HotelEventPublisher hotelEventPublisher) {
        this.hotelEventPublisher = hotelEventPublisher;
    }

    public Boolean createHotel(String hotelName, String hotelAddr) {
        // 호텔 생성 로직 생략
        log.info("created hotel. {}, {}", hotelName, hotelAddr);
        hotelEventPublisher.publishHotelCreated(2222L, hotelAddr);
        log.info("done create hotel publish.")
        ;
        return Boolean.TRUE;
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class PropagationService {
    public void propagateHotelEvent() {
        log.info("propagation of hotel event");
    }

    public void propagateResourceEvent() {
        log.info("propagation of resource event");
    }
}

package com.assu.study.chap12.event.hotel;

import com.assu.study.chap12.service.PropagationService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.Order;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

// 구독 클래스
@Slf4j
@Component
public class HotelEventListener {

    // 기능을 실행할 스프링 빈 주입
    // HotelEventListener 구독 클래스는 구독만 하고, 실제 이벤트 처리는 별도의 클래스(PropagationService)에 위임
    private final PropagationService propagationService;

    public HotelEventListener(PropagationService propagationService) {
        this.propagationService = propagationService;
    }

    @Async
    @Order(1)
    // 하나 이상의 클래스 타입 설정 가능
    // 정의된 이벤트 메시지가 게시되면 @EventListener 애너테이션이 정의된 메서드가 이벤트를 구독하고 실행함
    @EventListener(value = HotelCreateEvent.class)
    // 구독한 이벤트 객체를 메서드의 인자로 받을 수 있음
    public void handleHotelCreateEvent(HotelCreateEvent hotelCreateEvent) {
        log.info("handle HotelCreatedEvent : {}", hotelCreateEvent);
        propagationService.propagateHotelEvent();
    }

    @Async
    @Order(2)
    @EventListener(value = HotelCreateEvent.class)
    public void handleResourceCreateEvent(HotelCreateEvent hotelCreateEvent) {
        log.info("handle resourceCreatedEvent : {}", hotelCreateEvent);
        propagationService.propagateResourceEvent();
    }
}

import com.assu.study.chap12.service.HotelService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class Chap12ASyncApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext ctxt =
                SpringApplication.run(Chap12ASyncApplication.class, args);

        HotelService hotelService = ctxt.getBean(HotelService.class);
        hotelService.createHotel("ASSU", "Seoul");
    }

}

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;

@Slf4j
public class ApplicationEventListener implements ApplicationListener<ApplicationReadyEvent> {
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        long timestamp = event.getTimestamp();
        LocalDateTime eventTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault());

        log.info("Application is Ready. {}", eventTime);
    }
}

package com.assu.study.chap12;

import com.assu.study.chap12.server.ApplicationEventListener;
import com.assu.study.chap12.service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class Chap12SyncApplication {
  public static void main(String[] args) {
    // SpringApplication 객체와 ApplicationContext 를 설정할 수 있는 메서드를 제공하는 SpringApplicationBuilder 클래스 사용
    SpringApplicationBuilder builder = new SpringApplicationBuilder(Chap12SyncApplication.class);
    // build() 를 호출하여 SpringApplication 객체 생성
    SpringApplication application = builder.build();
    // addListener() 는 하나 이상의 ApplicationListener 객체들을 받음
    application.addListeners(new ApplicationEventListener());

    // run() 을 이용하여 스프링 부트 애플리케이션 실행
    ConfigurableApplicationContext ctxt = application.run(args);

    UserService userService = ctxt.getBean(UserService.class);
    userService.createUser("Assu", "assu@test.com");
  }
}

package com.assu.study.chap12_1.event;

import lombok.Getter;
import org.springframework.context.ApplicationEvent;

// 이벤트 메시지 클래스
// 불변(immutable) 클래스 이어야 하므로 Setter 는 없음
// 유저를 생성/삭제할 때 게시할 목적으로 사용됨
@Getter
public final class UserEvent extends ApplicationEvent {   // 이벤트 메시지 클래스이므로 ApplicationEvent 상속
    private final Type type;
    private final Long userId;
    private final String email;

    private UserEvent(Object source, Type type, Long userId, String email) {
        // Object source 는 이벤트를 게시하는 클래스의 객체를 의미
        // 예를 들어 UserService 클래스에서 UserEvent 객체를 생성/게시할 때 UserService 객체를 Object source 인자로 넘김
        // ApplicationEvent 객체에 할당된 Object source 는 Object getSource() 로 참조 가능
        super(source);

        this.type = type;
        this.userId = userId;
        this.email = email;
    }

    // 정적 팩토리 메서드
    public static UserEvent created(Object source, Long userId, String email) {
        return new UserEvent(source, Type.CREATE, userId, email);
    }

    public enum Type {
        CREATE, DELETE
    }
}

package com.assu.study.chap12_1.event;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;

// 게시 클래스
@Slf4j
@Component
public class UserEventPublisher {
    // ApplicationEventPublisher 스프링 빈 주입받음
    private final ApplicationEventPublisher applicationEventPublisher;

    public UserEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    // 이벤트가 발생하는 클래스에서 호출
    public void publishUserCreated(Long userId, String email) {
        UserEvent userEvent = UserEvent.created(this, userId, email);
        log.info("Publish user created event.");

        // UserEvent 이벤트 메시지 객체 게시
        applicationEventPublisher.publishEvent(userEvent);
    }
}

package com.assu.study.chap12_1.service;

import com.assu.study.chap12_1.event.UserEventPublisher;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class UserService {
    private final UserEventPublisher userEventPublisher;

    public UserService(UserEventPublisher userEventPublisher) {
        this.userEventPublisher = userEventPublisher;
    }

    public Boolean createUser(String userName, String email) {
        // 사용자 생성 로직 생략
        log.info("created user. {}, {}", userName, email);

        userEventPublisher.publishUserCreated(11111L, email);
        log.info("done create user event publish.");

        return Boolean.TRUE;
    }
}

package com.assu.study.chap12_1.event;

import com.assu.study.chap12_1.service.EventService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

// 구독 클래스
@Slf4j
@Component
public class UserEventListener implements ApplicationListener<UserEvent> {  // ApplicationListener 의 제네릭 클래스 타입은 구독할 이벤트의 클래스 타입

    // 기능을 실행할 스프링 빈 주입
    // UserEventListener 구독 클래스는 UserEvent 를 구독하는 기능만 담당하고, 실제 이벤트 처리는 별도의 클래스(EventService)에 위임
    private final EventService eventService;

    public UserEventListener(EventService eventService) {
        this.eventService = eventService;
    }

    @Async
    @Override
    public void onApplicationEvent(UserEvent event) {
        if (UserEvent.Type.CREATE == event.getType()) {
            log.info("Listen CREATE event. {}, {}", event.getUserId(), event.getEmail());
            // 메일 발송
            eventService.sendEventEmail(event.getEmail());
        } else if (UserEvent.Type.DELETE == event.getType()) {
            log.info("Listen DELETE event.");
        } else {
            log.error("Unsupported event type. {}", event.getType());
        }

        eventService.sendEventEmail2(event.getEmail());
    }
}

package com.assu.study.chap12_1.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class EventService {
    public void sendEventEmail(String email) {
        // 이메일 발송
        log.info("Send Email~, {}", email);
    }

    public void sendEventEmail2(String email) {
        // 이메일 발송
        log.info("Send Email2~, {}", email);
    }
}

package com.assu.study.chap12_1.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@EnableAsync    // 비동기 기능 활성화
@Configuration
public class AsyncExecutionConfig implements AsyncConfigurer {
    // 프레임워크가 스레드 풀을 설정할 때 사용하는 콜백 메서드
    @Override
    public Executor getAsyncExecutor() {
        return getExecutor();
    }

    private Executor getExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        // 기본 개수는 10개
        threadPoolTaskExecutor.setCorePoolSize(10);
        // 최대 10개까지 늘어남
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setThreadNamePrefix("asyncExecutor-");
        // 컨테이너가 모든 속성값을 적용한 후 initialize() 호출
        threadPoolTaskExecutor.afterPropertiesSet();
        return threadPoolTaskExecutor;
    }

    @Bean("asyncExecutor")
    public Executor asyncExecutor() {
        return getExecutor();
    }
}

package com.assu.study.chap12_1.server;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;

@Slf4j
public class ApplicationEventListener implements ApplicationListener<ApplicationReadyEvent> {
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        long timestamp = event.getTimestamp();
        LocalDateTime eventTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault());

        log.info("Application12_1 is Ready. {}", eventTime);
    }
}

package org.springframework.transaction.event;

public enum TransactionPhase {
	BEFORE_COMMIT,  // 트랜잭션 커밋 직전에 이벤트 처리
	AFTER_COMMIT, // 트랜잭션을 커밋한 후 이벤트 처리 (디폴트 값)
	AFTER_ROLLBACK, // 트랜잭션을 롤백한 후 이벤트 처리
	AFTER_COMPLETION  // 트랜잭션을 롤백하거나 커밋한 후 이벤트 처리
}

package org.springframework.transaction.event;

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@EventListener
public @interface TransactionalEventListener {

  // 기본값은 AFTER_COMMIT 이므로 커밋이 정상적으로 실행되면 구독 메서드 실행됨 (롤백에서는 실행안됨)
	TransactionPhase phase() default TransactionPhase.AFTER_COMMIT;

  // 구독 메서드를 실행하는 단계에서 트랜잭션이 없으면 구독 메서드 실행 여부 결정, false 일 경우 실행 중인 트랜잭션이 없을 때에는 구독 메서드 실행안함
	boolean fallbackExecution() default false;

  // 구독할 특정 이벤트 메시지 클래스의 클래스 타입 설정
	@AliasFor(annotation = EventListener.class, attribute = "classes")
	Class<?>[] classes() default {};

  // ...
}

// 구독 클래스
@Slf4j
@Component
public class HotelEventListener {

  // ...

  @Async
  @Order(1)
  // 하나 이상의 클래스 타입 설정 가능
  // 정의된 이벤트 메시지가 게시되면 @EventListener 애너테이션이 정의된 메서드가 이벤트를 구독하고 실행함
  @TransactionalEventListener(classes = HotelCreateEvent.class, fallbackExecution = true)
  // 구독한 이벤트 객체를 메서드의 인자로 받을 수 있음
  public void handleHotelCreateEvent(HotelCreateEvent hotelCreateEvent) {
    // ...
  }
}