✨ feat: add annotation saga #4

Author: pnguyen215

README.md

@@ -95,6 +95,10 @@ testImplementation group: 'org.springframework.boot', name: 'spring-boot-starter
 // enabling developers to write unit tests using Mockito's powerful mocking features.
 // It's designed to work specifically with the JUnit 5 platform, allowing for advanced testing capabilities.
 testImplementation group: 'org.mockito', name: 'mockito-junit-jupiter', version: '3.12.4'
+// The "spring-boot-starter-aop" library, version 2.7.18, provides support for Aspect-Oriented Programming (AOP) in Spring Boot applications.
+// AOP enables modularization of cross-cutting concerns such as logging, security, and transactions by allowing aspects to be applied to various parts of the application.
+// This starter simplifies the setup and configuration of AOP-related functionality, promoting cleaner and more maintainable code by separating concerns effectively.
+implementation group: 'org.springframework.boot', name: 'spring-boot-starter-aop', version: '2.7.18'
 ```
 
 ## Integration

plugin/build.gradle

@@ -187,6 +187,10 @@ dependencies {
     // enabling developers to write unit tests using Mockito's powerful mocking features.
     // It's designed to work specifically with the JUnit 5 platform, allowing for advanced testing capabilities.
     testImplementation group: 'org.mockito', name: 'mockito-junit-jupiter', version: '3.12.4'
+    // The "spring-boot-starter-aop" library, version 2.7.18, provides support for Aspect-Oriented Programming (AOP) in Spring Boot applications.
+    // AOP enables modularization of cross-cutting concerns such as logging, security, and transactions by allowing aspects to be applied to various parts of the application.
+    // This starter simplifies the setup and configuration of AOP-related functionality, promoting cleaner and more maintainable code by separating concerns effectively.
+    implementation group: 'org.springframework.boot', name: 'spring-boot-starter-aop', version: '2.7.18'
 }
 
 test {

plugin/src/main/groovy/org/clarify4j/config/Clarify4jConfig.java

@@ -1,7 +1,9 @@
 package org.clarify4j.config;
 
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.EnableAspectJAutoProxy;
 
 @Configuration
+@EnableAspectJAutoProxy
 public class Clarify4jConfig {
 }

plugin/src/main/groovy/org/clarify4j/config/annotation/Saga.java

@@ -0,0 +1,14 @@
+package org.clarify4j.config.annotation;
+
+import java.lang.annotation.*;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD, ElementType.TYPE})
+public @interface Saga {
+    String expression();
+
+    boolean disable() default false;
+
+    Class<?> clazz() default Saga.class;
+}

plugin/src/main/groovy/org/clarify4j/config/handler/SagaHandler.java

@@ -0,0 +1,53 @@
+package org.clarify4j.config.handler;
+
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.annotation.Pointcut;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.clarify4j.config.annotation.Saga;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.expression.EvaluationContext;
+import org.springframework.expression.ExpressionParser;
+import org.springframework.expression.common.TemplateParserContext;
+import org.springframework.expression.spel.standard.SpelExpressionParser;
+import org.springframework.expression.spel.support.StandardEvaluationContext;
+import org.springframework.stereotype.Component;
+import org.unify4j.common.Object4j;
+
+import java.lang.reflect.Method;
+
+@Aspect
+@Component
+public class SagaHandler {
+    protected static Logger logger = LoggerFactory.getLogger(SagaHandler.class);
+    protected static final TemplateParserContext TEMPLATE_PARSER_CONTEXT = new TemplateParserContext("{{", "}}");
+    protected static final ExpressionParser EXPRESSION_PARSER = new SpelExpressionParser();
+
+    @Pointcut(value = "@annotation(org.clarify4j.config.annotation.Saga)")
+    public void controller() {
+    }
+
+    @Before(value = "controller()")
+    public void handle(JoinPoint joinPoint) throws Throwable {
+        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+        Method method = signature.getMethod();
+        Saga saga = method.getAnnotation(Saga.class);
+        if (saga.disable()) {
+            return;
+        }
+        EvaluationContext context = new StandardEvaluationContext();
+        Object[] args = joinPoint.getArgs();
+        String[] parameters = signature.getParameterNames();
+
+        for (int i = 0; i < args.length; i++) {
+            context.setVariable(parameters[i], args[i]);
+        }
+        String value = EXPRESSION_PARSER.parseExpression(saga.expression(), TEMPLATE_PARSER_CONTEXT).getValue(context, String.class);
+        if (Object4j.allNotNull(saga.clazz())) {
+            logger = LoggerFactory.getLogger(saga.clazz());
+        }
+        logger.info(value);
+    }
+}

plugin/src/test/groovy/org/clarify4j/SagaAspectTest.java

@@ -0,0 +1,60 @@
+package org.clarify4j;
+
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.clarify4j.config.annotation.Saga;
+import org.clarify4j.config.handler.SagaHandler;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.lang.reflect.Method;
+
+import static org.mockito.Mockito.*;
+
+public class SagaAspectTest {
+    @Mock
+    private JoinPoint joinPoint;
+
+    @Mock
+    private MethodSignature methodSignature;
+
+    @InjectMocks
+    private SagaHandler sagaHandler;
+
+    @BeforeEach
+    public void setUp() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    public void testSaga() throws Throwable {
+        // Create a Method instance representing the method to be tested
+        Method method = TestMethods.class.getMethod("updateUser", Long.class, String.class);
+
+        // Mock method signature and annotation
+        when(joinPoint.getSignature()).thenReturn(methodSignature);
+        when(methodSignature.getMethod()).thenReturn(method);
+
+        // Mock method arguments
+        when(joinPoint.getArgs()).thenReturn(new Object[]{1L, "John Doe"});
+        when(methodSignature.getParameterNames()).thenReturn(new String[]{"userId", "newName"});
+
+        // Call the aspect method
+        sagaHandler.handle(joinPoint);
+
+        // Verify that the logging occurred (you might mock the logging framework to assert this)
+        // Here, we are just verifying that the method ran without exceptions
+        verify(joinPoint, times(1)).getSignature();
+    }
+
+    // Helper class to provide the method for reflection
+    public static class TestMethods {
+        @Saga(expression = "User {{#userId}} is being updated with the name {{#newName}}")
+        public void updateUser(Long userId, String newName) {
+            // This method is just a placeholder for reflection
+        }
+    }
+}

plugin/src/test/groovy/org/clarify4j/Wizard4jPluginTest.groovy

@@ -5,5 +5,5 @@
  * For more detailed information on multi-project builds, please refer to https://docs.gradle.org/8.6/userguide/multi_project_builds.html in the Gradle documentation.
  */
 
-rootProject.name = 'wizards2s4j'
+rootProject.name = 'clarify4j'
 include('plugin')