@Target({ElementType.TYPE, ElementType.METHOD}) // 클래스와 메서드 선언부에 @Transactional 선언 가능
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Reflective
public @interface Transactional {
  // ...
}

package org.springframework.transaction.annotation;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Reflective
public @interface Transactional {
  
  // 스프링 애플리케이션에 여러 개의 TransactionManager 설정이 있따면 사용할 TransactionManager 의 스프링 빈 이름 설정
  // 스프링 애플리케이션에 TransactionManager 가 하나만 있다면 생략해도 됨
  @AliasFor("transactionManager")
  String value() default "";

  @AliasFor("value")
  String transactionManager() default "";

  String[] label() default {};

  // 스프링 애플리케이션 내에서 트랜잭션 전파 설정
  // 디폴트는 Propagation.REQUIRED
  Propagation propagation() default Propagation.REQUIRED;

  // 데이터베이스의 트랜잭션 격리 수준 설정
  // 여러 트랜잭션이 공통된 하나의 데이터를 동시에 조작할 때 어떻게 처리할 지 설정
  Isolation isolation() default Isolation.DEFAULT;

  // 트랜잭션에 대한 타임아웃 (s) 설정
  // 기본값은 무제한이지만 데이터베이스에 타임아웃이 설정되어 있다면 그 값을 따름
  int timeout() default -1;

  String timeoutString() default "";

  // 읽기 전용 설정
  // readonly=true 로 설정하면 읽기 전용 트랜잭션을 시작함
  // 읽기 전용 설정을 하면 JPA/Hibernate 의 EntityManager 가 읽기 전용으로 설정되어 성능 향상
  // 기본값은 false 
  boolean readOnly() default false;

  // 롤백 처리할 예외 클래스를 rollbackFor 속성에 정의 가능
  // 대상 메서드를 실행할 때 발생할 수 있는 예외 클래스를 설정하면 해당 예외 클래스에 대해 롤백함
  Class<? extends Throwable>[] rollbackFor() default {};
  String[] rollbackForClassName() default {};

  // 대상 메서드가 던질 수 있는 예외 메서드 중 설정된 예외 클래스에 대해서는 롤백에서 제외
  // 즉, RuntimeException 을 상속받는 예외 중 롤백 대상에서 제외하고 싶은 경우 사용
  Class<? extends Throwable>[] noRollbackFor() default {};
  String[] noRollbackForClassName() default {};
}

package com.assu.stury.chap08.service;

import com.assu.stury.chap08.controller.HotelCreateRequest;
import com.assu.stury.chap08.controller.HotelCreateResponse;
import com.assu.stury.chap08.domain.HotelEntity;
import com.assu.stury.chap08.domain.HotelRoomEntity;
import com.assu.stury.chap08.domain.HotelRoomType;
import com.assu.stury.chap08.repository.HotelRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

@Service
public class HotelService {
  private final HotelRepository hotelRepository;

  public HotelService(HotelRepository hotelRepository) {
    this.hotelRepository = hotelRepository;
  }

  // 메서드 내부에 데이터를 생성하는 save() 가 있으므로 readOnly 를 false 로 설정 (디폴트라 안해도 되긴 함)
  @Transactional(readOnly = false, isolation = Isolation.SERIALIZABLE)
  public HotelCreateResponse createHotel(HotelCreateRequest createRequest) {
    HotelEntity hotelEntity = HotelEntity.of(
        createRequest.getName(),
        createRequest.getAddress(),
        createRequest.getPhoneNumber()
    );

    int roomCount = createRequest.getRoomCount();
    List<HotelRoomEntity> hotelRoomEntitis = IntStream.range(0, roomCount)  // IntStream 반환
        .mapToObj(i -> HotelRoomEntity.of("ROOM-" + i, HotelRoomType.DOUBLE, BigDecimal.valueOf(100)))  // Stream<HotelRoomEntity> 반환
        .collect(Collectors.toList());

    hotelEntity.addHotelRooms(hotelRoomEntitis);

    hotelRepository.save(hotelEntity);
    return HotelCreateResponse.of(hotelEntity.getHotelId());
  }
}

