feat: add spring cache filter (#172)

Author: YongwuHe

arex-instrumentation/dynamic/arex-cache/src/main/java/io/arex/inst/cache/spring/SpringCacheAdviceHelper.java

@@ -0,0 +1,31 @@
+package io.arex.inst.cache.spring;
+
+import io.arex.inst.runtime.config.Config;
+import io.arex.inst.runtime.context.ContextManager;
+import io.arex.inst.runtime.model.DynamicClassEntity;
+
+import java.lang.reflect.Method;
+
+public class SpringCacheAdviceHelper {
+    public static boolean needRecordOrReplay(Method method) {
+        if (!ContextManager.needRecordOrReplay() || method == null) {
+            return false;
+        }
+
+        String methodSignature = buildMethodSignature(method);
+
+        DynamicClassEntity dynamicEntity = Config.get().getDynamicEntity(methodSignature);
+
+        return dynamicEntity != null;
+    }
+
+    private static String buildMethodSignature(Method method) {
+        String className = method.getDeclaringClass().getName();
+        String methodName = method.getName();
+        Class<?>[] parameterTypes = method.getParameterTypes();
+        if (parameterTypes.length == 0) {
+            return className + methodName;
+        }
+        return className + methodName + parameterTypes.length;
+    }
+}

arex-instrumentation/dynamic/arex-cache/src/main/java/io/arex/inst/cache/spring/SpringCacheInstrumentation.java

@@ -46,12 +46,12 @@ public static boolean onEnter(@Advice.Argument(2) Method method,
                 return false;
             }
 
-            if (ContextManager.needRecordOrReplay()) {
+            if (SpringCacheAdviceHelper.needRecordOrReplay(method)) {
                 Cacheable cacheable = method.getDeclaredAnnotation(Cacheable.class);
                 String keyExpression = cacheable != null ? cacheable.key() : null;
                 extractor = new DynamicClassExtractor(method, args, keyExpression, null);
             }
-            if (ContextManager.needReplay()) {
+            if (extractor != null && ContextManager.needReplay()) {
                 mockResult = extractor.replay();
                 return mockResult != null && mockResult.notIgnoreMockResult();
             }

arex-instrumentation/dynamic/arex-cache/src/test/java/io/arex/inst/cache/spring/SpringCacheAdviceHelperTest.java

@@ -0,0 +1,76 @@
+package io.arex.inst.cache.spring;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import io.arex.inst.runtime.config.ConfigBuilder;
+import io.arex.inst.runtime.context.ContextManager;
+import io.arex.inst.runtime.model.DynamicClassEntity;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+class SpringCacheAdviceHelperTest {
+    @BeforeAll
+    static void setUp() {
+        Mockito.mockStatic(ContextManager.class);
+    }
+
+    @AfterAll
+    static void tearDown() {
+        Mockito.clearAllCaches();
+    }
+
+    @Test
+    void needRecordOrReplay() throws NoSuchMethodException {
+        final Method method1 = SpringCacheAdviceHelperTest.class.getDeclaredMethod("method1");
+        final ConfigBuilder configBuilder = ConfigBuilder.create("test");
+        configBuilder.build();
+
+        // not need record or replay
+        Mockito.when(ContextManager.needRecordOrReplay()).thenReturn(false);
+        final boolean needRecordOrReplay = SpringCacheAdviceHelper.needRecordOrReplay(method1);
+        assertFalse(needRecordOrReplay);
+
+        // null method
+        final boolean nullMethod = SpringCacheAdviceHelper.needRecordOrReplay(null);
+        assertFalse(nullMethod);
+
+        Mockito.when(ContextManager.needRecordOrReplay()).thenReturn(true);
+        // no dynamic class
+        final boolean noDynamicClass = SpringCacheAdviceHelper.needRecordOrReplay(method1);
+        assertFalse(noDynamicClass);
+
+        // has dynamic class, but not contains method
+        final List<DynamicClassEntity> entities = new ArrayList<>();
+        entities.add(new DynamicClassEntity("io.arex.inst.cache.spring.SpringCacheAdviceHelperTest", null, null, null));
+        configBuilder.dynamicClassList(entities).build();
+        final boolean notContainsMethod = SpringCacheAdviceHelper.needRecordOrReplay(method1);
+        assertFalse(notContainsMethod);
+
+        // has no args dynamic class, and contains method
+        entities.add(new DynamicClassEntity("io.arex.inst.cache.spring.SpringCacheAdviceHelperTest", "method1", null, null));
+        configBuilder.dynamicClassList(entities).build();
+        final boolean containsMethod = SpringCacheAdviceHelper.needRecordOrReplay(method1);
+        assertTrue(containsMethod);
+
+        // has args dynamic class, and contains method
+        final Method method2 = SpringCacheAdviceHelperTest.class.getDeclaredMethod("method2",
+                String.class);
+        entities.add(new DynamicClassEntity("io.arex.inst.cache.spring.SpringCacheAdviceHelperTest", "method2", "java.lang.String", null));
+        configBuilder.dynamicClassList(entities).build();
+        final boolean containsMethod2 = SpringCacheAdviceHelper.needRecordOrReplay(method2);
+        assertTrue(containsMethod2);
+    }
+
+    public void method1() {
+
+    }
+
+    public void method2(String arg1) {
+
+    }
+}

arex-instrumentation/dynamic/arex-cache/src/test/java/io/arex/inst/cache/spring/SpringCacheInstrumentationTest.java

@@ -1,6 +1,8 @@
 package io.arex.inst.cache.spring;
 
 import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+
 import io.arex.agent.bootstrap.model.MockResult;
 import io.arex.inst.cache.TestArexMock;
 import io.arex.inst.dynamic.common.DynamicClassExtractor;
@@ -29,6 +31,7 @@ static void setUp() {
         Mockito.mockStatic(ContextManager.class);
         Mockito.mockStatic(MockUtils.class);
         Mockito.mockStatic(RepeatedCollectManager.class);
+        Mockito.mockStatic(SpringCacheAdviceHelper.class);
     }
 
     @AfterAll
@@ -59,8 +62,13 @@ void onEnter() throws NoSuchMethodException {
             boolean actualResult = SpringCacheInstrumentation.SpringCacheAdvice.onEnter(testReturnVoid, null, null, null);
             assertFalse(actualResult);
 
+            // not record
+            Mockito.when(SpringCacheAdviceHelper.needRecordOrReplay(any())).thenReturn(false);
+            actualResult = SpringCacheInstrumentation.SpringCacheAdvice.onEnter(test1, new Object[]{ "name", 18 }, null, null);
+            assertFalse(actualResult);
+
             // record
-            Mockito.when(ContextManager.needRecordOrReplay()).thenReturn(true);
+            Mockito.when(SpringCacheAdviceHelper.needRecordOrReplay(any())).thenReturn(true);
             Mockito.when(ContextManager.needRecord()).thenReturn(true);
             DynamicClassExtractor extractor = new DynamicClassExtractor(test1, new Object[]{"mock"}, "#val", null);
             actualResult = SpringCacheInstrumentation.SpringCacheAdvice.onEnter(test1, new Object[]{ "name", 18 }, extractor, null);