hibernate guarantee failure on concurrent insertion of existing record instead of update

I have this scenario.
I have a web/rest service that receives a new record with a business id and inserts it using hibernate entityManager. However, there are multiple processes which can be doing such an insertion concurrently. Hibernate save method will insert or update( if the record exists for the same primary key).

so if multiple processes are performing the equivalent of:

process1:

    MySimple r=new MySimple(1,'tagP1')
    mySinmpleRepository.save(r);

process2:

    MySimple r=new MySimple(1,'tagP2')
    mySinmpleRepository.save(r);

What i need to achieve is a form of optimistic locking and to fail the update if the record already exists.

Unfortunately what happens so far is that the record gets updated and none of the save methods fail even if I try to "insert" a detached entity

sample entity:

    create table MySimple(
     SIMPLE_ID INTEGER NOT NULL,
    TAG VARCHAR(200),
    primary key PK_MYSIMPLE (SIMPLE_ID)
    )

entity:

    @Entity
    public class MySimple {
     @Id
     @Column(name="SIMPLE_ID", nullable=false, updateable=false)
     private simpleId;
    
     @Column(name="TAG", nullable=false, updateable=true)
     private tag;
     // getters/setters/etc..
    }

    public interface MySimpleRepository extends JpaRepository<MySimple, Integer>{
    }

That is how spring-data-jpa designed: since your entity has external identifier, spring-data-jpa never considers it as a new entity, and instead of calling em.persist() it calls em.save() (em.merge() in recent versions), which in turn cause Hibernate to make a decision what to do with entity: insert or update:

@Transactional
@Override
public <S extends T> S save(S entity) {

    Assert.notNull(entity, "Entity must not be null");

    if (entityInformation.isNew(entity)) {
        em.persist(entity);
        return entity;
    } else {
        return em.merge(entity);
    }
}

The options are following:

1. take advantage of DB locks, i.e. lock something in DB upon entering critical section and perform some checks before saving entity. In PostgreSQL it is possible to use advisory locks, in case of other DBs you may create a table with single row and lock it.

2. define a "technical" @Id field for your entity, and use "business identifier" provided as @NaturalId, in that case unique constraint will help

3. don't use spring-data-jpa repository for this particular case - use EnitytManager API instead.

4. take advantage of Composite Repositories and call em.persist()

5. file a CR to spring-data-jpa project, asking to provide persist method or some other option, boolean isNew parameter, for exmaple

6. take advantage of @Version - hibernate (and spring-data-jpa) believes entities with null version are new.

7. somehow try to implement org.springframework.data.domain.Persistable in your entity in order to tell spring-data-jpa that in particular scenario it should consider entity as new, for example:

@Entity
public class MySimple extends AbstractPersistable<Integer> {

    private Boolean forceNew;

    @Transient
    @Override
    public boolean isNew() {
        if (forceNew != null) {
            return forceNew;
        }
        return super.isNew();
    }

}