Spring JpaRepositroy.save() does not appear to throw exception on duplicate saves

Question

I'm currently playing around on Spring boot 1.4.2 in which I've pulled in Spring-boot-starter-web and Spring-boot-starter-jpa.

My main issue is that when I save a new entity it works fine (all cool).

However if I save a new product entity with the same id (eg a duplicate entry), it does not throw an exception. I was expecting ConstrintViolationException or something similar.

Given the following set up:

Application.java

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

ProductRepository.java

@Repository
public interface ProductRepository extends JpaRepository<Product, String> {}

JpaConfig.java

@Configuration
@EnableJpaRepositories(basePackages = "com.verric.jpa.repository" )
@EntityScan(basePackageClasses ="com.verric.jpa")
@EnableTransactionManagement
public class JpaConfig {

    @Bean
    JpaTransactionManager transactionManager() {
        return new JpaTransactionManager();
    }
}

Note JpaConfig.java and Application.java are in the same package.

ProductController.java

@RestController
@RequestMapping(path = "/product")
public class ProductController {

    @Autowired
    ProductRepository productRepository;

    @PostMapping("createProduct")
    public void handle(@RequestBody @Valid CreateProductRequest request) {
        Product product = new Product(request.getId(), request.getName(), request.getPrice(), request.isTaxable());
        try {
            productRepository.save(product);
        } catch (DataAccessException ex) {
            System.out.println(ex.getCause().getMessage());
        }
    }
}

and finally Product.java

@Entity(name = "product")
@Getter
@Setter
@AllArgsConstructor
@EqualsAndHashCode(of = "id")
public class Product {

    protected Product() { /* jpa constructor*/ }

    @Id
    private String id;

    @Column
    private String name;

    @Column
    private Long price;

    @Column
    private Boolean taxable;
}

The getter, setter and equalsHashcode.. are lombok annotations.

Miscellaneous:

Spring boot : 1.4.2

Hibernate ORM: 5.2.2.FINAL

This issue happens regardless if I annotate the controller with or without @Transactional

The underlying db shows the exception clearly

2016-11-15 18:03:49 AEDT [40794-1] verric@stuff ERROR:  duplicate key value violates unique constraint "product_pkey"
2016-11-15 18:03:49 AEDT [40794-2] verric@stuff DETAIL:  Key (id)=(test001) already exists

I know that is better (more common) to break the data access stuff into its own service layer instead of dumping it in the controller

The semantics of the controller aren't ReST

Things I've tried:

Spring CrudRepository exceptions

I've tried implementing the answer from this question, unfortunately my code never ever hits the DataAccesException exception

Does Spring JPA throw an error if save function is unsuccessful?

Again similar response to the question above.

http://www.baeldung.com/spring-dataIntegrityviolationexception

I tried adding the bean to my JPAconfig.java class that is:

   @Bean
   public PersistenceExceptionTranslationPostProcessor exceptionTranslation(){
      return new PersistenceExceptionTranslationPostProcessor();
   }

But nothing seemed to happen.

Sorry for long post, ty in advance

Answer 1

My solution is a lot cleaner. Spring Data already provides a nice way for us to define how an entity is considered to be new. This can easily be done by implementing Persistable on our entities, as documented in the reference.

In my case, as is the OP's, the IDs come from an external source and cannot be auto generated. So the default logic used by Spring Data to consider an entity as new if the ID is null wouldn't have worked.

@Entity
public class MyEntity implements Persistable<UUID> {

    @Id
    private UUID id;

    @Transient
    private boolean update;

    @Override
    public UUID getId() {
        return this.id;
    }

    public void setId(UUID id) {
        this.id = id;
    }

    public boolean isUpdate() {
        return this.update;
    }

    public void setUpdate(boolean update) {
        this.update = update;
    }

    @Override
    public boolean isNew() {
        return !this.update;
    }

    @PrePersist
    @PostLoad
    void markUpdated() {
        this.update = true;
    }
}

Here, I have provided a mechanism for the entity to express whether it considers itself new or not by means of another transient boolean property called update. As the default value of update will be false, all entities of this type are considered new and will result in a DataIntegrityViolationException being thrown when you attempt to call repository.save(entity) with the same ID.

If you do wish to perform a merge, you can always set the update property to true before attempting a save. Of course, if your use case never requires you to update entities, you can always return true from the isNew method and get rid of the update field.

The advantages of this approach over checking whether an entity with the same ID already exists in the database before saving are many:

1. Avoids an extra round trip to the database
2. We cannot guarantee that by the time one thread has determined that this entity doesn't exist and is about to persist, another thread doesn't attempt to do the same and result in inconsistent data.
3. Better performance as a result of 1 and having to avoid expensive locking mechanisms.
4. Atomic
5. Simple

EDIT: Don't forget to implement a method using JPA callbacks that sets the correct state of the update boolean field just before persisting and just after loading from the database. If you forget to do this, calling deleteAll on the JPA repository will have no effect as I painfully found out. This is because the Spring Data implementation of deleteAll now checks if the entity is new before performing the delete. If your isNew method returns true, the entity will never be considered for deletion.

Answer 2

To build upon Shazins answer and to clarify. the CrudRepositroy.save() or JpaRespository.saveAndFlush() both delegate to the following method

SimpleJpaRepository.java

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

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

Hence if a user tries to create a new entity that so happens to have the same id as an existing entity Spring data will just update that entity.

To achieve what I originally wanted the only thing I could find was to drop back down to JPA solely, that is

@Transactional
@PostMapping("/createProduct")
public Product createProduct(@RequestBody @Valid Product product) {
    try {
        entityManager.persist(product);
        entityManager.flush();
    }catch (RuntimeException ex) {
        System.err.println(ex.getCause().getMessage());
    }

    return product;
}

Here if we try to persist and new entity with an id already existing in the database it will throw will throw the constraint violation exception as we originally wanted.

Answer 3

Note that there are 3 scenarios here:

1. Setting ID manually

If there is no choice(like the OP), i.e if you are setting your own id "manually", Spring Data JPA is assuming that you want to check if there are duplicates(hence the SELECT), so it will do a "(i)SELECT + (ii)INSERT" if there is no existing record or a "(i)SELECT + (ii)UPDATE" if there is already an existing record.

In short, 2 SQLs!

2. Use an ID Generator

Cleaner & better, for example:

 @Id
 @GeneratedValue(generator = "my-uuid")
 @GenericGenerator(name = "my-uuid", strategy = "uuid2")
 private UUID id;

Result: there is ALWAYS only 1 INSERT statement.

3. Implement Persistable and isNew()

This has already been brilliantly answered by @adarshr, but is also more painful, i.e to implement Persistable(instead of Serializable), and implement the isNew() method.

Result: Also, 1 INSERT statement.

Answer 4

According to Spring Data documentation Spring persists an entity if does not exists or merge, this means update, the existing one:

Saving an entity can be performed via the CrudRepository.save(…)-Method. It will persist or merge the given entity using the underlying JPA EntityManager. If the entity has not been persisted yet Spring Data JPA will save the entity via a call to the entityManager.persist(…)-Method, otherwise the entityManager.merge(…)-Method will be called.