[도메인주도개발시작하기] Chapter8-애그리거트 트랜잭션 관리

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

import org.springframework.data.jpa.repository.Lock;
import javax.persistence.LockModeType;

public interface MemberRepository extends Repository<Member, MemberId> {

  @Lock(LockModeType.PESSIMITIC_WRITE
  @Query("select m from Member m where m.id = :id")
  Optional<Member> findByIdForUpdate(@Param("id") MemberId memberId);
}

Map<String, Object> hints = new HashMap<>();
hints.put("javax.persistence.lock.timeout", 2000);
Order order = entityManager.find(Order.class, orderNo, LockModeType.PESSIMISTIC_WRITE, hints);

import org.sprintframework.data.jpa.repository.QueryHints;
import javax.persistence.QueryHint;

public interface MemberRepository extends Repository<Member, MemberId> {
  @Lock(LockModeType.PESSIMISTIC_WRITE)
  @QueryHints({
    @QueryHint(name = "javax.persistence.lock.timeout", value = "2000")
  })
  @Query("select m from Member m where m.id = :id")
  Optional<Member> findByIdForUpdate(@Param("id") MemberId memberId);
}

UPDATE aggtable SET version = version + 1, colx = ?, coly = ?
WHERE aggid = ? and version = 현재 버젼

@Entity
@Table(name = "purchase_order")
@Access(AccessType.FIELD)
public class Order {
  @EmbeddedId
  private OrderNo number;

  @Version
  private long version;

  ...
}

UPDATE purchagse_order SET ...생략, version = version + 1
WHERE number = ? and version = 10

@Controller
public class OrderController {
	...
	@RequestMapping(value = "/changeShipping", method = RequestMethod.POST)
	public String changeShipping(ChangeShippingRequest changeReq) {
		try {
			changeShippingService.changeShipping(changeReq);
			return "changeShippingSuccess";
		} catch(optimisticLockingFailureException ex) {
				// 누군가 먼저 같은 주문 애그리거트를 수정했으므로, 
				// 트랜잭션 충돌이 일어났다는 메시지를 보여준다. 
				return "changeShippingExConflic";
		}
}

public class StartShippingRequest {
  private String orderNumber;
  private long version;


  ...생성자, getter
}

public class StartShippingService {
  @PreAuthorize("hasRole('ADMIN')")
  @Transactional
  public void startShipping(StartShippingRequest req) {
    Order order = orderRepository.findById(new OrderNo(req.getOrderNumber()));
    checkOrder(order);
    if (!order.matchVersion(req.getVersion())) {
      throw new VersionConfilictException();
    }
    order.startShipping();
  }
}

@Controller
public class OrderAdminController {
	private StartShippingService startShippingService;

