Transactional annotation support (#6)

* simpler class hierarchie and added test to find the Transactional
annotation
* added transaction behavior test
* added detection for Transactional methods
* added test for REQUIRES_NEW
*  @transactional Annotation support
*  PersistentTask instead of Task or SpringBeanTask

Author: sterlp

CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## v1.4.0 - (2025-01-02)
+
+-  @Transactional Annotation support
+-  PersistentTask instead of Task or SpringBeanTask
+
+
+## v1.3.1 - (2025-01-02)
+
+-  Bugfixes
+-  Sprign Transaction Template support
+
 ## v1.3.0 - (2025-01-01)
 
 -   MariaDB support

README.md

@@ -59,7 +59,7 @@ public class ExampleApplication {
 @Component(BuildVehicleTask.NAME)
 @RequiredArgsConstructor
 @Slf4j
-public class BuildVehicleTask implements SpringBeanTask<Vehicle> {
+public class BuildVehicleTask implements PersistentTask<Vehicle> {
 
     private static final String NAME = "buildVehicleTask";
     public static final TaskId<Vehicle> ID = new TaskId<>(NAME);
@@ -109,11 +109,15 @@ Simple task will use defaults:
 
 ```java
 @Bean
-SpringBeanTask<Vehicle> task1(VehicleHttpConnector vehicleHttpConnector) {
+PersistentTask<Vehicle> task1(VehicleHttpConnector vehicleHttpConnector) {
     return v -> vehicleHttpConnector.send(v);
 }
 ```
 
+### Task Transaction Management
+
+[Transaction-Management Task](https://github.com/sterlp/spring-persistent-tasks/wiki/Transaction-Management)
+
 ## Queue a task execution
 
 ### Direct usage of the `TriggerService` or `PersistentTaskService`.

RUN_AND_BUILD.md

@@ -1,6 +1,6 @@
 mvn versions:display-dependency-updates
-mvn versions:set -DnewVersion=1.3.1 -DgenerateBackupPoms=false
-mvn versions:set -DnewVersion=1.3.2-SNAPSHOT -DgenerateBackupPoms=false
+mvn versions:set -DnewVersion=1.4.0-SNAPSHOT -DgenerateBackupPoms=false
+mvn versions:set -DnewVersion=1.4.0 -DgenerateBackupPoms=false
 
 ## postgres
 docker run --name pg-container -e POSTGRES_USER=sa -e POSTGRES_PASSWORD=veryStrong123 -p 5432:5432 -d postgres

core/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <groupId>org.sterl.spring</groupId>
         <artifactId>spring-persistent-tasks-root</artifactId>
-        <version>1.3.2-SNAPSHOT</version>
+        <version>1.4.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

core/src/main/java/org/sterl/spring/persistent_tasks/api/AddTriggerRequest.java

@@ -5,7 +5,7 @@
 
 /**
 /**
- * For any registered task a task trigger represent one unit of work, executing this task once.
+ * For any registered persistentTask a persistentTask trigger represent one unit of work, executing this persistentTask once.
  * @param <T> state type which has to be of {@link Serializable}
  */
 public record AddTriggerRequest<T extends Serializable>(

core/src/main/java/org/sterl/spring/persistent_tasks/api/PersistentTask.java

@@ -0,0 +1,34 @@
+package org.sterl.spring.persistent_tasks.api;
+
+import java.io.Serializable;
+
+/**
+ * A Spring persistent task whose state is saved in a {@link Trigger}.
+ *
+ * <p>This interface defines a task that accepts a state of type <code>T</code> and
+ * provides default implementations for retry strategies.
+ *
+ * @param <T> the type of the state, which must be {@link Serializable}
+ */
+@FunctionalInterface
+public interface PersistentTask<T extends Serializable> {
+    void accept(T state);
+
+    default RetryStrategy retryStrategy() {
+        return RetryStrategy.THREE_RETRIES;
+    }
+    
+    /**
+     * Whether the persistentTask is transaction or not. If <code>true</code> the execution
+     * is wrapped into the default transaction template together with the state update
+     * and the following events:
+     * <ol>
+     * <li>org.sterl.spring.persistent_tasks.trigger.event.TriggerRunningEvent</li>
+     * <li>org.sterl.spring.persistent_tasks.trigger.event.TriggerSuccessEvent</li>
+     * </ol>
+     * @return {@code true} if the persistentTask is transactional; {@code false} otherwise.
+     */
+    default boolean isTransactional() {
+        return false;
+    }
+}

core/src/main/java/org/sterl/spring/persistent_tasks/api/SpringBeanTask.java

@@ -1,29 +1,12 @@
 package org.sterl.spring.persistent_tasks.api;
 
 import java.io.Serializable;
-import java.util.function.Consumer;
 
+/**
+ * Same as {@link PersistentTask}
+ */
+@Deprecated
 @FunctionalInterface
-public interface SpringBeanTask<T extends Serializable> extends Consumer<T> {
-    @Override
-    void accept(T state);
-
-    default RetryStrategy retryStrategy() {
-        return RetryStrategy.THREE_RETRIES;
-    }
+public interface SpringBeanTask<T extends Serializable> extends PersistentTask<T> {
 
-    /**
-     * Whether the task is transaction or not. If <code>true</code> the execution
-     * is wrapped into the default transaction template together with the state update
-     * and the following events:
-     * <ol>
-     * <li>org.sterl.spring.persistent_tasks.trigger.event.TriggerRunningEvent</li>
-     * <li>org.sterl.spring.persistent_tasks.trigger.event.TriggerSuccessEvent</li>
-     * <li>org.sterl.spring.persistent_tasks.trigger.event.TriggerFailedEvent</li>
-     * </ol>
-     * @return {@code true} if the task is transactional; {@code false} otherwise.
-     */
-    default boolean isTransactional() {
-        return false;
-    }
 }

core/src/main/java/org/sterl/spring/persistent_tasks/api/Task.java

@@ -8,7 +8,7 @@
 import lombok.RequiredArgsConstructor;
 
 /**
- * Represents the ID of a task, which is currently not running.
+ * Represents the ID of a persistentTask, which is currently not running.
  */
 public record TaskId<T extends Serializable>(String name) implements Serializable {
 

core/src/main/java/org/sterl/spring/persistent_tasks/api/TaskId.java

@@ -0,0 +1,30 @@
+package org.sterl.spring.persistent_tasks.api;
+
+import java.io.Serializable;
+
+/**
+ * Similar to {@link PersistentTask} but specifically for transactional workloads.
+ * Use this interface when the task execution should be wrapped in a transaction.
+ *
+ * <p>This interface ensures that the task's execution is transactional, meaning that it will
+ * be executed within a transaction context, along with the state update and the dispatching of
+ * relevant events.
+ *
+ * @param <T> the type of the state, which must be {@link Serializable}
+ */
+@FunctionalInterface
+public interface TransactionalTask<T extends Serializable> extends PersistentTask<T> {
+    /**
+     * Whether the persistentTask is transaction or not. If <code>true</code> the execution
+     * is wrapped into the default transaction template together with the state update
+     * and the following events:
+     * <ol>
+     * <li>org.sterl.spring.persistent_tasks.trigger.event.TriggerRunningEvent</li>
+     * <li>org.sterl.spring.persistent_tasks.trigger.event.TriggerSuccessEvent</li>
+     * </ol>
+     * @return {@code true} if the persistentTask is transactional; {@code false} otherwise.
+     */
+    default boolean isTransactional() {
+        return true;
+    }
+}