Polish code

Author: mercyblitz

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

@@ -51,7 +51,6 @@
 import static java.util.Collections.*;
 import static java.util.Objects.requireNonNull;
 import static org.geektimes.commons.collection.util.CollectionUtils.newLinkedHashSet;
-import static org.geektimes.commons.collection.util.CollectionUtils.asSet;
 import static org.geektimes.commons.lang.util.StringUtils.endsWith;
 import static org.geektimes.commons.lang.util.StringUtils.isBlank;
 import static org.geektimes.enterprise.inject.standard.beans.BeanArchiveType.EXPLICIT;
@@ -80,25 +79,18 @@ public class BeanArchiveManager {
 
     private final SimpleClassScanner classScanner;
 
-    // Discovered types
+    private final Map<BeanTypeSource, List<Class<?>>> beanClasses;
 
-    private final Set<Class<?>> beanClasses;
+    private final Map<BeanTypeSource, List<Class<?>>> interceptorClasses;
 
-    private final List<Class<?>> interceptorClasses;
+    private final Map<BeanTypeSource, List<Class<?>>> decoratorClasses;
 
-    private final List<Class<?>> decoratorClasses;
-
-    private final List<Class<?>> alternativeClasses;
+    private final Map<BeanTypeSource, List<Class<?>>> alternativeClasses;
 
     private final Set<Class<? extends Annotation>> alternativeStereotypeClasses;
 
     // Synthetic meta-data
 
-    /**
-     * Synthetic Bean classes from {@link SeContainerInitializer#addBeanClasses(Class[])}
-     */
-    private final Set<Class<?>> syntheticBeanClasses;
-
     /**
      * Synthetic package names from {@link SeContainerInitializer#addPackages(boolean, Package...)}
      * <p>
@@ -147,13 +139,14 @@ public BeanArchiveManager(ClassLoader classLoader) {
         this.classLoader = classLoader;
         this.beansReader = ServiceLoaders.loadSpi(BeansReader.class, classLoader);
         this.classScanner = SimpleClassScanner.INSTANCE;
-        this.beanClasses = new LinkedHashSet<>();
-        this.interceptorClasses = new LinkedList<>();
-        this.decoratorClasses = new LinkedList<>();
-        this.alternativeClasses = new LinkedList<>();
+
+        this.beanClasses = new LinkedHashMap<>();
+        this.interceptorClasses = new LinkedHashMap<>();
+        this.decoratorClasses = new LinkedHashMap<>();
+        this.alternativeClasses = new LinkedHashMap<>();
+
         this.alternativeStereotypeClasses = new LinkedHashSet<>();
 
-        this.syntheticBeanClasses = new LinkedHashSet<>();
         this.syntheticPackagesToScan = new TreeMap<>();
         this.syntheticQualifiers = new LinkedHashSet<>();
         this.syntheticStereotypes = new LinkedHashMap<>();
@@ -165,21 +158,18 @@ public BeanArchiveManager(ClassLoader classLoader) {
         this.scanImplicitEnabled = false;
     }
 
-    public BeanArchiveManager addSyntheticPackage(Package packageToScan, boolean scanRecursively) {
+    public void addSyntheticPackage(Package packageToScan, boolean scanRecursively) {
         requireNonNull(packageToScan, "The 'packageToScan' argument must not be null!");
-        return addSyntheticPackage(packageToScan.getName(), scanRecursively);
+        addSyntheticPackage(packageToScan.getName(), scanRecursively);
     }
 
-    public BeanArchiveManager addSyntheticPackage(String packageToScan, boolean scanRecursively) {
+    public void addSyntheticPackage(String packageToScan, boolean scanRecursively) {
         requireNonNull(packageToScan, "The 'packageToScan' argument must not be null!");
         this.syntheticPackagesToScan.put(packageToScan, scanRecursively);
-        return this;
     }
 
-    public BeanArchiveManager addSyntheticBeanClass(Class<?> beanClass) {
-        requireNonNull(beanClass, "The 'beanClass' argument must not be null!");
-        this.syntheticBeanClasses.add(beanClass);
-        return this;
+    public void addSyntheticBeanClass(Class<?> beanClass) {
+        addBeanType(beanClass, BeanTypeSource.SYNTHETIC, beanClasses);
     }
 
     public BeanArchiveManager addSyntheticQualifier(Class<? extends Annotation> qualifier) {
@@ -221,6 +211,24 @@ private void discoverBeanClasses(Set<Class<?>> discoveredTypes) {
                 this::addBeanClass);
     }
 
+
+    private void addEnabledBeanClass(Class<?> beanClass) {
+        addBeanType(beanClass, BeanTypeSource.ENABLED, beanClasses);
+    }
+
+    private void addDiscoveredBeanClass(Class<?> beanClass) {
+        addBeanType(beanClass, BeanTypeSource.DISCOVERED, beanClasses);
+    }
+
+    private static void addBeanType(Class<?> beanType, BeanTypeSource beanTypeSource,
+                                    Map<BeanTypeSource, List<Class<?>>> beanTypesRepository) {
+        requireNonNull(beanType, "The 'class' argument must not be null!");
+        List<Class<?>> beanTypes = beanTypesRepository.computeIfAbsent(beanTypeSource, source -> new LinkedList<>());
+        if (!beanTypes.contains(beanType)) {
+            beanTypes.add(beanType);
+        }
+    }
+
     /**
      * Add provided bean classes.
      *
@@ -251,7 +259,7 @@ public BeanArchiveManager addAlternativeClass(Class<?> alternativeClass) {
      *
      * @param interceptors
      */
-    private void addInterceptors(org.geektimes.enterprise.inject.standard.beans.xml.bind.Interceptors interceptors) {
+    private void enableInterceptors(org.geektimes.enterprise.inject.standard.beans.xml.bind.Interceptors interceptors) {
         if (interceptors != null) {
             List<String> classNames = interceptors.getClazz();
             loadAnnotatedClasses(classNames, javax.interceptor.Interceptor.class)
@@ -288,7 +296,7 @@ public BeanArchiveManager addInterceptorClass(Class<?> interceptorClass) throws
      *
      * @param decorators
      */
-    private void addDecorators(org.geektimes.enterprise.inject.standard.beans.xml.bind.Decorators decorators) {
+    private void enableDecorators(org.geektimes.enterprise.inject.standard.beans.xml.bind.Decorators decorators) {
         if (decorators != null) {
             List<String> classNames = decorators.getClazz();
             loadAnnotatedClasses(classNames, javax.decorator.Decorator.class)
@@ -309,7 +317,7 @@ public BeanArchiveManager addDecoratorClass(Class<?> decoratorClass) {
     }
 
 
-    private void addAlternatives(Alternatives alternatives) {
+    private void enableAlternatives(Alternatives alternatives) {
 //        alternatives.getClazzOrStereotype()
 //                .stream()
 //                .map(this::)
@@ -392,14 +400,14 @@ public Set<Annotation> getStereotypeDefinition(Class<? extends Annotation> stere
      */
     public void discoverTypes() {
         if (!discovered) {
-            discoverTypesInBeanArchives();
-            discoverTypesInNonBeanArchivesAsImplicit();
+            discoverTypesInExplicitBeanArchives();
+            discoverTypesInImplicitBeanArchives();
             discoverTypesInSyntheticBeanArchives();
             discovered = true;
         }
     }
 
-    private void discoverTypesInBeanArchives() {
+    private void discoverTypesInExplicitBeanArchives() {
         try {
             Enumeration<URL> beansXMLResources = classLoader.getResources(BEANS_XML_RESOURCE_NAME);
             while (beansXMLResources.hasMoreElements()) {
@@ -434,7 +442,7 @@ private void discoverTypesInBeanArchives() {
      *      <code>"javax.enterprise.inject.scan.implicit"</code> as key and Boolean.TRUE as value.</li>
      * </ul>
      */
-    private void discoverTypesInNonBeanArchivesAsImplicit() {
+    private void discoverTypesInImplicitBeanArchives() {
         if (isScanImplicitEnabled()) {
             Set<String> classPaths = ClassPathUtils.getClassPaths();
             classPaths.stream().map(File::new).forEach(archiveFile -> {
@@ -484,11 +492,11 @@ private void discoverTypesInExplicitBeanArchive(URL beansXMLResource, Beans bean
             // Exclude filters
             excludeFilters(discoveredTypes, beans);
             // Add Interceptor classes
-            addInterceptors(beans.getInterceptors());
+            enableInterceptors(beans.getInterceptors());
             // Add Decorator classes
-            addDecorators(beans.getDecorators());
+            enableDecorators(beans.getDecorators());
             // Add Alternative classes
-            addAlternatives(beans.getAlternatives());
+            enableAlternatives(beans.getAlternatives());
             // Trimmed bean archive
             if (!trimBeanArchive(discoveredTypes, beans)) {
                 // Add bean classes from the remaining discovered types

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

@@ -0,0 +1,43 @@
+/*
+ * 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.enterprise.inject.standard.beans;
+
+/**
+ * The source enumeration for Bean type
+ *
+ * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
+ * @since 1.0.0
+ */
+public enum BeanTypeSource {
+
+    /**
+     * The enabled bean type from explicit bean archives.
+     */
+    ENABLED,
+
+    /**
+     * The discovered bean type from implicit bean archives.
+     */
+    DISCOVERED,
+
+
+    /**
+     * The synthetic bean type outside of bean archives.
+     */
+    SYNTHETIC;
+
+}

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

@@ -25,6 +25,7 @@
 import org.geektimes.enterprise.inject.standard.producer.ProducerMethodBeanAttributes;
 import org.geektimes.enterprise.inject.standard.producer.ProducerMethodFactory;
 import org.geektimes.enterprise.inject.util.Annotations;
+import org.geektimes.interceptor.InterceptorManager;
 
 import javax.el.ELResolver;
 import javax.el.ExpressionFactory;
@@ -56,6 +57,7 @@
 import static org.geektimes.enterprise.inject.util.Injections.validateForbiddenAnnotation;
 import static org.geektimes.enterprise.inject.util.Parameters.isConstructorParameter;
 import static org.geektimes.enterprise.inject.util.Parameters.isMethodParameter;
+import static org.geektimes.interceptor.InterceptorManager.getInstance;
 
 /**
  * Standard {@link BeanManager}
@@ -79,18 +81,22 @@ public class StandardBeanManager implements BeanManager, Instance<Object> {
      */
     public static final String SCAN_IMPLICIT_PROPERTY_NAME = "javax.enterprise.inject.scan.implicit";
 
-    private final Map<String, Object> properties;
+    private ClassLoader classLoader;
 
-    private final Map<Class<? extends Extension>, Extension> extensions;
+    private final Map<String, Object> properties;
 
     private final BeanArchiveManager beanArchiveManager;
 
     private final ObserverMethodManager observerMethodsManager;
 
-    private ClassLoader classLoader;
+    private final InterceptorManager interceptorManager;
+
+    private final Map<Class<? extends Extension>, Extension> extensions;
 
     private final Map<String, AnnotatedType<?>> beanTypes;
 
+    private final DisposerMethodManager disposerMethodManager;
+
     private final Map<String, AnnotatedType<?>> alternativeTypes;
 
     private final Map<String, AnnotatedType<?>> interceptorTypes;
@@ -101,21 +107,22 @@ public class StandardBeanManager implements BeanManager, Instance<Object> {
 
     private final List<ManagedBean<?>> managedBeans;
 
-    private final DisposerMethodManager disposerMethodManager;
-
     public StandardBeanManager() {
         this.classLoader = ClassLoaderUtils.getClassLoader(getClass());
+
+        this.beanArchiveManager = new BeanArchiveManager(classLoader);
+        this.observerMethodsManager = new ObserverMethodManager(this);
+        this.disposerMethodManager = new DisposerMethodManager(this);
+        this.interceptorManager = getInstance(classLoader);
+
         this.properties = new HashMap<>();
         this.extensions = new LinkedHashMap<>();
-        this.observerMethodsManager = new ObserverMethodManager(this);
-        this.beanArchiveManager = new BeanArchiveManager(classLoader);
         this.beanTypes = new LinkedHashMap<>();
         this.alternativeTypes = new LinkedHashMap<>();
         this.interceptorTypes = new LinkedHashMap<>();
         this.decoratorTypes = new LinkedHashMap<>();
         this.syntheticTypes = new LinkedHashMap<>();
         this.managedBeans = new LinkedList<>();
-        this.disposerMethodManager = new DisposerMethodManager(this);
     }
 
     @Override
@@ -554,7 +561,7 @@ private void determineManagedBean(AnnotatedType beanType) {
         fireProcessInjectionPointEvents(managedBean);
         fireProcessInjectionTarget(beanType, managedBean);
         fireProcessBeanAttributesEvent(beanType, managedBean);
-        if(!managedBean.isVetoed()){ // vetoed if ProcessBeanAttributes.veto() method was invoked
+        if (!managedBean.isVetoed()) { // vetoed if ProcessBeanAttributes.veto() method was invoked
             fireProcessBeanEvent(beanType, managedBean);
             determineProducerMethods(managedBean);
             determineProducerFields(managedBean);
@@ -651,6 +658,12 @@ private void determineInterceptorBeans() {
 
     private void determineInterceptorBean(AnnotatedType<?> interceptorType) {
         // TODO
+        registerInterceptorClass(interceptorType);
+    }
+
+    private void registerInterceptorClass(AnnotatedType<?> interceptorType) {
+        Class<?> interceptorClass = interceptorType.getJavaClass();
+        interceptorManager.registerInterceptorClass(interceptorClass);
     }
 
     private void determineDecoratorBeans() {

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

@@ -46,6 +46,7 @@ public AfterTypeDiscoveryEvent(StandardBeanManager standardBeanManager) {
     @Override
     public List<Class<?>> getAlternatives() {
         getCallerExtension();
+        // FIXME
         return beanArchiveManager.getAlternativeClasses();
     }
 
@@ -60,12 +61,14 @@ public List<Class<?>> getAlternatives() {
     @Override
     public List<Class<?>> getInterceptors() {
         getCallerExtension();
+        // FIXME
         return beanArchiveManager.getInterceptorClasses();
     }
 
     @Override
     public List<Class<?>> getDecorators() {
         getCallerExtension();
+        // FIXME
         return beanArchiveManager.getDecoratorClasses();
     }
 

projects/stage-1/middleware-frameworks/my-commons/src/main/java/org/geektimes/commons/util/PriorityComparator.java

@@ -44,7 +44,7 @@ public class PriorityComparator implements Comparator<Object> {
 
     @Override
     public int compare(Object o1, Object o2) {
-        return compare(o1.getClass(), o2.getClass());
+        return compare(resolveClass(o1), resolveClass(o2));
     }
 
     public static int compare(Class<?> type1, Class<?> type2) {
@@ -61,6 +61,10 @@ public static int compare(Class<?> type1, Class<?> type2) {
         return Integer.compare(priorityValue1, priorityValue2);
     }
 
+    private static Class<?> resolveClass(Object object) {
+        return object instanceof Class ? (Class) object : object.getClass();
+    }
+
     private static int getValue(Priority priority) {
         int value = priority == null ? UNDEFINED_VALUE : priority.value();
         return value < 0 ? UNDEFINED_VALUE : value;

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

@@ -68,7 +68,7 @@ public class DefaultInterceptorManager implements InterceptorManager {
 
     public DefaultInterceptorManager() {
         this.interceptorBindingTypes = new LinkedHashSet<>();
-        this.interceptorInfoRepository = new LinkedHashMap<>();
+        this.interceptorInfoRepository = new TreeMap<>(PriorityComparator.INSTANCE);
         this.bindingInterceptors = new LinkedHashMap<>();
         this.interceptorsCache = new LinkedHashMap<>();
         registerDefaultInterceptorBindingType();
@@ -164,6 +164,12 @@ public boolean isInterceptorBindingType(Class<? extends Annotation> annotationTy
                 interceptorBindingTypes.contains(annotationType);
     }
 
+    @Override
+    public Set<Class<?>> getInterceptorClasses() {
+        return interceptorInfoRepository.keySet();
+    }
+
+    @Override
     public Set<Class<? extends Annotation>> getInterceptorBindingTypes() {
         return unmodifiableSet(interceptorBindingTypes);
     }