	@RequestMapping(value = "/startShipping", method = RequestMethod.POST)
	public String startShipping(StartShippingRequest startReq) {
		try {
			startShippingService.startShipping(startReq);
			return "shippingStarted";
		} catch(OptimisticLockingFailureException | VersionConflicException ex) {
			// 트랜잭션 충돌
			return "startShippingTxConflict";
		}
	}
	... 

public void startShipping(StartShippingRequest req) {
  Order order = orderRepository.findById(new OrderNo(req.getOrderNumber()));
  checkOrder(order);
  if (!order.matchVersion(req.getVersion())) {
    // 프레임워크가 제공하는 비선점 트랜잭션 충돌 관련 익셉션 사용
    throw new OptimisticLockingFailureException("version conflict);
  }
  order.startShipping();
}

@Repository
public class JpaOrderRepository implements OrderRepository {
	@PersistenceContext
	private EntityMangager entityManager;

	@Override
	public Order findbyIdOptimisticLockMode(OrderNo id) {
		return entityManager.find(Order.class, id
				LockModeType.OPTIMISTTIC_FORCE_INCREMENT);
	}
...

// LockManager 인터페이스
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;
}

// LockId 클래스
public class LockId {
  private String value;

  public LockId(String value) {
    this.value = value;
  }

	public String getValue() {
	  return value;
  }
}

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

// 컨트롤러: 서비스가 리턴한 잠금ID를 모델로 뷰에 전달
@RequestMapping("/some/edit/{id}")
public String editForm(@PathVariable("id") Long id, ModelMap model) {
    DataAndLockId dl = dataService.getDataWithLock(id);
    model.addAttribute("data", dl.getData());
    // 3. 잠금 해제에 사용할 LockId를 모델에 추가
    model.addAttribute("lockId", dl.getLockId());
    return "editForm"
}

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

@RequestMapping(value = "/some/edit/{id}", method = RequestMethod.POST)
public String edit(@PathVariable("id") Long id, 
                   @ModelAttribute("editReq") EditRequest editReq, 
                   @RequestMapping("lid") String lockIdValue) {
    editReq.setId(id);
    someEditService.edit(editReq, new LockId(lockIdValue));
    model.addAttribute("data", data);

    return "editSuccess";
}

public class LockData {
    private String type;
    private String id;
    private String lockId;
    private long timestamp;

    public LockData(String type, String id, String lockId, long timestamp) {
        this.type = type;
        this.id = id;
        this.lockId = lockId;
        this.timestamp = timestamp;
    }

    public String getType() {
        return type;
    }

    public String getId() {
        return id;
    }

    public String getLockId() {
        return lockId;
    }

    public long getTimestamp() {
        return timestamp;
    }

		// 유효 시간이 지났는지를 판단할 때 사용
    public boolean isExpired() {
        return timestamp < System.currentTimeMillis();
    }
}

@Component
public class SpringLockManager implements LockManager {
  private int lockTimeout = 5 * 60 * 1000;
  private JdbcTemplate jdbcTemplate;

  private RowMapper<LockData> lockDataRowMapper = (rs, rowNum) ->
          new LockData(rs.getString(1), rs.getString(2),
                  rs.getString(3), rs.getTimestamp(4).getTime());

  public SpringLockManager(JdbcTemplate jdbcTemplate) {
      this.jdbcTemplate = jdbcTemplate;
  }

  /**
   * type과 id에 대한 잠금 시도
   */
  @Transactional(propagation = Propagation.REQUIRES_NEW)
  @Override
  public LockId tryLock(String type, String id) throws LockException {
      checkAlreadyLocked(type, id);
      LockId lockId = new LockId(UUID.randomUUID().toString());
      locking(type, id, 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> lockData = handleExpiration(locks);
      if (lockData.isPresent()) throw new AlreadyLockedException();
  }

  /**
   * 유효시간이 지난 락인지 아닌지 판단 후 유효시간 내 락이면 리턴
   */
  private Optional<LockData> handleExpiration(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 테이블에 잠금 데이터를 삽입
   * 데이터 삽입 결과가 없거나 DuplicateKeyException이 발생하면 LockingFailException을 익셉션을 발생시킨다
   */
  private void locking(String type, String id, LockId lockId) {
      try {
          int updatedCount = jdbcTemplate.update(
                  "insert into locks values (?, ?, ?, ?)",
                  type, id, lockId.getValue(), new Timestamp(getExpirationTime()));
          if (updatedCount == 0) throw new LockingFailException();
      } catch (DuplicateKeyException e) {
          throw new LockingFailException(e);
      }
  }

  /**
   * 잠금 유효 시간 생성
   */
  private long getExpirationTime() {
      return System.currentTimeMillis() + lockTimeout;
  }

  /**
   * 잠금이 유효한지 검사
   */
  @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 조회
   */
  private Optional<LockData> getLockData(LockId lockId) {
      List<LockData> locks = jdbcTemplate.query(
              "select * from locks where lockid = ?",
              lockDataRowMapper, lockId.getValue());
      return handleExpiration(locks);
  }

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

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

  public void setLockTimeout(int lockTimeout) {
      this.lockTimeout = lockTimeout;
  }
}