Order order = entityManager.find(Order.class, orderNo, LockModeType.PESSIMISTIC_WRITE);

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

import jakarta.persistence.LockModeType;
import org.springframework.data.jpa.repository.Lock;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.query.Param;

import java.util.Optional;

public interface MemberRepository extends Repository<Member, MemberId> {
    Optional<Member> findById(MemberId memberId);

    // 선점 잠금 방식 이용
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("select m from Member m where m.id = :id")
    Optional<Member> findByIdForUpdate(@Param("id") MemberId memberId);
}

Map<String, Object> hints = new HashMap<>();

// 최대 대기 시간 2초
hints.put("javax.persistence.lock.timeout", 2000);
Order order = entityManager.find(Order.class, orderNo, LockModeType.PESSIMISTIC_WRITE, hints);

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

import jakarta.persistence.LockModeType;
import jakarta.persistence.QueryHint;
import org.springframework.data.jpa.repository.Lock;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.jpa.repository.QueryHints;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.query.Param;

import java.util.Optional;

public interface MemberRepository extends Repository<Member, MemberId> {
    Optional<Member> findById(MemberId memberId);

    // 선점 잠금 방식 이용
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    // 잠금을 구하는 대기 시간을 2초로 지정
    @QueryHints({
            @QueryHint(name = "javax.persistenct.lock.timeout", value = "2000")
    })
    @Query("select m from Member m where m.id = :id")
    Optional<Member> findByIdForUpdate(@Param("id") MemberId memberId);
}

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

// 주문 (애그리거트 루트)
@Entity
@Table(name = "purchase_order")
@Access(AccessType.FIELD)
public class Order {
    // ...

    // 비선점 잠금 방식을 이용하기 위한 필드
    @Version
    private long version;
            
    // ...
}

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

import com.assu.study.order.NoOrderException;
import com.assu.study.order.command.domain.Order;
import com.assu.study.order.command.domain.OrderNo;
import com.assu.study.order.command.domain.OrderRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Optional;

@Service
public class ChangeShippingService {
    private OrderRepository orderRepository;

    @Transactional
    public void changeShipping(ChangeShippingRequest changeReq) {
        Optional<Order> oOrder = orderRepository.findById(new OrderNo(changeReq.getNumber()));
        Order order = oOrder.orElseThrow(() -> new NoOrderException());
        order.changeShippingInfo(changeReq.getShippingInfo());
    }
}

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

import com.assu.study.order.command.domain.ShippingInfo;
import lombok.AllArgsConstructor;
import lombok.Getter;

@AllArgsConstructor
@Getter
public class ChangeShippingRequest {
    private String number;
    private ShippingInfo shippingInfo;
}

@Controller
public class OrderController {
    private ChangeShippingService changeShippingService;
    
    @PostMapping("/changeShipping")
    public String changeShippingInfo(ChangeShippingRequest changeReq) {
        try {
            changeShippingService.changeShipping(changeReq);
            return "success";
        } catch (OptimisticLockingFailureException e) {
            // 누군가 먼저 같은 주문 애그리거트를 수정하여 트랜잭션이 충돌했다는 메시지 노출
            return "changeShippingConflict";
        }
    }
}

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

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;

@NoArgsConstructor
@AllArgsConstructor
@Getter
public class StartShippingRequest {
  private String orderNumber;
  private long version;
}

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

import com.assu.study.common.VersionConflictException;
import com.assu.study.order.NoOrderException;
import com.assu.study.order.command.domain.Order;
import com.assu.study.order.command.domain.OrderNo;
import com.assu.study.order.command.domain.OrderRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Optional;

@RequiredArgsConstructor
@Service
public class StartShippingService {
  private final OrderRepository orderRepository;

