Polish code

Author: mercyblitz

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

@@ -24,6 +24,7 @@
 import javax.enterprise.context.spi.CreationalContext;
 import javax.enterprise.inject.CreationException;
 import javax.enterprise.inject.spi.*;
+import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
 import java.util.LinkedList;
 import java.util.List;

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

@@ -16,20 +16,20 @@
  */
 package org.geektimes.enterprise.inject.standard.beans;
 
-import org.geektimes.enterprise.inject.standard.ConstructorParameterInjectionPoint;
 import org.geektimes.enterprise.inject.standard.annotation.ReflectiveAnnotatedType;
 import org.geektimes.enterprise.inject.standard.beans.producer.ProducerFieldBean;
 import org.geektimes.enterprise.inject.standard.beans.producer.ProducerMethodBean;
 import org.geektimes.enterprise.inject.util.Beans;
 
+import javax.enterprise.context.NormalScope;
 import javax.enterprise.context.spi.CreationalContext;
-import javax.enterprise.inject.CreationException;
-import javax.enterprise.inject.spi.*;
-import java.lang.reflect.Constructor;
+import javax.enterprise.inject.spi.Annotated;
+import javax.enterprise.inject.spi.AnnotatedType;
+import javax.enterprise.inject.spi.Bean;
+import javax.enterprise.inject.spi.BeanManager;
+import java.lang.annotation.Annotation;
 import java.lang.reflect.Type;
 import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
 import static java.util.Collections.unmodifiableSet;
@@ -61,6 +61,12 @@ protected ManagedBean(Class<?> beanClass, BeanManager beanManager) {
         this(new ReflectiveAnnotatedType<>(beanClass), beanManager);
     }
 
