Polish code

Author: mercyblitz

projects/stage-1/middleware-frameworks/my-cdi/src/main/java/org/geektimes/enterprise/inject/standard/beans/BeanArchiveManager.java

@@ -30,6 +30,7 @@
 import org.geektimes.enterprise.inject.util.Qualifiers;
 import org.geektimes.enterprise.inject.util.Scopes;
 import org.geektimes.enterprise.inject.util.Stereotypes;
+import org.geektimes.interceptor.InterceptorManager;
 import org.geektimes.interceptor.util.InterceptorUtils;
 
 import javax.enterprise.context.*;
@@ -60,7 +61,8 @@
 import static org.geektimes.enterprise.inject.standard.beans.BeanTypeSource.*;
 import static org.geektimes.enterprise.inject.standard.beans.xml.BeansReader.BEANS_XML_RESOURCE_NAME;
 import static org.geektimes.enterprise.inject.util.Decorators.isDecorator;
-import static org.geektimes.interceptor.util.InterceptorUtils.isInterceptorClass;
+import static org.geektimes.interceptor.InterceptorManager.getInstance;
+
 
 /**
  * Bean archives Manager
@@ -80,6 +82,8 @@ public class BeanArchiveManager {
 
     private final SimpleClassScanner classScanner;
 
+    private final InterceptorManager interceptorManager;
+
     private final Map<BeanTypeSource, List<Class<?>>> beanClasses;
 
     private final Map<BeanTypeSource, List<Class<?>>> interceptorClasses;
@@ -140,6 +144,7 @@ public BeanArchiveManager(ClassLoader classLoader) {
         this.classLoader = classLoader;
         this.beansReader = ServiceLoaders.loadSpi(BeansReader.class, classLoader);
         this.classScanner = SimpleClassScanner.INSTANCE;
+        this.interceptorManager = getInstance(classLoader);
 
         this.beanClasses = new TreeMap<>();
         this.interceptorClasses = new TreeMap<>();
@@ -272,7 +277,7 @@ private void addEnabledInterceptorClasses(org.geektimes.enterprise.inject.standa
 
     private void discoverInterceptorClasses(Set<Class<?>> discoveredTypes) {
         filterAndHandleBeanTypes(discoveredTypes,
-                InterceptorUtils::isInterceptorClass,
+                interceptorManager::isInterceptorClass,
                 this::addDiscoveredInterceptorClass);
     }
 
@@ -545,7 +550,7 @@ private void addSyntheticBeanTypes(Set<Class<?>> discoveredTypes) {
 
     private void addSyntheticInterceptorClasses(Set<Class<?>> discoveredTypes) {
         filterAndHandleBeanTypes(discoveredTypes,
-                InterceptorUtils::isInterceptorClass,
+                interceptorManager::isInterceptorClass,
                 this::addSyntheticInterceptorClass);
     }
 
@@ -814,7 +819,7 @@ private BeanArchiveType resolveBeanArchiveType(Beans beans) {
      */
     public boolean isDefiningAnnotationType(Class<?> type, boolean includedInterceptor, boolean includedDecorator) {
 
-        if (includedInterceptor && isInterceptorClass(type)) {
+        if (includedInterceptor && interceptorManager.isInterceptorClass(type)) {
             return true;
         }
         if (includedDecorator && isDecorator(type)) {

projects/stage-1/middleware-frameworks/my-cdi/src/main/java/org/geektimes/enterprise/inject/standard/interceptor/InterceptorBean.java

@@ -17,7 +17,6 @@
 package org.geektimes.enterprise.inject.standard.interceptor;
 
 import org.geektimes.enterprise.inject.standard.AbstractAnnotatedTypeBean;
-import org.geektimes.interceptor.InterceptorBindings;
 import org.geektimes.interceptor.InterceptorInfo;
 import org.geektimes.interceptor.InterceptorManager;
 
@@ -27,6 +26,7 @@
 import java.lang.annotation.Annotation;
 import java.util.Set;
 
+import static java.lang.String.format;
 import static org.geektimes.interceptor.InterceptorManager.getInstance;
 
 /**
@@ -46,6 +46,8 @@ public class InterceptorBean<T> extends AbstractAnnotatedTypeBean<T> implements
 
     private final InterceptorInfo interceptorInfo;
 
+    private final Set<Annotation> interceptorBindings;
+
     private final BeanManager beanManager;
 
     public InterceptorBean(AnnotatedType<T> interceptorType, BeanManager beanManager) {
@@ -55,23 +57,56 @@ public InterceptorBean(AnnotatedType<T> interceptorType, BeanManager beanManager
         this.interceptorManager = getInstance(interceptorClass.getClassLoader());
         this.interceptorManager.registerInterceptorClass(interceptorClass);
         this.interceptorInfo = interceptorManager.getInterceptorInfo(interceptorClass);
+        this.interceptorBindings = resolveInterceptorBindings();
         this.beanManager = beanManager;
     }
 
+    private Set<Annotation> resolveInterceptorBindings() {
+        return interceptorInfo.getInterceptorBindings().getDeclaredAnnotations();
+    }
+
     @Override
     public Set<Annotation> getInterceptorBindings() {
-        // TODO
-        return null;
+        return interceptorBindings;
     }
 
     @Override
     public boolean intercepts(InterceptionType type) {
-        // TODO
+        boolean supported = false;
+        switch (type) {
+            case AROUND_INVOKE:
+                supported = interceptorInfo.hasAroundInvokeMethod();
+                break;
+            case AROUND_TIMEOUT:
+                supported = interceptorInfo.hasAroundTimeoutMethod();
+                break;
+            case AROUND_CONSTRUCT:
+                supported = interceptorInfo.hasAroundConstructMethod();
+                break;
+            case POST_CONSTRUCT:
+                supported = interceptorInfo.hasPostConstructMethod();
+                break;
+            case PRE_DESTROY:
+                supported = interceptorInfo.hasPreDestroyMethod();
+                break;
+            case PRE_PASSIVATE:
+                // TODO
+                break;
+            case POST_ACTIVATE:
+                // TODO
+                break;
+        }
         return false;
     }
 
     @Override
     public Object intercept(InterceptionType type, T instance, InvocationContext ctx) throws Exception {
+        if (!intercepts(type)) {
+            throw new UnsupportedOperationException(format(
+                    "The interceptor[type:%s] does not support the interception type[%s]!",
+                    interceptorClass.getName(),
+                    type.name()));
+        }
         // TODO
         return null;
     }
@@ -101,12 +136,11 @@ protected String getBeanName(Class interceptorClass) {
 
     @Override
     protected void validateAnnotatedElement(Class interceptorClass) {
-        // TODO
+        this.interceptorManager.validateInterceptorClass(interceptorClass);
     }
 
     @Override
     public Annotated getAnnotated() {
-        // TODO
         return interceptorType;
     }
 }

projects/stage-1/middleware-frameworks/my-cdi/src/main/java/org/geektimes/enterprise/inject/util/Beans.java

@@ -18,6 +18,7 @@
 
 import org.geektimes.commons.lang.util.ArrayUtils;
 import org.geektimes.commons.reflect.util.MemberUtils;
+import org.geektimes.interceptor.InterceptorManager;
 
 import javax.decorator.Decorator;
 import javax.enterprise.context.Dependent;
@@ -47,6 +48,7 @@
 import static org.geektimes.commons.reflect.util.TypeUtils.*;
 import static org.geektimes.enterprise.inject.util.Decorators.isDecorator;
 import static org.geektimes.enterprise.inject.util.Qualifiers.findQualifier;
+import static org.geektimes.interceptor.InterceptorManager.getInstance;
 import static org.geektimes.interceptor.util.InterceptorUtils.isInterceptorClass;
 
 /**
@@ -228,7 +230,8 @@ private static boolean hasManagedBeanConstructor(Class<?> beanClass) {
      * @throws DefinitionException if the bean class does not meet above conditions
      */
     public static void validateManagedBeanType(Class<?> managedBeanClass) throws DefinitionException {
-        if (isInterceptorClass(managedBeanClass) && isDecorator(managedBeanClass)) {
+        InterceptorManager interceptorManager = getInstance(managedBeanClass.getClassLoader());
+        if (interceptorManager.isInterceptorClass(managedBeanClass) && isDecorator(managedBeanClass)) {
             throwDefinitionException("The managed bean [class : %s] must not annotate with both %s and %s",
                     managedBeanClass.getName(), Interceptor.class.getName(), Decorator.class.getName());
         }

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

@@ -76,6 +76,7 @@ public DefaultInterceptorManager() {
 
     @Override
     public void registerInterceptorClass(Class<?> interceptorClass) {
+        validateInterceptorClass(interceptorClass);
         interceptorInfoRepository.computeIfAbsent(interceptorClass, InterceptorInfo::new);
     }
 
@@ -174,6 +175,21 @@ public Set<Class<? extends Annotation>> getInterceptorBindingTypes() {
         return unmodifiableSet(interceptorBindingTypes);
     }
 
+    @Override
+    public boolean isInterceptorClass(Class<?> interceptorClass) {
+        if(interceptorInfoRepository.containsKey(interceptorClass)){
+            return true;
+        }
+        return InterceptorUtils.isInterceptorClass(interceptorClass);
+    }
+
+    @Override
+    public void validateInterceptorClass(Class<?> interceptorClass) throws NullPointerException, IllegalStateException {
+        if (!interceptorInfoRepository.containsKey(interceptorClass)) {
+            InterceptorUtils.validateInterceptorClass(interceptorClass);
+        }
+    }
+
     private void registerDefaultInterceptorBindingType() {
         registerInterceptorBindingType(PostConstruct.class);
         registerInterceptorBindingType(PreDestroy.class);

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

@@ -33,6 +33,8 @@
  */
 public class InterceptorBindingInfo {
 
+    private final Annotation declaredAnnotation;
+
     private final Class<? extends Annotation> declaredAnnotationType;
 
     /**
@@ -43,6 +45,7 @@ public class InterceptorBindingInfo {
     private final Map<String, Object> attributes;
 
     public InterceptorBindingInfo(Annotation declaredAnnotation) {
+        this.declaredAnnotation = declaredAnnotation;
         this.declaredAnnotationType = declaredAnnotation.annotationType();
         this.synthetic = !isInterceptorBinding(declaredAnnotationType);
         this.attributes = getAttributesMap(declaredAnnotation, FILTERS);
@@ -73,6 +76,10 @@ public int hashCode() {
         return Objects.hash(declaredAnnotationType, synthetic, attributes);
     }
 
+    public Annotation getDeclaredAnnotation() {
+        return declaredAnnotation;
+    }
+
     /**
      * New instance of {@link InterceptorBindingInfo}
      *

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

@@ -43,7 +43,9 @@
  */
 public class InterceptorBindings implements Iterable<InterceptorBindingInfo> {
 
-    private final Set<InterceptorBindingInfo> interceptorBindings;
+    private final Set<Annotation> declaredAnnotations;
+
+    private final Set<InterceptorBindingInfo> bindingInfoSet;
 
     private final Set<Class<? extends Annotation>> interceptorBindingTypes;
 
@@ -52,12 +54,13 @@ public InterceptorBindings(Collection<Annotation> interceptorBindings) {
     }
 
     public InterceptorBindings(Set<Annotation> interceptorBindings) {
-        this.interceptorBindings = asInterceptorBindings(interceptorBindings);
+        this.declaredAnnotations = interceptorBindings;
+        this.bindingInfoSet = asInterceptorBindings(interceptorBindings);
         this.interceptorBindingTypes = asInterceptorBindingTypes(interceptorBindings);
     }
 
-    public Set<InterceptorBindingInfo> getInterceptorBindings() {
-        return interceptorBindings;
+    public Set<Annotation> getDeclaredAnnotations() {
+        return declaredAnnotations;
     }
 
     public Set<Class<? extends Annotation>> getInterceptorBindingTypes() {
@@ -66,20 +69,20 @@ public Set<Class<? extends Annotation>> getInterceptorBindingTypes() {
 
     @Override
     public Iterator<InterceptorBindingInfo> iterator() {
-        return interceptorBindings.iterator();
+        return bindingInfoSet.iterator();
     }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         InterceptorBindings that = (InterceptorBindings) o;
-        return Objects.equals(interceptorBindings, that.interceptorBindings);
+        return Objects.equals(bindingInfoSet, that.bindingInfoSet);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(interceptorBindings);
+        return Objects.hash(bindingInfoSet);
     }
 
     private Set<InterceptorBindingInfo> asInterceptorBindings(Collection<Annotation> interceptorBindings) {

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

@@ -30,10 +30,9 @@
 import java.util.function.Predicate;
 
 import static java.lang.String.format;
-import static java.util.Collections.unmodifiableCollection;
 import static org.geektimes.commons.lang.util.AnnotationUtils.getAllDeclaredAnnotations;
 import static org.geektimes.commons.reflect.util.ClassUtils.getAllClasses;
-import static org.geektimes.interceptor.util.InterceptorUtils.validatorInterceptorClass;
+import static org.geektimes.interceptor.util.InterceptorUtils.validateInterceptorClass;
 
 /**
  * Interceptor Info Metadata class
@@ -66,7 +65,6 @@ public class InterceptorInfo {
     private final InterceptorBindings interceptorBindings;
 
     public InterceptorInfo(Class<?> interceptorClass) {
-        validatorInterceptorClass(interceptorClass);
         this.interceptorManager = InterceptorManager.getInstance(interceptorClass.getClassLoader());
         this.interceptorClass = interceptorClass;
         this.aroundInvokeMethods = new LinkedList<>();
@@ -127,10 +125,6 @@ private InterceptorBindings resolveInterceptorBindings() {
         return new InterceptorBindings(getAllDeclaredAnnotations(interceptorClass, interceptorManager::isInterceptorBinding));
     }
 
-    public Class<?> getInterceptorClass() {
-        return interceptorClass;
-    }
-
     Collection<Method> getAroundInvokeMethods() {
         return aroundInvokeMethods;
     }
@@ -151,6 +145,31 @@ Collection<Method> getPreDestroyMethods() {
         return preDestroyMethods;
     }
 
+    public Class<?> getInterceptorClass() {
+        return interceptorClass;
+    }
+
+    public boolean hasAroundInvokeMethod() {
+        return !getAroundInvokeMethods().isEmpty();
+    }
+
+    public boolean hasAroundTimeoutMethod(){
+        return !getAroundTimeoutMethods().isEmpty();
+    }
+
+    public boolean hasAroundConstructMethod(){
+        return !getAroundConstructMethods().isEmpty();
+    }
+
+    public boolean hasPostConstructMethod(){
+        return !getPostConstructMethods().isEmpty();
+    }
+
+    public boolean hasPreDestroyMethod(){
+        return !getPreDestroyMethods().isEmpty();
+    }
+
+
     public InterceptorBindings getInterceptorBindings() {
         return interceptorBindings;
     }

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

@@ -177,14 +177,9 @@ default List<Object> resolveInterceptors(Constructor<?> constructor, Object... d
     /**
      * The given interceptor class is {@link javax.interceptor.Interceptor @Interceptor} or not.
      *
-     * @param interceptorClass the class of interceptor
-     * @throws NullPointerException  If <code>interceptorClass</code> is <code>null</code>
-     * @throws IllegalStateException If an interceptor class does not annotate @Interceptor or
-     *                               is abstract or have not a public no-arg constructor
+     * @param interceptorClass the class of interceptor is abstract or have not a public no-arg constructor
      */
-    default boolean isInterceptorClass(Class<?> interceptorClass) throws NullPointerException, IllegalStateException {
-        return InterceptorUtils.isInterceptorClass(interceptorClass);
-    }
+    boolean isInterceptorClass(Class<?> interceptorClass);
 
     /**
      * An interceptor class must not be abstract and must have a public no-arg constructor.
@@ -194,9 +189,7 @@ default boolean isInterceptorClass(Class<?> interceptorClass) throws NullPointer
      * @throws IllegalStateException If an interceptor class does not annotate @Interceptor or
      *                               is abstract or have not a public no-arg constructor
      */
-    default void validatorInterceptorClass(Class<?> interceptorClass) throws NullPointerException, IllegalStateException {
-        InterceptorUtils.validatorInterceptorClass(interceptorClass);
-    }
+    void validateInterceptorClass(Class<?> interceptorClass) throws NullPointerException, IllegalStateException;
 
     default boolean isInterceptorBinding(Annotation annotation) {
         return isInterceptorBindingType(annotation.annotationType());