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

// 해결방법: Time Out 설정
Map<String, Object> hints = new HashMap<>();
hints.put("javax.persistence.lock.timeout", 2000); // 2초
Order order = entityManager.find( Order.class, orderNo, LockModeType.PESSIMISTIC_WRITE, hints);

// 버전 사용: 1씩 증가
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 // UPDATE 쿼리 실행 버전 UP
    private long version;
    //...
}

@Controller
public class OrderController {
    private ChangeShippingService changeShippingService;
    @RequestMapping(value = "/changeshipping", method = RequestMethod.POST)
    public String changeShipping(ChangeShippingRequest changeReq) {
        try {
            ChangeShippingService.changeShipping(changeReq);
            return "changeShippingSuccess";
        } catch(OptimisticLockingFailureException ex) {
            // 트랜잭션 충돌 메시지
            return "changeShippingTxConflict";
        }
        //...
    }
}

public class ChangeShippingService {
    @Transactional
    public void changeShipping(ChangeShippingRequest changeReq) {
        Order order = orderRepository.findById(new OrderNo(changeReq. getNumber()));
        checkNoOrder(order);
        order.changeShippingInfo(changeReq.getShippingInfo()); // 트랜잭션이 충돌시 여기서 OptimisticLockingFailureException 예외 발생 (아래코드확인)
    }
    //...
}

<!-- 애그리거트 정보를 보여줄 때 뷰 코드는 버전 값을 함께 전송한다. ->
<form action="startShipping" method="post">
    < input type="hidden" name="version" value="${orderDto.version}" > // 버전 
    <input type="text" name="orderNumber" value="${orderDto.orderNumber}"
    readonly>
    //....
    <input type="submit" value="배송 상태로 변경하기">
</form>

public class StartShippingRequest {
    private String orderNumber;
    private long version;
    //...생성자, getter
}

@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 | VersionConflictException ex) {
            return "startShippingTxConflict";
        }
    }
    //...
}

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 VersionConflictException(); // 표현 계층으로 넘긴다 
        }
        order.startShipping();
    }
    //..
}

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

// PTIMISTIC_FORCE_INCREMENT 사용해 강제로 증가 처리
// 루트 엔티티가 아닌 다른 엔티티나 밸류가 변경되더라도 버전 값을 증가시킬 수 있다.
@Repository
public class JpaOrderRepository implements OrderRepository {
    @PersistenceContext
    private EntityManager entityManager;
    @Override
    public Order findByIdOptimisticLockMode(OrderNo id) {
        return entityManager.find(
            Order.class, id, LockModeType.OPTIMISTIC_FORCE_INCREMENT);
    }
    //...
}

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;
}

public class LockId {
    private String value;
    // 생성자, getter
}

// 데이터 수정 폼에 동시에 접근하는 것을 제어하는 코드의 예 
@RequestMapping("/some/edit/{id}")
public String editForm(@PathVariable("id") Long id, ModelMap model) {
    // 1. 오프라인 선점 잠금 시도
    LockId lockId = lockManager.tryLock("data", id);
    // 2. 기능 실행
    Data data = someDao.select(id);
    model.addAttribute("data", data);
    // 3. 잠금 해제에 사용할 LockId를 모델에 추가
    model.addAttribute("lockId", lockId);
    return "editForm"
}

<form action="/some/edit/${data.id}" method="post">
    ...
	<input type="hidden" name="lid" value="${lockId.value}">
    ...
</form>
// ------------------------------------------------
@RequestMapping(value = "/some/edit/{id}", method = RequestMethod.POST)
public String edit(@PathVariable("id") Long id,
                   @ModelAttribute("editReq") EditRequest editReq,
                   @RequestParam("lid") String lockIdValue) {
    editReq.setId(id);
    // 1. 잠금 선점 확인
    LockId lockId = new LockId(lockIdValue);
    lockManager.checkLock(lockId);
    // 2. 기능 실행
    someEditService.edit(editReq);
    model.addAttribute("data", data);
    // 3. 잠금 해제
    lockManager.releaseLock(lockId);

    return "editSuccess";
}

public class LockData {
    private String type;
    private String id;
    private String lockid;
    private long expirationTime;
   
    public LockData(String type, String id, String lockId, long expirationTime) {
        this.type = type;
        this.id = id;
        this.lockId = lockId;
        this.expirationTime= expirationTime;
    }

    public String getType() {
        return type;
    }

    public String getId() {
        return id;
    }

    public String getLockId() {
        return lockId;
    }

    public long getExpirationTime() {
        return expirationTime;
    }

    // 유효 시간이 지났는지 확인
    public boolean isExpired() {
        return expirationTime < System.currentTimeMillis();
    }
}

@Component
public class SpringLockManager implements LockManager {
    private int lockTimeout = 5 * 60 * 1000;
    private DdbcTemplate jdbcTemplate;
    private RowMapper<LockData> lockDataRowMapper = (rs3 rowNum) ->
        new LockData(rs.getString(1), rs.getString(2),
                     rs.getString(3), rs.getTimestamp(4).getTime());
    @Transactional
    @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;
    }

    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.isEmptyO) 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);
        }
    }

    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;
    }

    @Override
    public void checkLock(Lockid lockid) throws LockException {
        Optional<LockData> lockData = getLockData(lockid);
        if (!lockData.isPresent()) throw new NoLockException();
    }

    private Optional<LockData> getLockData(Lockid lockid) {
        List<LockData> locks = jdbcTemplate.query(
            "select * from locks where lockid =
            lockDataRowMapper, lockid.getValue());
        return handleExpiration(locks);
    }

    @Transactional
    @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());
    }

    @Transactional
    @Override
    public void releaseLock(LockId lockId) throws LockException {
        jdbcTemplate.update("delete from locks where lockid = ?", lockId.getValue());
    }

    @Autowired
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
}