How does Spring's JPARepository and @Transactional behave together?

Question

I have two methods (in a Spring boot application) that handle an entity. The entity has two fields, both boolean isDefault and isPdfGenerated. The first method (which is called from a controller) changes the isDefault flag when a new entity is created while the second one (called from a @Scheduled annotated method) changes the isPdfGenrated after it generates a pdf file for that entity.

My problem is that sometimes the second method finds entities with the isPdfGenerated flag set to false even though the file has been generated and saved in the database.

Both the methods have the @Transactional annotation and the repository interface for the entity extends JpARepository.

My guess is that the first method loads the entity from the database before the second method does but saves the entity after the second method does its job, thus overriding the isPdfGenerated flag.

Is this possible ? If the answer is yes, how should one handle such cases ? Shouldn't JPARepository handle the case when an entity gets updated from an external source ?

Bellow is some code to better illustrate the situation.

MyController:

@Controller
@RequestMapping("/customers")
public class MyController {

  @Autowired
  private EntityService entityService;

  @RequestMapping(value = "/{id}/changeDefault", method = RequestMethod.POST)
  public String changeDefault(@PathVariable("id") Long customerId, @ModelAttribute EntityForm entityForm, Model model) {

        Entity newDefaultEntity = entityService.updateDefaultEntity(customerId, entityForm);

        if (newDefaultEntity == null)
            return "redirect:/customers/" + customerId;

        return "redirect:/customers/" + customerId + "/entity/default;
  }
}

EntityService:

import org.springframework.transaction.annotation.Transactional;

@Service
public class EntityService {

  @Autowired
  private EntityRepository entityRepository;

  @Autowired
  private CustomerRepository customerRepository;

  @Transactional
  public Entity updateDefaultEntity(Long customerId, submittedData) {

      Customer customer = customerRepository.findById(customerId);
      if(customer == null)
        return customer; // I know there are better ways to do this

      Entity currentDefaultEntity = entityRepository.findUniqueByCustomerAndDefaultFlag(customer, true);
      if(currentDefaultEntity == null)
        return null; // I know there are better ways to do this also

      Entity newDefaultEntity = new Entity();
      newDefaultEntity.setField1(submittedData.getField1());
      newDefaultEntity.setField2(submittedData.getField2());
      newDefaultEntity.setCustomer(customer);

      oldDefaultEntity.setDefaultFlag(false);
      newDefaultEntity.setDefaultFlag(true);

      entityRepository.save(newDefaultEntity);
  }

  @Transactional
  public void generatePdfDocument(Entity entity) {

      Document pdfDocument = generateDocument(entity);
      if(pdfDocument == null)
        return;

      documentRepository.save(pdfDocument);

      entity.setPdfGeneratedFlag(true);
      entityRepository.save(entity);
  }

}

ScheduledTasks:

@Component
public class ScheduledTasks {

    private static final int SECOND_IN_MILLISECONDS = 1000;
    private static final int MINUTE_IN_SECONDS = 60;

    @Autowired
    private EntityRepository entityRepository;

    @Autowired
    private DocumentService documentService;

    @Scheduled(fixedDelay = 20 * SECOND_IN_MILLISECONDS)
    @Transactional
    public void generateDocuments() {

        List<Quotation> quotationList = entityRepository.findByPdfGeneratedFlag(false);
        for(Entity entity : entitiesList) {

          documentService.generatePdfDocument(entity);
        }
    }
 }

DocumentService:

@Service
public class DocumentService {

  @Autowired
  private EntityRepository entityRepository;

  @Autowired
  private DocumentRepository documentRepository;

  @Transactional
  public void generatePdfDocument(Entity entity) {

      Document pdfDocument = generateDocument(entity);
      if(pdfDocument == null)
        return;

      documentRepository.save(pdfDocument);

      entity.setPdfGeneratedFlag(true);
      entityRepository.save(entity);
  }

}

EntityRepository:

@Repository
public interface EntityRepository extends JpaRepository<Entity, Long> {

    Entity findById(@Param("id") Long id);

    List<Entity> findByPdfGeneratedFlag(@Param("is_pdf_generated") Boolean pdfGeneratedFlag);

    Entity findUniqueByCustomerAndDefaultFlag(
            @Param("customer") Customer customer,
            @Param("defaultFlag") Boolean defaultFlag
    );
}

DocumentRepository:

@Repository
public interface DocumentRepository extends JpaRepository<Document, Long> {

    Document findById(@Param("id") Long id);
}

Entity:

@Entity
@Table(name = "entities")
@JsonIdentityInfo(generator = ObjectIdGenerators.IntSequenceGenerator.class, property = "id")
public class Entity {

    private Long id;
    private boolean defaultFlag;
    private boolean pdfGeneratedFlag;
    private String field1;
    private String field2;
    private Customer customer;

    public Entity() { }

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    public Long getId() {
        return id;
    }

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

    @Column(name = "is_default")
    public boolean isDefaultFlag() {
        return defaultFlag;
    }

    public void setDefaultFlag(boolean defaultFlag) {
        this.defaultFlag = defaultFlag;
    }

    @Column(name = "is_pdf_generated")
    public boolean isPdfGeneratedFlag() {
        return pdfGeneratedFlag;
    }

    public void setPdfGeneratedFlag(boolean pdfGeneratedFlag) {
        this.pdfGeneratedFlag = pdfGeneratedFlag;
    }

    @Column(name = "field_1")
    public String getField1() {
        return field1;
    }

    public void setField1(String field1) {
        this.field1 = field1;
    }

    @Column(name = "field_2")
    public String getField2() {
        return field2;
    }

    public void setField2(String field2) {
        this.field2 = field2;
    }

    @ManyToOne
    @JoinColumn(name = "customer_id", referencedColumnName = "id", nullable = false)
    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Entity quotation = (Entity) o;

        return id != null ? id.equals(entity.id) : entity.id == null;

    }

    @Override
    public int hashCode() {
        return id != null ? id.hashCode() : 0;
    }

    @Override
    public String toString() {
        return "Entity{" +
                "id=" + id +
                ", pdfGeneratedFlag=" + pdfGeneratedFlag +
                ", defaultFlag=" + defaultFlag +
                ", field1=" + field1 +
                ", field2=" + field2 +
                ", customer=" + (customer == null ? null : customer.getId()) +
                "}";
    }
}

I have omitted the other classes because they are either POJOs ( EntityForm ) or the same as other domain model classes ( Document ).

Answer 1

If you're talking about a row on the database that is getting updated by another process after the first process has read it but before it has been updated, then you need to put in some sort of optimistic locking strategy.

This will be handled by the underlying ORM api (e.g. Hibernate or Eclipselink) rather than Spring Data (which will just handle an optimistic locking errors thrown by the ORM).

Have a look at this article. Bear in mind that if you want optimistic locking you need some way of determining a row's version. In JPA this is normally done using a column annotated with the @Version tag.

https://vladmihalcea.com/hibernate-locking-patterns-how-does-optimistic-lock-mode-work/