Spring JPA saveはメインキーの繰り返しスロー異常を実現します。

create table order_lock (
    order_number varchar(20) not null primary key,
    user_name varchar(100) not null,
    created_time datetime default CURRENT_TIMESTAMP null
);

Hibernate: 
    select
        orderl0_.order_number as order_nu1_12_0_,
        orderl0_.created_time as created_2_12_0_,
        orderl0_.user_name as user_nam4_12_0_ 
    from
        order_lock orderl0_ 
    where
        orderl0_.order_number=?
[V][2019-11-04 15:03:06,602][INFO ][http-nio-9091-exec-9][OrderLockService][lockOrder][][][][] - order lock start lock: order number:aaaaaaaaaaaaaaaa, user name: zzz2
Hibernate: 
    insert 
    into
        order_lock
        (created_time user_name, order_number) 
    values
        (?, ?, ?)

Hibernate: 
    select
        orderl0_.order_number as order_nu1_12_0_,
        orderl0_.created_time as created_2_12_0_,
        orderl0_.user_name as user_nam4_12_0_ 
    from
        order_lock orderl0_ 
    where
        orderl0_.order_number=?
Hibernate: 
    update
            order_lock 
        set
            created_time=? 
        where
            order_number=?

@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
@Table(name = "order_lock")
public class OrdertLock implements Persistable {
    @Id
    private String orderNumber;

    @Column(updatable = false, nullable = false)
    private String userName;

    @CreationTimestamp
    private Date createdTime;

    @Override
    public Object getId() {
        return orderNumber;
    }

    @Override
    public boolean isNew() {
        return true;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        OrderEditLock orderEditLock = (OrderEditLock) o;
        return Objects.equals(orderNumber, orderEditLock.orderNumber);
    }

    @Override
    public int hashCode() {
        return Objects.hash(orderNumber);
    }
}

Hibernate: 
    insert 
    into
        order_lock
        (created_time, user_name, order_number) 
    values
        (?, ?, ?)

@Modifying
@Query(nativeQuery = true,
       value = "INSERT INTO " +
       "order_lock(order_number, user_name) " +
       "VALUES (:orderNumber, :userName);")
void lockOrder(@Param("orderNumber") String orderNumber,
               @Param("userName") String userName);

Hibernate: 
    INSERT 
    INTO
        service_order_edit_lock
        (order_number, user_name) 
    VALUES
        (?, ?);

JpaEntityInformation entityInformation；
@Transactional
public  S save(S entity) {

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

public boolean isNew(T entity) {

ID id = getId(entity);
Class idType = getIdType();

if (!idType.isPrimitive()) {
    return id == null;
}

if (id instanceof Number) {
    return ((Number) id).longValue() == 0L;
}

throw new IllegalArgumentException(String.format("Unsupported primitive id type %s!", idType));
}

public abstract class JpaEntityInformationSupport extends AbstractEntityInformation
    implements JpaEntityInformation 

public class JpaPersistableEntityInformation, ID>
    extends JpaMetamodelEntityInformation {

public JpaPersistableEntityInformation(Class domainClass, Metamodel metamodel) {
    super(domainClass, metamodel);
}

@Override
public boolean isNew(T entity) {
    return entity.isNew();
}

@Nullable
@Override
public ID getId(T entity) {
    return entity.getId();
}
}

ID getId();
boolean isNew();

public final IsNewStrategy getIsNewStrategy(Class> type) {

    Assert.notNull(type, "Type must not be null!");

    if (Persistable.class.isAssignableFrom(type)) {
        return PersistableIsNewStrategy.INSTANCE;
    }

    IsNewStrategy strategy = doGetIsNewStrategy(type);

    if (strategy != null) {
        return strategy;
    }

    throw new IllegalArgumentException(
            String.format("Unsupported entity %s! Could not determine IsNewStrategy.", type.getName()));
}

public enum PersistableIsNewStrategy implements IsNewStrategy {
@Override
public boolean isNew(Object entity) {

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

if (!(entity instanceof Persistable)) {
    throw new IllegalArgumentException(
            String.format("Given object of type %s does not implement %s!", entity.getClass(), Persistable.class));
}

return ((Persistable>) entity).isNew();
}
}

public class JpaPersistableEntityInformation, ID>
        extends JpaMetamodelEntityInformation {

    public JpaPersistableEntityInformation(Class domainClass, Metamodel metamodel) {
        super(domainClass, metamodel);
    }
}

public class PersistableEntityInformation, ID> extends AbstractEntityInformation {
    @SuppressWarnings("unchecked")
    public PersistableEntityInformation(Class domainClass) {

        super(domainClass);

        Class> idClass = ResolvableType.forClass(Persistable.class, domainClass).resolveGeneric(0);

        if (idClass == null) {
            throw new IllegalArgumentException(String.format("Could not resolve identifier type for %s!", domainClass));
        }

        this.idClass = (Class) idClass;
    }
}