Polish code

Author: mercyblitz

projects/stage-1/middleware-frameworks/my-interceptor/src/main/java/org/geektimes/interceptor/util/InterceptorUtils.java

@@ -46,6 +46,18 @@ public abstract class InterceptorUtils {
 
     public static final Class<? extends Annotation> INTERCEPTOR_ANNOTATION_TYPE = javax.interceptor.Interceptor.class;
 
+    public static final Class<? extends Annotation> INTERCEPTOR_BINDING_ANNOTATION_TYPE = InterceptorBinding.class;
+
+    public static final Class<? extends Annotation> AROUND_INVOKE_ANNOTATION_TYPE = AroundInvoke.class;
+
+    public static final Class<? extends Annotation> AROUND_TIMEOUT_ANNOTATION_TYPE = AroundTimeout.class;
+
+    public static final Class<? extends Annotation> AROUND_CONSTRUCT_ANNOTATION_TYPE = AroundConstruct.class;
+
+    public static final Class<? extends Annotation> POST_CONSTRUCT_ANNOTATION_TYPE = PostConstruct.class;
+
+    public static final Class<? extends Annotation> PRE_DESTROY_ANNOTATION_TYPE = PreDestroy.class;
+
 
     public static boolean isInterceptorClass(Class<?> interceptorClass) {
         if (isAnnotationPresent(interceptorClass, INTERCEPTOR_ANNOTATION_TYPE)) {
@@ -105,7 +117,7 @@ public static <A extends Annotation> A searchAnnotation(Class<?> componentClass,
      *                               or if the return type of method is not <code>Object</code> or its derived type.
      */
     public static boolean isAroundInvokeMethod(Method method) {
-        return isInterceptionMethod(method, AroundInvoke.class, Object.class);
+        return isInterceptionMethod(method, AROUND_INVOKE_ANNOTATION_TYPE, Object.class);
     }
 
     /**
@@ -126,7 +138,7 @@ public static boolean isAroundInvokeMethod(Method method) {
      *                               or if the return type of method is not <code>Object</code> or its derived type.
      */
     public static boolean isAroundTimeoutMethod(Method method) {
-        return isInterceptionMethod(method, AroundTimeout.class, Object.class);
+        return isInterceptionMethod(method, AROUND_TIMEOUT_ANNOTATION_TYPE, Object.class);
     }
 
     /**
@@ -140,7 +152,7 @@ public static boolean isAroundTimeoutMethod(Method method) {
      *                               or if the return type of method is not <code>void</code>
      */
     public static boolean isAroundConstructMethod(Method method) {
-        return isInterceptionMethod(method, AroundConstruct.class, void.class);
+        return isInterceptionMethod(method, AROUND_CONSTRUCT_ANNOTATION_TYPE, void.class);
     }
 
     /**
@@ -154,7 +166,7 @@ public static boolean isAroundConstructMethod(Method method) {
      *                               or if the return type of method is not <code>void</code>
      */
     public static boolean isPostConstructMethod(Method method) {
-        return isInterceptionMethod(method, PostConstruct.class, void.class);
+        return isInterceptionMethod(method, POST_CONSTRUCT_ANNOTATION_TYPE, void.class);
     }
 
     /**
@@ -168,7 +180,7 @@ public static boolean isPostConstructMethod(Method method) {
      *                               or if the return type of method is not <code>void</code>
      */
     public static boolean isPreDestroyMethod(Method method) {
-        return isInterceptionMethod(method, PreDestroy.class, void.class);
+        return isInterceptionMethod(method, PRE_DESTROY_ANNOTATION_TYPE, void.class);
     }
 
 
@@ -282,7 +294,7 @@ private static void validateInterceptorClassMethods(Class<?> interceptorClass) {
     }
 
     public static boolean isAnnotatedInterceptorBinding(Class<? extends Annotation> annotationType) {
-        return isMetaAnnotation(annotationType, InterceptorBinding.class);
+        return isMetaAnnotation(annotationType, INTERCEPTOR_BINDING_ANNOTATION_TYPE);
     }
 
     public static boolean isAnnotatedInterceptorBinding(Executable executable,

projects/stage-1/middleware-frameworks/my-interceptor/src/test/java/org/geektimes/interceptor/Monitored.java

@@ -32,7 +32,7 @@
  * @since 1.0.0
  */
 @Inherited
-@InterceptorBinding
+@DataAccess
 @Target({TYPE, METHOD})
 @Retention(RUNTIME)
 public @interface Monitored {

projects/stage-1/middleware-frameworks/my-interceptor/src/test/java/org/geektimes/interceptor/util/InterceptorUtilsTest.java

@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.geektimes.interceptor.util;
+
+import org.geektimes.interceptor.ExternalInterceptor;
+import org.geektimes.interceptor.Logging;
+import org.geektimes.interceptor.Monitored;
+import org.junit.Test;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.interceptor.*;
+
+import static org.geektimes.interceptor.util.InterceptorUtils.*;
+import static org.junit.Assert.*;
+
+/**
+ * {@link InterceptorUtils} Test
+ *
+ * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
+ * @since 1.0.0
+ */
+public class InterceptorUtilsTest {
+
+    @Test
+    public void testConstants() {
+        assertEquals(javax.interceptor.Interceptor.class, INTERCEPTOR_ANNOTATION_TYPE);
+        assertEquals(InterceptorBinding.class, INTERCEPTOR_BINDING_ANNOTATION_TYPE);
+        assertEquals(AroundInvoke.class, AROUND_INVOKE_ANNOTATION_TYPE);
+        assertEquals(AroundTimeout.class, AROUND_TIMEOUT_ANNOTATION_TYPE);
+        assertEquals(AroundConstruct.class, AROUND_CONSTRUCT_ANNOTATION_TYPE);
+        assertEquals(PostConstruct.class, POST_CONSTRUCT_ANNOTATION_TYPE);
+        assertEquals(PreDestroy.class, PRE_DESTROY_ANNOTATION_TYPE);
+    }
+
+    @Test
+    public void testIsInterceptorClass() {
+        isInterceptorClass(ExternalInterceptor.class);
+    }
+
+    @Test
+    public void testValidateInterceptorClass() {
+        validateInterceptorClass(ExternalInterceptor.class);
+        testOnError(() -> validateInterceptorClass(String.class), IllegalStateException.class);
+        testOnError(() -> validateInterceptorClass(A.class), IllegalStateException.class);
+        testOnError(() -> validateInterceptorClass(B.class), IllegalStateException.class);
+    }
+
+    protected void testOnError(Runnable runnable, Class<? extends Throwable> errorClass) {
+        Throwable throwable = null;
+        try {
+            runnable.run();
+        } catch (Throwable e) {
+            throwable = e;
+        }
+        assertTrue(errorClass.isAssignableFrom(throwable.getClass()));
+    }
+
+    @Test
+    public void testIsAnnotatedInterceptorBinding() {
+        assertTrue(isAnnotatedInterceptorBinding(Logging.class));
+        assertTrue(isAnnotatedInterceptorBinding(Monitored.class));
+        assertFalse(isAnnotatedInterceptorBinding(Override.class));
+    }
+
+    @Interceptor
+    abstract class A {
+    }
+
+    @Interceptor
+    final class B {
+    }
+}