+    @Override
+    public Class<? extends Annotation> getScope() {
+        Class<? extends Annotation> scope = super.getScope();
+        return scope == null ? NormalScope.class : scope;
+    }
+
     @Override
     protected void validate(Class<T> beanClass) {
         validateManagedBeanType(beanClass);
@@ -93,15 +99,13 @@ public void destroy(T instance, CreationalContext<T> creationalContext) {
     public Set<ProducerMethodBean> getProducerMethodBeans() {
         if (producerMethodBeans == null) {
             producerMethodBeans = resolveProducerMethodBeans(this);
-
         }
         return producerMethodBeans;
     }
 
     public Set<ProducerFieldBean> getProducerFieldBeans() {
         if (producerFieldBeans == null) {
             producerFieldBeans = resolveProducerFieldBeans(this);
-
         }
         return producerFieldBeans;
     }

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

@@ -18,6 +18,7 @@
 
 import org.geektimes.enterprise.inject.standard.beans.ManagedBean;
 
+import javax.enterprise.context.Dependent;
 import javax.enterprise.context.spi.CreationalContext;
 import javax.enterprise.inject.spi.AnnotatedType;
 import javax.enterprise.inject.spi.Bean;
@@ -27,6 +28,8 @@
 import java.lang.reflect.Type;
 import java.util.Set;
 
+import static org.geektimes.enterprise.inject.util.Exceptions.newDefinitionException;
+
 /**
  * {@link Decorator} {@link Bean}
  * <p>
@@ -50,12 +53,21 @@
  */
 public class DecoratorBean<T> extends ManagedBean<T> implements Decorator<T> {
 
-
-
     public DecoratorBean(AnnotatedType<T> decoratorType, BeanManager beanManager) {
         super(decoratorType, beanManager);
     }
 
+    @Override
+    public Class<? extends Annotation> getScope() {
+        Class<? extends Annotation> scope = super.getScope();
+        if (scope == null) {
+            scope = Dependent.class;
+        } else if (scope != null && !Dependent.class.equals(scope)) {
+            throw newDefinitionException("The scope of decorator must be declared as @%s!", Dependent.class.getName());
+        }
+        return scope;
+    }
+
     @Override
     public Type getDelegateType() {
         return null;

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

@@ -20,13 +20,15 @@
 import org.geektimes.interceptor.InterceptorInfo;
 import org.geektimes.interceptor.InterceptorManager;
 
+import javax.enterprise.context.Dependent;
 import javax.enterprise.context.spi.CreationalContext;
 import javax.enterprise.inject.spi.*;
 import javax.interceptor.InvocationContext;
 import java.lang.annotation.Annotation;
 import java.util.Set;
 
 import static java.lang.String.format;
+import static org.geektimes.enterprise.inject.util.Exceptions.newDefinitionException;
 import static org.geektimes.interceptor.InterceptorManager.getInstance;
 
 /**
@@ -62,6 +64,17 @@ private Set<Annotation> resolveInterceptorBindings() {
         return interceptorInfo.getInterceptorBindings().getDeclaredAnnotations();
     }
 
+    @Override
+    public Class<? extends Annotation> getScope() {
+        Class<? extends Annotation> scope = super.getScope();
+        if (scope == null) {
+            scope = Dependent.class;
+        } else if (scope != null && !Dependent.class.equals(scope)) {
+            throw newDefinitionException("The scope of interceptor must be declared as @%s!", Dependent.class.getName());
+        }
+        return scope;
+    }
+
     @Override
     public Set<Annotation> getInterceptorBindings() {
         return interceptorBindings;

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

@@ -687,10 +687,10 @@ private void performAfterTypeDiscovery() {
      * the container must perform bean discovery, as defined in Bean discovery.
      */
     private void performBeanDiscovery() {
-        determineManagedBeans();
         determineAlternativeBeans();
         determineInterceptorBeans();
         determineDecoratorBeans();
+        determineManagedBeans();
     }
 
     private void determineManagedBeans() {
@@ -731,7 +731,7 @@ private void determineManagedBean(AnnotatedType beanType) {
             determineProducerFields(managedBean);
             determineDisposerMethods(managedBean);
             determineObserverMethods(managedBean);
-            registerManagedBean(managedBean);
+            registerBean(managedBean);
         }
     }
 
@@ -826,7 +826,7 @@ private void determineInterceptorBean(AnnotatedType<?> interceptorType) {
         if (!interceptorBean.isVetoed()) {
             fireProcessBeanEvent(interceptorType, interceptorBean);
             registerInterceptorClass(interceptorType);
-            registerInterceptorBean(interceptorBean);
+            registerBean(interceptorBean);
         }
     }
 
@@ -840,6 +840,7 @@ public void registerBean(Bean<?> bean) {
         } else {
             genericBeans.add(bean);
         }
+        contextManager.addBean(bean);
     }
 
     private void registerInterceptorBean(Interceptor<?> interceptorBean) {
@@ -862,7 +863,7 @@ private void determineDecoratorBean(AnnotatedType<?> decoratorType) {
         fireProcessBeanAttributesEvent(decoratorType, decoratorBean);
         if (!decoratorBean.isVetoed()) { // vetoed if ProcessBeanAttributes.veto() method was invoked
             fireProcessBeanEvent(decoratorType, decoratorBean);
-            registerDecoratorBean(decoratorBean);
+            registerBean(decoratorBean);
         }
     }
 

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

@@ -19,11 +19,14 @@
 import javax.enterprise.context.spi.Context;
 import javax.enterprise.context.spi.Contextual;
 import javax.enterprise.context.spi.CreationalContext;
-import javax.enterprise.inject.spi.AnnotatedType;
+import javax.enterprise.inject.spi.Bean;
 import javax.enterprise.inject.spi.BeanManager;
 import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.LinkedList;
+import java.util.List;
 
-import static org.geektimes.enterprise.inject.util.Contexts.getBeanClass;
+import static org.geektimes.enterprise.inject.util.Contexts.getBeanType;
 
 /**
  * Abstract implementation {@link Context}
@@ -37,11 +40,14 @@ public abstract class AbstractContext implements Context {
 
     protected final Class<? extends Annotation> scope;
 
+    protected final List<Bean<?>> beans;
+
     protected boolean active;
 
     public AbstractContext(BeanManager beanManager, Class<? extends Annotation> scope) {
         this.beanManager = beanManager;
         this.scope = scope;
+        this.beans = new LinkedList<>();
         active();
     }
 
@@ -54,23 +60,49 @@ public final Class<? extends Annotation> getScope() {
         return scope;
     }
 
+    /**
+     * @param contextual
+     * @param creationalContext
+     * @param <T>
+     * @return <ul>
+     * <li>return an existing instance of the given contextual type, or</li>
+     * <li>if no CreationalContext is given, return a null value, or</li>
+     * <li>if a CreationalContext is given, create a new instance of the given contextual type by calling
+     * Contextual.create(), passing the given CreationalContext, and return the new instance.</li>
+     * </ul>
+     */
     @Override
     public <T> T get(Contextual<T> contextual, CreationalContext<T> creationalContext) {
-        Class<T> beanClass = getBeanClass(contextual);
-        CreationalContext<T> context = creationalContext;
-        if (context == null) {
-            context = beanManager.createCreationalContext(contextual);
+        T instance = getInstance(contextual);
+        if (instance == null) {
+            if (creationalContext != null) {
+                instance = contextual.create(creationalContext);
+            }
         }
-        AnnotatedType<T> beanType = beanManager.createAnnotatedType(beanClass);
-        return get(contextual, context, beanType);
+        return instance;
+//        Class<T> beanClass = getBeanClass(contextual);
+//        Type requiredBeanType = getBeanType(contextual);
+//        CreationalContext<T> context = creationalContext;
+//        if (context == null) {
+//            context = beanManager.createCreationalContext(contextual);
+//        }
+//        AnnotatedType<T> beanType = beanManager.createAnnotatedType(beanClass);
+//        return get(contextual, context, beanType);
+    }
+
+    private <T> T getInstance(Contextual<T> contextual) {
+        Type requiredBeanType = getBeanType(contextual);
+        return getInstance(contextual, requiredBeanType);
     }
 
-    protected abstract <T> T get(Contextual<T> contextual, CreationalContext<T> creationalContext,
-                                 AnnotatedType<T> beanType);
+    protected <T> T getInstance(Contextual<T> contextual, Type requiredBeanType) {
+        // TODO
+        return null;
+    }
 
     @Override
     public <T> T get(Contextual<T> contextual) {
-        return get(contextual, null);
+        return get(contextual, beanManager.createCreationalContext(contextual));
     }
 
     public final void inactive() {
@@ -85,4 +117,8 @@ public final void active() {
     public final boolean isActive() {
         return active;
     }
+
+    public void addBean(Bean<?> bean) {
+        this.beans.add(bean);
+    }
 }

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

@@ -21,6 +21,7 @@
 import javax.enterprise.context.spi.CreationalContext;
 import javax.enterprise.inject.spi.AnnotatedType;
 import javax.enterprise.inject.spi.BeanManager;
+import java.lang.reflect.Type;
 
 /**
  * The Context for {@link ApplicationScoped}
@@ -33,10 +34,4 @@ public class ApplicationScopedContext extends AbstractAlterableContext {
     public ApplicationScopedContext(BeanManager beanManager) {
         super(beanManager, ApplicationScoped.class);
     }
-
-    @Override
-    protected <T> T get(Contextual<T> contextual, CreationalContext<T> creationalContext,
-                        AnnotatedType<T> beanType) {
-        return null;
-    }
 }

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

@@ -19,9 +19,8 @@
 import javax.enterprise.context.Dependent;
 import javax.enterprise.context.spi.AlterableContext;
 import javax.enterprise.context.spi.Contextual;
-import javax.enterprise.context.spi.CreationalContext;
-import javax.enterprise.inject.spi.AnnotatedType;
 import javax.enterprise.inject.spi.BeanManager;
+import java.lang.reflect.Type;
 
 /**
  * The Context for {@link Dependent @Dependent}
@@ -39,10 +38,4 @@ public class DependentScopeContext extends AbstractAlterableContext {
     public DependentScopeContext(BeanManager beanManager) {
         super(beanManager, Dependent.class);
     }
-
-    @Override
-    protected <T> T get(Contextual<T> contextual, CreationalContext<T> creationalContext,
-                        AnnotatedType<T> beanType) {
-        return null;
-    }
 }

projects/stage-1/middleware-frameworks/my-cdi/src/main/java/org/geektimes/enterprise/inject/standard/context/mananger/ContextManager.java

@@ -16,10 +16,12 @@
  */
 package org.geektimes.enterprise.inject.standard.context.mananger;
 
+import org.geektimes.enterprise.inject.standard.context.AbstractContext;
 import org.geektimes.enterprise.inject.util.Scopes;
 
 import javax.enterprise.context.ContextNotActiveException;
 import javax.enterprise.context.spi.Context;
+import javax.enterprise.inject.spi.Bean;
 import javax.enterprise.inject.spi.BeforeBeanDiscovery;
 import javax.enterprise.inject.spi.DeploymentException;
 import javax.inject.Scope;
@@ -82,6 +84,15 @@ public void addContext(Context context) throws DeploymentException {
         contexts.put(scope, context);
     }
 
+    public void addBean(Bean<?> bean) {
+        Class<? extends Annotation> scope = bean.getScope();
+        Context context = getContext(scope);
+        if(context instanceof AbstractContext){
+            AbstractContext abstractContext = (AbstractContext) context;
+            abstractContext.addBean(bean);
+        }
+    }
+
     public Context getContext(Class<? extends Annotation> scopeType) {
         Context context = contexts.get(scopeType);
         if (!context.isActive()) {

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

@@ -18,8 +18,10 @@
 
 import javax.enterprise.context.spi.Context;
 import javax.enterprise.context.spi.Contextual;
+import java.lang.reflect.Type;
 
 import static org.geektimes.commons.reflect.util.TypeUtils.findActualTypeArgumentClass;
+import static org.geektimes.commons.reflect.util.TypeUtils.findActualTypeArguments;
 
 /**
  * The utilities class for {@link Context}
@@ -34,4 +36,9 @@ public static <T> Class<T> getBeanClass(Contextual<T> contextual) {
         return findActualTypeArgumentClass(contextualClass, Contextual.class, 0);
     }
 
+    public static <T> Type getBeanType(Contextual<T> contextual) {
+        Class<?> contextualClass = contextual.getClass();
+        return findActualTypeArguments(contextualClass, Contextual.class).get(0);
+    }
+
 }

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

@@ -35,11 +35,9 @@ public abstract class Scopes {
 
     public static Class<? extends Annotation> getScopeType(AnnotatedElement annotatedElement) {
         Annotation scope = findAnnotation(annotatedElement, Scopes::isScope);
-        final Class<? extends Annotation> scopeType;
+        Class<? extends Annotation> scopeType = null;
         if (scope != null) {
             scopeType = scope.annotationType();
-        } else {
-            scopeType = NormalScope.class;
         }
         return scopeType;
     }