  @PreAuthorize("hasRole('ADMIN')")
  @Transactional
  public void startShipping(StartShippingRequest req) {
    Optional<Order> oOrder = orderRepository.findById(new OrderNo(req.getOrderNumber()));
    Order order = oOrder.orElseThrow(() -> new NoOrderException());

    // 애그리거트 조회 시점의 버전과 수정 시점의 버전이 일치하지 않으면
    // 누군가 먼저 주문 애그리거트를 수정한 것이므로 예외 발생
    if (!order.matchVersion(req.getVersion())) {
      throw new VersionConflictException();
    }
    order.startShipping();
  }
}

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

import com.assu.study.common.jpa.MoneyConverter;
import com.assu.study.common.model.Money;
import jakarta.persistence.*;

import java.time.LocalDateTime;
import java.util.List;

// 주문 (애그리거트 루트)
@Entity
@Table(name = "purchase_order")
@Access(AccessType.FIELD)
public class Order {
    // 비선점 잠금 방식을 이용하기 위한 필드
    @Version
    private long version;

    // ...

    // 출고 전 상태인지 검사
    private void verifyNotYetShipped() {
      if (!isNotYetShipped()) {
        throw new AlreadyShippedException();
      }
    }
  
    // 아직 결제 전이거나 상품 준비중이면 아직 출고되지 않은 상태임
    public boolean isNotYetShipped() {
      return state == OrderState.PAYMENT_WAITING || state == OrderState.PREPARING;
    }
  
    // 비선점 잠금 방식으로 정보 수정 시 애그리거트 버전 정보가 일치하는지 확인
    public boolean matchVersion(long version) {
        return this.version == version;
    }

    // 배송 출발로 상태 변경
    public void startShipping() {
      verifyNotYetShipped();
      verifyNotCanceled();
    }
  
    private void verifyNotCanceled() {
      if (state == OrderState.CANCELED) {
        throw new OrderAlreadyCanceledException();
      }
    }
}

package com.assu.study.common;

public class VersionConflictException extends RuntimeException {
}

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

public class AlreadyShippedException extends RuntimeException {
}

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

public class OrderAlreadyCanceledException extends RuntimeException {
}

package com.assu.study.admin.ui;

import com.assu.study.common.VersionConflictException;
import com.assu.study.order.command.application.StartShippingRequest;
import com.assu.study.order.command.application.StartShippingService;
import lombok.RequiredArgsConstructor;
import org.springframework.dao.OptimisticLockingFailureException;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

@RequiredArgsConstructor
@Controller
public class AdminOrderController {
  private final StartShippingService startShippingService;

  // 배송 시작으로 상태 변경 시
  @PostMapping("/admin/orders/{orderNo}/shipping")
  public String startShippingOrder(@PathVariable("orderNo") String orderNo,
                                   @RequestParam("version") long version) {
    try {
      startShippingService.startShipping(new StartShippingRequest(orderNo, version));
      return "admin/adminOrderShipped";
    } catch (OptimisticLockingFailureException | VersionConflictException e) {
      // OptimisticLockingFailureException: 누군가 거의 동시에 애그리거트를 수정함 (프레임워크에서 제공하는 예외)
      // VersionConflictException: 이미 누군가 애그리거트를 수정함 (커스텀 예외)
      return "admin/adminOrderLockFail";
    }
  }
}

@RequiredArgsConstructor
@Service
public class StartShippingService {
  private OrderRepository orderRepository;

  @PreAuthorize("hasRole('ADMIN')")
  @Transactional
  public void startShipping(StartShippingRequest req) {
    Optional<Order> oOrder = orderRepository.findById(new OrderNo(req.getOrderNumber()));
    Order order = oOrder.orElseThrow(() -> new NoOrderException());

    // 애그리거트 조회 시점의 버전과 수정 시점의 버전이 일치하지 않으면
    // 누군가 먼저 주문 애그리거트를 수정한 것이므로 예외 발생
    if (!order.matchVersion(req.getVersion())) {
      throw new OptimisticLockingFailureException("version conflict");
    }
    order.startShipping();
  }
}

@Repository
public class JpaOrderRepository implements OrderRepository {
    @PersistenceContext
    private EntityManager entityManager;
    
