Different REST methods modifies the same object - RollbackException, OptimisticLockException, StaleStateException

Question

I use Java 8, Hibernate 5.1.0.Final, Guice 4.1.0, Jersey 1.19. I have several REST methods which may modify the same object - entity loaded from the database. When they run concurrently and modify the same item, I get:

javax.persistence.RollbackException: Error while committing the transaction
    at org.hibernate.jpa.internal.TransactionImpl.commit(TransactionImpl.java:86)

Caused by: javax.persistence.OptimisticLockException: Batch update returned unexpected row count from update [0]; actual row count: 0; expected: 1

Caused by: org.hibernate.StaleStateException: Batch update returned unexpected row count from update [0]; actual row count: 0; expected: 1

Possible solutions:

• Synchronization by object in REST methods
• Constantly refresh object state to reduce chance of OptimisticLockException (5 Common Hibernate Exceptions and How to Fix Them)
• Retry REST method after OptimisticLockException (JPA: pattern for handling OptimisticLockException)

Are there any other options? What's the best way to handle this problem?

UPDATE 1

I have tried to implemented retry:

public void changeItemName(Long id, String name){

    Item item = itemDAO.find(id);
    item.setName(name);

    try {
        itemDAO.save(item);
    } catch (RollbackException | OptimisticLockException | StaleStateException e) {
        logger.warn("Retry method after " + e.getClass().getName()); 
        changeItemName(id, name);
    }
}

But I get:

javax.persistence.RollbackException: Error while committing the transaction
at org.hibernate.jpa.internal.TransactionImpl.commit(TransactionImpl.java:86)

Caused by: javax.persistence.PersistenceException: org.hibernate.exception.GenericJDBCException: could not update: [com.example.Item#1]
at org.hibernate.jpa.spi.AbstractEntityManagerImpl.convert(AbstractEntityManagerImpl.java:1692)

Caused by: org.hibernate.exception.GenericJDBCException: could not update: [com.example.Item#1]
at org.hibernate.exception.internal.StandardSQLExceptionConverter.convert(StandardSQLExceptionConverter.java:47)

Caused by: org.postgresql.util.PSQLException: This statement has been closed.
at org.postgresql.jdbc2.AbstractJdbc2Statement.checkClosed(AbstractJdbc2Statement.java:2653)

Answer 1

1. Synchronization by object in REST methods I would say it's not possible. Imagine the same service running on 2 nodes.

2. Constantly refresh object state again is not an option. The update could happens just between 2 refreshing.

3. This one is fine. CAS principle. While version is not correct attempt to save the changes. But actually it depends on your business logic. E.g. There is a User object and initial name was "name1". The first call changes it from "name1" to "name2". The second calls tries to change from "name1" to "name3". We can either (A) change the name suppressing the "name1"->"name2" update or (B) reject the change reporting to invoker to refresh to see actual state and apply the changes to actual state.

If we are trying to modify e.g. account balance (A) approach is not valid and we need (B).

You should decide what to do according to the business logic you need there.

UPDATE: It won't work this way. You need to catch it higher - where transaction is started and do it in a separate transaction.

Suppose you have

@Service
public class MyServiceImpl
    @Transactional
    public void changeItemName(Long id, String name) {
    }

where the optimistic lock exception could happen. If you call the method just from catch block a new transaction is not started because not proxies method is called.

Instead you can do something like this

@Service
public class MyServiceImpl
    @Autowired
    private MyService myService;
    @Transactional
    public void changeItemName(Long id, String name) {
      catch() {
        myService.changeItemName(id, name);
      }
    }