Hibernate – Pauls Blog

Spring Persistent Tasks

Paul Sterl — Sun, 20 Apr 2025 07:16:43 +0000

A simple task management framework designed to queue and execute asynchronous tasks with support for database persistence and a user-friendly interface. It can be used to implement scheduling patterns or outbound patterns.

Focus is the usage with spring boot and JPA.

https://github.com/sterlp/spring-persistent-tasks

Key Features

JPA-Powered Persistence – Automatically persists tasks to your database
Spring Boot Auto-Configuration – Simple setup with @EnableSpringPersistentTasks
Clustering Support – Built-in lock management for distributed environments
Type-Safe Tasks – Generic task definitions with state objects
Retry Mechanisms – Automatic retry policies for failed executions
Transactional Integration – Works with Spring’s transaction management
Queue Management – Intelligent task queuing and prioritization
Different DB Supports
- MsSQL
- MariaDB
- Postgres

Propagation REQUIRES_NEW & NEVER | Transaktionsmanagement mit Spring Boot, JPA & Hibernate

Paul Sterl — Sun, 19 Jan 2025 20:17:00 +0000

In diesem Video tauchen wir tiefer in die Welt des Transaktionsmanagements ein und erklären die Unterschiede zwischen den Propagation-Einstellungen REQUIRES_NEW und NEVER in Spring Boot. Erfahre, wie du mit Spring Boot, Spring Data, JPA und Hibernate effektive Transaktionen in modernen Datenbanken steuerst.

Lerne, wann und warum du REQUIRES_NEW nutzen solltest, um eine neue Transaktion zu starten, und warum NEVER nützlich ist, um sicherzustellen, dass kein bestehender Transaktionskontext verwendet wird. Dieses Tutorial ist ideal für Entwickler, die fortgeschrittene Techniken des Transaktionsmanagements verstehen und in ihren Anwendungen umsetzen möchten.

Github

Transaktionsmanagement mit Spring, JPA, Hibernate

Paul Sterl — Sat, 31 Aug 2024 15:02:17 +0000

Lerne die Grundlagen des Transaktionsmanagements in modernen Datenbanken kennen, und erfahre, wie du mit Spring Boot, Spring Data, JPA und Hibernate effektiv arbeitest.

In diesem Tutorial starten wir mit den Grundlagen der Datenbanktransaktionen in deiner Anwendung: – Transaktionen starten:

Transaktion starten: Verstehe, wie Du Transaktionen in Spring Boot richtig initialisierst.
Rollback-Strategien: Erlerne die wichtigsten Methoden, um Transaktionen bei Fehlern sicher zurückzusetzen.
Annotations: Setze Annotations gezielt ein, um Transaktionen zu steuern.
Programmatische Transaktionen: Implementiere Transaktionen programmatisch und gewinne maximale Kontrolle.
Read Only: Transaktionen für GET Operationen
Timeouts: Wie stelle ich bei einer Transaktion einen Timeout ein, was muss ich beachten?

Dieses Video ist perfekt für Entwickler, die ihre Fähigkeiten in Spring Framework erweitern und transaktionssichere Anwendungen erstellen möchten.

Grundlagen Datenbanken | als Entwickler | Datenbank Locks vs Write Ahead | Spring | JPA | Hibernate

Paul Sterl — Sat, 13 Jan 2024 10:03:48 +0000

Last uns zusammen ein State Persistence Anwendung auf eine Write Ahead Anwendung abändern und die Verbesserung in der Skalierbarkeit dieser betrachten.

Wie synchronisieren wir parallelle Objektzugriffe in Java und Spring Boot, um die Skalierbarkeit unseres Systems zu optimieren?
Praktische Lösungen: Wie verarbeitet ein Java Spring Boot System viele Updates auf einmal nach einer Downtime?
Strategien für Lastspitzen in der Praxis: Einsatz von DB Locks in Java und Spring Boot.
Praktische Tipps und Tricks: Vor- und Nachteile von Locks in der Java Spring Boot Anwendung.
Weitere Optimierungsmöglichkeiten in der Java Spring Boot Architektur:
- Umsetzung von Write Ahead Log in Java und Spring Boo, welche Modifikationen sind notwendig?
- Was bring das an mehr Skalierbarkeit?

Datenbank| Transaktionen | Isolationlevel | Locks | Hibernate | JPA | Spring Boot

Paul Sterl — Mon, 02 Oct 2023 11:40:50 +0000

Um weiterführende Konzepte besser nachvollziehen zu können, wollen wir uns in den Grundlagen Datenbanken mit Spring Boot, Isolation Level (Isolationsgrad) und Locks beschäftigen.

Datenbank Timeouts | Locks | Isonaltionlevel | Transaktionen

Paul Sterl — Mon, 02 Oct 2023 11:15:27 +0000

Häufig vergessen, oder nur teilweise gemacht. Timeouts tragen einen wesentlichen Bestandteil zur Stabilität und dem Ressourcenmanagement von Software bei. Insbesondere bei Microservices sollten diese immer richtig eingestellt sein. Timeouts spielen auch eine wesentliche Rolle in Bezug auf Transaktionen, Locks und Isolationslevel. Sollte man zudem den Zugriff auf die Datenbank auch Dritten gewähren, also nicht nur den Services selbst, dann sind diese umso wichtiger, für alle Clients, die auf die Datenbank zugreifen.

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;
}