    @Override 
    public Order findByOptimisticLockMode(OrderNo id) {
        return entityManager.find(Order.class, id, LockModeType.OPTIMISTIC_FORCE_INCREMENT);
    }
}

package com.assu.study.lock;

// 오프라인 선점 잠금을 위한 인터페이스
public interface LockManager {
  LockId tryLock(String type, String id) throws LockException;

  void checkLock(LockId lockId) throws LockException;

  void releaseLock(LockId lockId) throws LockException;

  void extendLockExpiration(LockId lockId, long inc) throws LockException;
}

package com.assu.study.lock;

import lombok.AllArgsConstructor;
import lombok.Getter;

@AllArgsConstructor
@Getter
public class LockId {
    private String value;
}

package com.assu.study.lock;

import lombok.NoArgsConstructor;

@NoArgsConstructor
public class LockException extends RuntimeException {
    public LockException(String message) {
        super(message);
    }

    public LockException(Throwable cause) {
        super(cause);
    }
}

// 서비스는 잠금 ID 를 리턴함
public DataAndLockId getDataWithLock(Long id) {
  // 오프라인 선점 잠금 시도
  LockId lockId = lockManager.tryLock("data", id);
  
  // 기능 실행
  Data data = someDao.select(id);
  return new DataAndLockId(data, lockId);
}

@GetMapping("/some/edit/{id}")
public String editForm(@PathVariable("id") Long id, ModelMap map) {
    DataAndLockId dl = dataService.getDataWithLock(id);
    model.addAttribute("data", dl.getData());
    
    // 잠금 해제에 사용할 LockId 를 모델에 추가
    model.addAttribute("lockId", dl.getLockId());
    
    return "editForm";
}

// 서비스는 잠금을 해제한다.
public void edit(EditRequest editReq, LockId lockId) {
  // 잠금 선점 확인
  lockManager.checkLock(lockId);
  
  // 기능 실행
  // ...
  
  // 잠금 해제
  lockManager.releaseLock(lockId);
}

// 서비스 호출 시 잠금 ID 함께 전달
@PostMapping("/some/edit/{id}")
public String edit(@PathVariable("id") Long id,
                   @ModelAttribute("editReq") EditRequest editReq,
                   @RequestParam("lockId") String lockId) {
    editReq.setId(id);
    
    // lockId 전달
    someEditService.edit(editReq, new LockId(lockId));
    model.addAttribute("data", data);
    return "success";
}

package com.assu.study.lock;

import lombok.AllArgsConstructor;
import lombok.Getter;

// locks 테이블의 데이터를 담는 클래스
@AllArgsConstructor
@Getter
public class LockData {
    private String type;
    private String id;
    private String lockId;
    private long timestamp;

    // 잠금 유효시간이 지났는지 판단
    public boolean isExpired() {
        return timestamp < System.currentTimeMillis();
    }
}

package com.assu.study.lock;

import lombok.RequiredArgsConstructor;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.sql.Timestamp;
import java.util.List;
import java.util.Optional;
import java.util.UUID;

@RequiredArgsConstructor
@Component
public class SpringLockManager implements LockManager {
    private final JdbcTemplate jdbcTemplate;
    // 잠금 유효 시간은 5분
    private int LOCK_TIMEOUT = 5 * 60 * 1000;

    // locks 테이블에서 조회한 데이터를 LockData 로 매핑하기 위한 RowMapper
    private RowMapper<LockData> lockDataRowMapper = (rs, rowNum) ->
            new LockData(rs.getString(1), rs.getString(2),
                    rs.getString(3), rs.getTimestamp(4).getTime());

    // type, id 에 대한 잠금 시도
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public LockId tryLock(String type, String id) throws LockException {
        // 해당 type, id 에 대한 잠금이 존재하는지 확인
        checkAlreadyLocked(type, id);

        // 새로운 lockId 생성
        // 매번 새로운 lockId 를 생성해야 하므로 UUID 이용
        LockId lockId = new LockId(UUID.randomUUID().toString());

        // 잠금 생성
        locking(type, id, lockId);

        // lockId 리턴
        return lockId;
    }

