Honor Cache and NoCache annotations on CDI bean implementations of a …

…JaxRS interface
quarkusio · Feb 28, 2024 · a4559fe · a4559fe
1 parent 4dd779e
commit a4559fe
Show file tree

Hide file tree

Showing 10 changed files with 823 additions and 8 deletions.
diff --git a/.../main/java/org/jboss/resteasy/reactive/server/processor/scanning/CacheControlScanner.java b/.../main/java/org/jboss/resteasy/reactive/server/processor/scanning/CacheControlScanner.java
@@ -1,5 +1,6 @@
 package org.jboss.resteasy.reactive.server.processor.scanning;
 
+import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
@@ -10,6 +11,7 @@
 import org.jboss.jandex.ClassInfo;
 import org.jboss.jandex.DotName;
 import org.jboss.jandex.MethodInfo;
+import org.jboss.jandex.Type;
 import org.jboss.resteasy.reactive.Cache;
 import org.jboss.resteasy.reactive.NoCache;
 import org.jboss.resteasy.reactive.common.processor.EndpointIndexer;
@@ -27,32 +29,55 @@ public class CacheControlScanner implements MethodScanner {
     @Override
     public List<HandlerChainCustomizer> scan(MethodInfo method, ClassInfo actualEndpointClass,
             Map<String, Object> methodContext) {
+
+        ClassInfo currentClassInfo = method.declaringClass();
+
+        // Check whether the actualEndpointClass is implementing an interface containing the method
+        // In this case, allow annotations on the implementation itself to take precedence over annotations on the
+        // interface.
+        if (!actualEndpointClass.equals(currentClassInfo) && Modifier.isInterface(currentClassInfo.flags())) {
+            MethodInfo actualMethod = actualEndpointClass.method(method.name(), method.parameterTypes().toArray(new Type[0]));
+
+            // first check bean implementation
+            List<HandlerChainCustomizer> customizers = scanImpl(actualMethod, actualEndpointClass, methodContext);
+            if (customizers.isEmpty()) {
+                // if no annotations where found on implementation, check the interface
+                customizers = scanImpl(method, currentClassInfo, methodContext);
+            }
+            return customizers;
+        } else {
+            return scanImpl(method, actualEndpointClass, methodContext);
+        }
+    }
+
+    private List<HandlerChainCustomizer> scanImpl(MethodInfo methodInfo, ClassInfo classInfo,
+                                                  Map<String, Object> methodContext) {
         AnnotationStore annotationStore = (AnnotationStore) methodContext.get(EndpointIndexer.METHOD_CONTEXT_ANNOTATION_STORE);
-        ExtendedCacheControl cacheControl = noCacheToCacheControl(annotationStore.getAnnotation(method, NO_CACHE));
+        ExtendedCacheControl cacheControl = noCacheToCacheControl(annotationStore.getAnnotation(methodInfo, NO_CACHE));
         if (cacheControl != null) {
-            if (method.annotation(CACHE) != null) {
+            if (methodInfo.annotation(CACHE) != null) {
                 throw new IllegalStateException(
                         "A resource method cannot be simultaneously annotated with '@Cache' and '@NoCache'. Offending method is '"
-                                + method.name() + "' of class '" + method.declaringClass().name() + "'");
+                                + methodInfo.name() + "' of class '" + methodInfo.declaringClass().name() + "'");
             }
             return cacheControlToCustomizerList(cacheControl);
         } else {
-            cacheControl = noCacheToCacheControl(annotationStore.getAnnotation(actualEndpointClass, NO_CACHE));
+            cacheControl = noCacheToCacheControl(annotationStore.getAnnotation(classInfo, NO_CACHE));
             if (cacheControl != null) {
-                if (actualEndpointClass.declaredAnnotation(CACHE) != null) {
+                if (classInfo.declaredAnnotation(CACHE) != null) {
                     throw new IllegalStateException(
                             "A resource class cannot be simultaneously annotated with '@Cache' and '@NoCache'. Offending class is '"
-                                    + actualEndpointClass.name() + "'");
+                                    + classInfo.name() + "'");
                 }
                 return cacheControlToCustomizerList(cacheControl);
             }
         }
 
-        cacheControl = cacheToCacheControl(method.annotation(CACHE));
+        cacheControl = cacheToCacheControl(methodInfo.annotation(CACHE));
         if (cacheControl != null) {
             return cacheControlToCustomizerList(cacheControl);
         } else {
-            cacheControl = cacheToCacheControl(actualEndpointClass.declaredAnnotation(CACHE));
+            cacheControl = cacheToCacheControl(classInfo.declaredAnnotation(CACHE));
             if (cacheControl != null) {
                 return cacheControlToCustomizerList(cacheControl);
             }

diff --git a/...s/resteasy/reactive/server/vertx/test/cache/CacheOnClassAndMethodsImplementationTest.java b/...s/resteasy/reactive/server/vertx/test/cache/CacheOnClassAndMethodsImplementationTest.java
@@ -0,0 +1,82 @@
+package org.jboss.resteasy.reactive.server.vertx.test.cache;
+
+import io.restassured.RestAssured;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import org.jboss.resteasy.reactive.Cache;
+import org.jboss.resteasy.reactive.server.processor.ResteasyReactiveDeploymentManager;
+import org.jboss.resteasy.reactive.server.processor.scanning.CacheControlScanner;
+import org.jboss.resteasy.reactive.server.vertx.test.framework.ResteasyReactiveUnitTest;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+
+public class CacheOnClassAndMethodsImplementationTest {
+
+    @RegisterExtension
+    static ResteasyReactiveUnitTest test = new ResteasyReactiveUnitTest()
+            .addScanCustomizer(new Consumer<ResteasyReactiveDeploymentManager.ScanStep>() {
+                @Override
+                public void accept(ResteasyReactiveDeploymentManager.ScanStep scanStep) {
+                    scanStep.addMethodScanner(new CacheControlScanner());
+                }
+            })
+            .setArchiveProducer(new Supplier<>() {
+                @Override
+                public JavaArchive get() {
+                    return ShrinkWrap.create(JavaArchive.class)
+                            .addClasses(ResourceWithCache.class);
+                }
+            });
+
+    @Test
+    public void testWith() {
+        RestAssured.get("/test/with")
+                .then()
+                .statusCode(200)
+                .body(equalTo("with"))
+                .header("Cache-Control", "no-store");
+    }
+
+    @Test
+    public void testWithout() {
+        RestAssured.get("/test/without")
+                .then()
+                .statusCode(200)
+                .body(equalTo("without"))
+                .header("Cache-Control", "no-cache, no-transform, proxy-revalidate, s-maxage=100");
+    }
+
+    @Path("test")
+    public interface IResourceWithCache {
+
+        @Path("with")
+        @GET
+        String with();
+
+        @Path("without")
+        @GET
+        String without();
+    }
+
+    @Cache(sMaxAge = 100, noTransform = true, proxyRevalidate = true, noCache = true)
+    public static class ResourceWithCache implements IResourceWithCache{
+
+        @Override
+        @Cache(noStore = true)
+        public String with() {
+            return "with";
+        }
+
+        @Override
+        public String without() {
+            return "without";
+        }
+    }
+}
diff --git a/.../jboss/resteasy/reactive/server/vertx/test/cache/CacheOnClassAndMethodsInterfaceTest.java b/.../jboss/resteasy/reactive/server/vertx/test/cache/CacheOnClassAndMethodsInterfaceTest.java
@@ -0,0 +1,82 @@
+package org.jboss.resteasy.reactive.server.vertx.test.cache;
+
+import io.restassured.RestAssured;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import org.jboss.resteasy.reactive.Cache;
+import org.jboss.resteasy.reactive.server.processor.ResteasyReactiveDeploymentManager;
+import org.jboss.resteasy.reactive.server.processor.scanning.CacheControlScanner;
+import org.jboss.resteasy.reactive.server.vertx.test.framework.ResteasyReactiveUnitTest;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+
+public class CacheOnClassAndMethodsInterfaceTest {
+
+    @RegisterExtension
+    static ResteasyReactiveUnitTest test = new ResteasyReactiveUnitTest()
+            .addScanCustomizer(new Consumer<ResteasyReactiveDeploymentManager.ScanStep>() {
+                @Override
+                public void accept(ResteasyReactiveDeploymentManager.ScanStep scanStep) {
+                    scanStep.addMethodScanner(new CacheControlScanner());
+                }
+            })
+            .setArchiveProducer(new Supplier<>() {
+                @Override
+                public JavaArchive get() {
+                    return ShrinkWrap.create(JavaArchive.class)
+                            .addClasses(ResourceWithCache.class);
+                }
+            });
+
+    @Test
+    public void testWith() {
+        RestAssured.get("/test/with")
+                .then()
+                .statusCode(200)
+                .body(equalTo("with"))
+                .header("Cache-Control", "no-store");
+    }
+
+    @Test
+    public void testWithout() {
+        RestAssured.get("/test/without")
+                .then()
+                .statusCode(200)
+                .body(equalTo("without"))
+                .header("Cache-Control", "no-cache, no-transform, proxy-revalidate, s-maxage=100");
+    }
+
+    @Path("test")
+    @Cache(sMaxAge = 100, noTransform = true, proxyRevalidate = true, noCache = true)
+    public interface IResourceWithCache {
+
+        @Path("with")
+        @Cache(noStore = true)
+        @GET
+        String with();
+
+        @Path("without")
+        @GET
+        String without();
+    }
+
+    public static class ResourceWithCache implements IResourceWithCache{
+
+        @Override
+        public String with() {
+            return "with";
+        }
+
+        @Override
+        public String without() {
+            return "without";
+        }
+    }
+}
diff --git a/...org/jboss/resteasy/reactive/server/vertx/test/cache/CacheOnMethodsImplementationTest.java b/...org/jboss/resteasy/reactive/server/vertx/test/cache/CacheOnMethodsImplementationTest.java
@@ -0,0 +1,82 @@
+package org.jboss.resteasy.reactive.server.vertx.test.cache;
+
+import io.restassured.RestAssured;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import org.jboss.resteasy.reactive.Cache;
+import org.jboss.resteasy.reactive.server.processor.ResteasyReactiveDeploymentManager;
+import org.jboss.resteasy.reactive.server.processor.scanning.CacheControlScanner;
+import org.jboss.resteasy.reactive.server.vertx.test.framework.ResteasyReactiveUnitTest;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.Matchers.nullValue;
+
+public class CacheOnMethodsImplementationTest {
+
+    @RegisterExtension
+    static ResteasyReactiveUnitTest test = new ResteasyReactiveUnitTest()
+            .addScanCustomizer(new Consumer<ResteasyReactiveDeploymentManager.ScanStep>() {
+                @Override
+                public void accept(ResteasyReactiveDeploymentManager.ScanStep scanStep) {
+                    scanStep.addMethodScanner(new CacheControlScanner());
+                }
+            })
+            .setArchiveProducer(new Supplier<>() {
+                @Override
+                public JavaArchive get() {
+                    return ShrinkWrap.create(JavaArchive.class)
+                            .addClasses(IResourceWithCache.class, ResourceWithCache.class);
+                }
+            });
+
+    @Test
+    public void testWith() {
+        RestAssured.get("/test/with")
+                .then()
+                .statusCode(200)
+                .body(equalTo("with"))
+                .header("Cache-Control", "must-revalidate, no-store, max-age=100, private");
+    }
+
+    @Test
+    public void testWithout() {
+        RestAssured.get("/test/without")
+                .then()
+                .statusCode(200)
+                .body(equalTo("without"))
+                .header("Cache-Control", nullValue());
+    }
+
+    @Path("test")
+    public interface IResourceWithCache {
+
+        @Path("with")
+        @GET
+        String with();
+
+        @Path("without")
+        @GET
+        String without();
+    }
+
+    public static class ResourceWithCache implements IResourceWithCache {
+
+        @Override
+        @Cache(maxAge = 100, noStore = true, mustRevalidate = true, isPrivate = true)
+        public String with() {
+            return "with";
+        }
+
+        @Override
+        public String without() {
+            return "without";
+        }
+    }
+}