package com.assu.stury.chap08.controller;

import lombok.Getter;
import lombok.Setter;

// DTO
@Getter
@Setter
public class HotelCreateRequest {
  private String name;
  private String address;
  private String phoneNumber;
  private Integer roomCount;
}

package com.assu.stury.chap08.controller;

import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

// DTO
@Getter
@Setter
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class HotelCreateResponse {
  private Long hotelId;

  public static HotelCreateResponse of(Long hotelId) {
    HotelCreateResponse response = new HotelCreateResponse();
    response.hotelId = hotelId;
    return response;
  }
}

package com.assu.stury.chap08.domain;

import com.assu.stury.chap08.domain.converter.HotelStatusConverter;
import jakarta.persistence.*;
import lombok.Getter;

import java.util.ArrayList;
import java.util.List;

//@NoArgsConstructor
// @EqualsAndHashCode
// @ToString
@Getter
@Table(name = "hotels")
@Entity(name = "hotels")
public class HotelEntity extends AbstractManageEntity {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "hotel_id")
  private Long hotelId;

//  @Column(name = "status")
//  private HotelStatus status;

//  @Column
//  @Enumerated(value = EnumType.STRING)
//  private HotelStatusTemp status;

  @Column(name = "status")
  @Convert(converter = HotelStatusConverter.class)
  private HotelStatus status;

  @Column
  private String name;

  @Column
  private String address;

  @Column(name = "phone_number")
  private String phoneNumber;

  @Column(name = "room_count")
  private Integer roomCount;

  @OneToMany(cascade = CascadeType.PERSIST)
  @JoinColumn(name = "hotels_hotel_id", referencedColumnName = "hotel_id")
  private List<HotelRoomEntity> hotelRoomEntities;

  // 반드시 AbstractManageEntity 의 생성자를 호출해야 함
  public HotelEntity() {
    super();
    this.hotelRoomEntities = new ArrayList<>();
  }


  public static HotelEntity of(String name, String address, String phoneNumber) {
    HotelEntity hotelEntity = new HotelEntity();

    hotelEntity.name = name;
    hotelEntity.status = HotelStatus.READY;
    hotelEntity.address = address;
    hotelEntity.phoneNumber = phoneNumber;
    hotelEntity.roomCount = 0;

    return hotelEntity;
  }

  public void addHotelRooms(List<HotelRoomEntity> hotelRoomEntities) {
    this.roomCount += hotelRoomEntities.size();
    this.hotelRoomEntities.addAll(hotelRoomEntities);
  }
//  public enum HotelStatusTemp {
//    OPEN, CLOSED, READY
//  }
}

package com.assu.stury.chap08.domain;

import com.assu.stury.chap08.domain.converter.HotelRoomTypeConverter;
import jakarta.persistence.*;
import lombok.Getter;

import java.math.BigDecimal;

// @EqualsAndHashCode
// @ToString
@Getter
@Entity(name = "hotelRooms")
@Table(name = "hotel_rooms")
public class HotelRoomEntity extends AbstractManageEntity {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "hotel_room_id")
  private Long hotelRoomId;

  @Column(name = "hotels_hotel_id")
  private Long hotelId;

  @Column(name = "room_number")
  private String roomNumber;

  @Column(name = "room_type")
  @Convert(converter = HotelRoomTypeConverter.class)
  private HotelRoomType roomType;

  @Column(name = "original_price")
  private BigDecimal originalPrice;

  // 반드시 AbstractManageEntity 의 생성자를 호출해야 함
  public HotelRoomEntity() {
    super();
  }

  public static HotelRoomEntity of(String roomNumber, HotelRoomType hotelRoomType, BigDecimal originalPrice) {
    HotelRoomEntity hotelRoomEntity = new HotelRoomEntity();
    hotelRoomEntity.roomNumber = roomNumber;
    hotelRoomEntity.roomType = hotelRoomType;
    hotelRoomEntity.originalPrice = originalPrice;

    return hotelRoomEntity;
  }
}