    // 해당 type, id 에 대한 잠금이 존재하는지 확인
    private void checkAlreadyLocked(String type, String id) {
        List<LockData> locks = jdbcTemplate.query(
                "select * from locks where type = ? and id = ?",
                lockDataRowMapper, type, id);

        // 유효 시간이 지난 데이터 처리
        Optional<LockData> oLockData = handelExpiration(locks);

        // 유효 시간이 지나지 않은 LockData 가 존재하면 예외 발생
        if (oLockData.isPresent()) {
            throw new AlreadyLockedException();
        }
    }

    // 잠금 유효 시간이 지나면 해당 데이터를 삭제 후 빈 Optional 리턴
    // 유효 시간이 지나지 않았으면 해당 LockData 를 가진 Optional 리턴
    private Optional<LockData> handelExpiration(List<LockData> locks) {
        if (locks.isEmpty()) {
            return Optional.empty();
        }

        LockData lockData = locks.get(0);

        if (lockData.isExpired()) {
            jdbcTemplate.update(
                    "delete from locks where type = ? and id = ?",
                    lockData.getType(), lockData.getId());
            return Optional.empty();
        } else {
            return Optional.of(lockData);
        }
    }

    // 잠금을 위해 locks 테이블에 데이터 삽입
    // 삽입된 데이터가 없으면 예외 발생
    // 동일한 PK 나 lockId 를 가진 데이터가 이미 존재하여 DuplicateKeyException 이 발생하면 예외 발생
    private void locking(String type, String id, LockId lockId) {
        try {
            int updatedCount = jdbcTemplate.update(
                    "insert into locks value (?, ?, ?, ?)",
                    type, id, lockId.getValue(), new Timestamp(getExpirationTime()));
            if (updatedCount == 0) {
                throw new LockingFailException();
            }
        } catch (DuplicateKeyException e) {
            throw new LockingFailException(e);
        }
    }

    // 현재 시간 기준으로 잠금 유효 시간(5분) 이후 시간을 유효 시간으로 생성
    private long getExpirationTime() {
        return System.currentTimeMillis() + LOCK_TIMEOUT;
    }

    // 잠금이 유효한지 확인한 후 유효하지 않으면 예외 발생
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void checkLock(LockId lockId) throws LockException {
        Optional<LockData> lockData = getLockData(lockId);
        if (!lockData.isPresent()) {
            throw new NoLockException();
        }
    }

    // lockId 에 해당하는 LockData 를 구한 후 유효 시간이 지난 LockData 처리
    private Optional<LockData> getLockData(LockId lockId) {
        List<LockData> locks = jdbcTemplate.query(
                "select * from locks where lockid = ?",
                lockDataRowMapper, lockId.getValue());
        return handelExpiration(locks);
    }

    // lockId 에 해당하는 잠금 유효 시간은 inc 만큼 증가시킴
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void extendLockExpiration(LockId lockId, long inc) throws LockException {
        Optional<LockData> oLockData = getLockData(lockId);
        LockData lockData = oLockData.orElseThrow(() -> new NoLockException());
        jdbcTemplate.update(
                "update locks set expiration_time = ? where type = ? and id = ?",
                new Timestamp(lockData.getTimestamp() + inc),
                lockData.getType(), lockData.getId());
    }

    // lockId 에 해당하는 잠금 데이터 삭제
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void releaseLock(LockId lockId) throws LockException {
        jdbcTemplate.update("delete from locks where lockid = ?", lockId.getValue());
    }
}

package com.assu.study.lock;

public class AlreadyLockedException extends LockException {
}

package com.assu.study.lock;

import lombok.NoArgsConstructor;

@NoArgsConstructor
public class LockingFailException extends LockException {
    public LockingFailException(Exception cause) {
        super(cause);
    }
}

package com.assu.study.lock;

public class NoLockException extends RuntimeException {
}