JPA Model testing with Hibernate Statistics

Paul Sterl — Sun, 01 Aug 2021 11:25:00 +0000

Problem

Often we write JPA Entity classes an have to ensure in a larger team that refactoring doesn’t create performance problems or logical errors in the entity model usual problems are:

Missing fetch joins in Queries
- Which leads to slow fetch joins
Wrong direction of Entity relations
- which leads to updates after inserts
- or even to deletes and reinserts of data
Wrong transaction boundaries
- Which leads to multiple transactions for one logical business operation

@Component
public class HibernateAsserts {
  private final Statistics statistics;

  public HibernateAsserts(EntityManager entityManager) {
    try (Session session = entityManager.unwrap(org.hibernate.Session.class)) {
      @SuppressWarnings("resource")
      SessionFactory factory = session.getSessionFactory();
      factory.getStatistics().setStatisticsEnabled(true);
      statistics = factory.getStatistics();
    }
  }
  
  public HibernateAsserts assertTrxCount(int expected) {
    long value = statistics.getTransactionCount();
    if (value != expected) {
      logSummary();
      fail("Expected " + expected + " TransactionCount, but found " + value);
    }
    return this;
  }
  
  public HibernateAsserts assertInsertCount(int expected) {
    long value = statistics.getEntityInsertCount();
    if (value != expected) {
      logSummary();
      fail("Expected " + expected + " EntityInsertCount, but found " + value);
    }
    return this;
  }

  public void reset() {
    statistics.clear();
  }

  public void logSummary() {
    statistics.logSummary();
  }
}

In your test

@SpringBootTest
class MyTestClassTest {

  @Autowired private SubjectUnderTest subject;
  @Autowired private HibernateAsserts hibernateAsserts;
  
  @Test
  void textMyBusinessMethod() {
    // GIVEN
    // custom data setup for the test

    // WHEN
    hibernateAsserts.reset(); // ensure the setup is not in the stats
    subject.runBusinessMethod();
    
    // THEN
    // any business asserts
    hibernateAsserts
      .assertTrxCount(1)
      .assertInsertCount(1);
  }
}

JPA default entity listener

Paul Sterl — Tue, 15 Aug 2017 10:52:10 +0000

The problem

Sometimes we want to register a default Entity Listeners which are called as soon an entity is persisted, without adding the @EntityListeners annotation to our classes, as in most cases we anyway provide interfaces so we can access data on the entity itself. The problem is, that we cannot annotate our entity listener with any annotation, only the entity itself.

Solution

In JPA we can provide entity mappings in the orm.xml which allows us to define default listeners which are executed on any entity.

Furthermore, the body of the entity-listener may contain elements pre-persist to define method.

Example On GitHub

Example

Let’s assume we want to add to each entity an update time and a create time. We could, of course, implement a base entity, but as we should favor composition over inheritance — which would allow us to add even more common fields to the entity — we want to go with an embedded class. Let’s say TimestampBE.

Embeddable time stamps

This class adds to any entity the create date and update date. We just store UTC longs measured from 1970-01-01T00:00Z.

@Embeddable @Getter @Setter
public class TimestampBE implements Serializable {
    @Column(name = "create_date", nullable = false, updatable = false)
    private Long createDate;
    @Column(name = "update_date", nullable = false, updatable = true)
    private Long updateDate;
}

Tag interface

Next, we add an interface that allows us to tag any entity that has a timestamp.

/**
 * Interface which marks an entity that it has the timestamp entity.
 */
public interface HasTimestamp {
    TimestampBE getTimestamp();
    void setTimestamp(TimestampBE timestamp);
}

Timestamp Entity Listener

Now we have to define the behavior which sets us the create and update date in the live cycle of the entity.

public class TimestampEntityListener {
    @PrePersist
    void prePersist(Object entity) {
        if (entity instanceof HasTimestamp) {
            TimestampBE timestamp = getTimestamp((HasTimestamp)entity);
            final long now = Clock.systemUTC().millis();
            timestamp.setCreateDate(now);
            timestamp.setUpdateDate(now);
        }
    }

    @PreUpdate
    void preUpdate(Object entity) {
        if (entity instanceof HasTimestamp) {
            TimestampBE timestamp = getTimestamp((HasTimestamp)entity);
            final long now = Clock.systemUTC().millis();
            if (timestamp.getCreateDate() == null) timestamp.setCreateDate(now);
            timestamp.setUpdateDate(now);
        }
    }
    
    private TimestampBE getTimestamp(HasTimestamp ht) {
        TimestampBE timestamp = ht.getTimestamp();
        if (timestamp == null) {
            timestamp = new TimestampBE();
            ht.setTimestamp(timestamp);
        }
        return timestamp;
    }
}

Reister the default listener

Add the src/main/resources/META-INF/orm.xml and register the Listener above. Adjust the package as needed:

Use the new classes

In the end, you may add the new class at any entity:

@Entity
@Data
@NoArgsConstructor @AllArgsConstructor @Builder
public class PersonBE implements HasTimestamp, Serializable {
    @Id 
    @GeneratedValue
    @Column(name = "person_id")
    private Long id;
    private String name;
    @Embedded
    private TimestampBE timestamp;
}

JPA – Pauls Blog