package com.assu.stury.chap08.domain;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;

import java.util.Arrays;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;

public enum HotelRoomType {
  SINGLE("single", 0),  // HotelRoomType.SINGLE 열거형 상수의 내부 속성인 param 값은 'single' 문자열
  DOUBLE("double", 1),
  TRIPLE("triple", 2),
  QUAD("quad", 3);

  private final String param;
  private final Integer value;

  // Map 의 key 는 HotelRoomType 열거형의 param 로, Map 의 value 는 HotelRoomType 의 상수로 저장
  // 빠르게 변환하고자 static 구문으로 클래스가 로딩될 때 Map 객체를 미리 생성함
  private static final Map<String, HotelRoomType> parmaMap = Arrays.stream(HotelRoomType.values())
      .collect(Collectors.toMap(
          HotelRoomType::getParam,
          Function.identity())
      );

  private static final Map<Integer, HotelRoomType> valueMap = Arrays.stream(HotelRoomType.values())
      .collect(Collectors.toMap(
          HotelRoomType::getValue,
          Function.identity())
      );

  // 모든 enum 상수 선언 시 JSON 객체 값으로 사용될 값을 인수로 입력
  // SINGLE 상수는 문자열 'single' 이 param 값으로 할당, 0 이 value 값으로 할당
  HotelRoomType(String param, Integer value) {
    this.param = param;
    this.value = value;
  }

  // PARAM 인자를 받아서 paramMap 의 key 와 일치하는 enum 상수 리턴
  // 언마셜링(JSON -> 객체) 과정에서 JSON 속성값이 single 이면 fromValue 메서드가 HotelRoomType.SINGLE 로 변환
  @JsonCreator  // 언마셜링 과정에서 값 변환에 사용되는 메서드 지정
  public static HotelRoomType fromParma(String param) {
    return Optional.ofNullable(param) // Optional<String> 반환
        .map(parmaMap::get) // Optional<HotelRoomType> 반환
        .orElseThrow(() -> new IllegalArgumentException("param is not valid."));
  }

  public static HotelRoomType fromValue(Integer value) {
    return Optional.ofNullable(value) // Optional<Integer> 반환
        .map(valueMap::get) // Optional<HotelRoomType> 반환
        .orElseThrow(() -> new IllegalArgumentException("value is not valid"));
  }

  // enum 상수에 정의된 param 변수값 리턴 (= getParam() 이 리턴하는 문자열이 JSON 속성값으로 사용됨)
  // 마셜링 (객체 -> JSON) 과정에서 HotelRoomType.SINGLE 이 "single" 로 변환됨
  @JsonValue  // 마셜링 과정에서 값 변환에 사용되는 메서드 지정, 이 애너테이션이 있으면 마셜링 때 toString() 이 아닌 getParam() 사용
  public String getParam() {
    return param;
  }

  public Integer getValue() {
    return value;
  }
}

package com.assu.stury.chap08.domain.converter;

import com.assu.stury.chap08.domain.HotelRoomType;
import jakarta.persistence.AttributeConverter;

import java.util.Objects;

// @Component
public class HotelRoomTypeConverter implements AttributeConverter<HotelRoomType, Integer> {

  // 데이터베이스에서 사용할 데이터로 변환
  // HotelRoomType 의 value 값을 리턴하는 getValue() 리턴
  @Override
  public Integer convertToDatabaseColumn(HotelRoomType attribute) {
    if (Objects.isNull(attribute)) {
      return null;
    }

    return attribute.getValue();
  }

  // 데이터베이스에 저장된 값을 HotelRoomType 열거형으로 변환
  // 데이터베이스에 저장된 Integer 값과 매핑되는 HotelRoomType 상수를 리턴하는 fromValue() 리턴
  @Override
  public HotelRoomType convertToEntityAttribute(Integer dbData) {
    if (Objects.isNull(dbData)) {
      return null;
    }

    return HotelRoomType.fromValue(dbData);
  }
}

package com.assu.stury.chap08.repository;

import com.assu.stury.chap08.domain.HotelRoomEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface HotelRoomRepository extends JpaRepository<HotelRoomEntity, Long> {

  List<HotelRoomEntity> findByHotelId(Long hotelId);
}

package com.assu.stury.chap08.service;

import com.assu.stury.chap08.controller.HotelCreateRequest;
import com.assu.stury.chap08.controller.HotelCreateResponse;
import com.assu.stury.chap08.domain.HotelEntity;
import com.assu.stury.chap08.domain.HotelRoomEntity;
import com.assu.stury.chap08.repository.HotelRepository;
import com.assu.stury.chap08.repository.HotelRoomRepository;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestPropertySource;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@SpringBootTest
@Transactional
@TestPropertySource(locations = "classpath:application-test.properties")
class HotelServiceTest {

  @Autowired
  private HotelService hotelService;

  @Autowired
  private HotelRepository hotelRepository;

  @Autowired
  private HotelRoomRepository hotelRoomRepository;

  @Test
  void createHotel() {
    // given
    HotelCreateRequest request = new HotelCreateRequest();
    request.setName("test");
    request.setAddress("test address");
    request.setPhoneNumber("555555");
    request.setRoomCount(10);

    // when
    HotelCreateResponse response = hotelService.createHotel(request);
    HotelEntity hotelEntity = hotelRepository.findById(response.getHotelId()).orElse(null);
    List<HotelRoomEntity> hotelRoomEntities = hotelRoomRepository.findByHotelId(response.getHotelId());

    //Then
    Assertions.assertNotNull(hotelEntity);
    Assertions.assertEquals(request.getName(), hotelEntity.getName());
    Assertions.assertEquals(request.getAddress(), hotelEntity.getAddress());
    Assertions.assertEquals(request.getPhoneNumber(), hotelEntity.getPhoneNumber());
    Assertions.assertEquals(request.getRoomCount(), hotelEntity.getRoomCount());

    Assertions.assertEquals(request.getRoomCount(), hotelRoomEntities.size());
  }
}

@Service
public class HotelService {
  private final HotelRepository hotelRepository;

  public HotelService(HotelRepository hotelRepository) {
    this.hotelRepository = hotelRepository;
  }

  // 메서드 내부에 데이터를 생성하는 save() 가 있으므로 readOnly 를 false 로 설정 (디폴트라 안해도 되긴 함)
  @Transactional(readOnly = false, isolation = Isolation.SERIALIZABLE)
  public HotelCreateResponse createHotel(HotelCreateRequest createRequest) {
    // ...
  }

  // this 키워드를 사용하여 @Transactional 애너테이션이 걸려 있는 내부 메서드 호출하는 예시
  public List<HotelCreateResponse> createHotels(List<HotelCreateRequest> createRequests) {
    return createRequests.stream()
        .map(createRequest -> this.createHotel(createRequest))  // this 를 이용하여 createHotel 호출
        .collect(Collectors.toList());
  }
}

@AutoWired
@Service
public class HotelService {
  @Autowired
  private HotelService hotelService;

  // ...
}

@Service
public class HotelService {
//  @Autowired
//  private HotelService hotelService;

  @Autowired
  private ApplicationContext applicationContext;

  private HotelService self;

  @PostConstruct
  private void init() {
    self = applicationContext.getBean(HotelService.class);
  }

  // ...
}

public List<HotelCreateResponse> createHotels(List<HotelCreateRequest> createRequests) {
  return createRequests.stream()
      .map(createRequest -> self.createHotel(createRequest))
      .collect(Collectors.toList());
}