Polish code

Author: mercyblitz

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

@@ -42,6 +42,7 @@
 
 import javax.el.ELResolver;
 import javax.el.ExpressionFactory;
+import javax.enterprise.context.ContextNotActiveException;
 import javax.enterprise.context.spi.Context;
 import javax.enterprise.context.spi.Contextual;
 import javax.enterprise.context.spi.CreationalContext;
@@ -57,8 +58,11 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 import java.util.*;
+import java.util.function.Function;
 
+import static java.lang.String.format;
 import static java.lang.System.getProperty;
+import static java.util.Collections.unmodifiableList;
 import static java.util.Objects.requireNonNull;
 import static java.util.ServiceLoader.load;
 import static org.geektimes.commons.lang.util.ArrayUtils.iterate;
@@ -101,13 +105,14 @@ public class StandardBeanManager implements BeanManager, Instance<Object> {
 
     private final ObserverMethodManager observerMethodsManager;
 
+    private final DisposerMethodManager disposerMethodManager;
+
     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<?>> beanTypes;
 
     private final Map<String, AnnotatedType<?>> alternativeTypes;
 
@@ -127,9 +132,12 @@ public class StandardBeanManager implements BeanManager, Instance<Object> {
     private final List<Bean<?>> genericBeans;
 
 
-    private Set<Throwable> definitionErrors;
+    private final Set<DefinitionException> definitionErrors;
 
-    private Set<Throwable> deploymentProblems;
+    private final Set<DeploymentException> deploymentProblems;
+
+
+    private final Map<Class<? extends Annotation>, Context> contexts;
 
     public StandardBeanManager() {
         this.classLoader = ClassLoaderUtils.getClassLoader(getClass());
@@ -154,10 +162,13 @@ public StandardBeanManager() {
 
         this.definitionErrors = new LinkedHashSet<>();
         this.deploymentProblems = new LinkedHashSet<>();
+
+        this.contexts = new HashMap<>();
     }
 
     @Override
     public Object getReference(Bean<?> bean, Type beanType, CreationalContext<?> ctx) {
+        Class<? extends Annotation> scope = bean.getScope();
         // TODO
         return null;
     }
@@ -333,8 +344,11 @@ public int getInterceptorBindingHashCode(Annotation interceptorBinding) {
 
     @Override
     public Context getContext(Class<? extends Annotation> scopeType) {
-        // TODO
-        return null;
+        Context context =  contexts.get(scopeType);
+        if(!context.isActive()){
+            throw new ContextNotActiveException(format("The context[scope : @%s] is not active!",scopeType.getName()));
+        }
+        return context;
     }
 
     @Override
@@ -487,16 +501,17 @@ public void initialize() {
     }
 
     public void addDefinitionError(Throwable t) {
-        this.definitionErrors.add(t);
+        this.definitionErrors.add(new DefinitionException(t));
     }
 
     /**
      * Registers a deployment problem with the container, causing the container to abort deployment
      * after all observers have been notified.
+     *
      * @param t {@link Throwable}
      */
     public void addDeploymentProblem(Throwable t) {
-        this.deploymentProblems.add(t);
+        this.deploymentProblems.add(new DeploymentException(t));
     }
 
     private void initializeBeanArchiveManager() {
@@ -717,7 +732,7 @@ public void registerBean(Bean<?> bean) {
             registerInterceptorBean((Interceptor) bean);
         } else if (bean instanceof Decorator) {
             registerDecoratorBean((Decorator) bean);
-        } else if (bean instanceof ManagedBean){
+        } else if (bean instanceof ManagedBean) {
             registerManagedBean((ManagedBean) bean);
         } else {
             genericBeans.add(bean);
@@ -958,7 +973,7 @@ private void registerObserverMethods(Object beanInstance) {
         observerMethodsManager.registerObserverMethods(beanInstance);
     }
 
-    public void registerObserverMethod(ObserverMethod<?> observerMethod){
+    public void registerObserverMethod(ObserverMethod<?> observerMethod) {
         observerMethodsManager.registerObserverMethod(observerMethod);
     }
 
@@ -1054,4 +1069,60 @@ private Set<AnnotatedType<?>> createAnnotatedTypes(Iterable<Class<?>> classes) {
         return annotatedTypes;
     }
 
-}
+    public <T> AnnotatedType<T> getAnnotatedType(Class<T> type, String id) {
+        return id == null ? getAnnotatedType(type.getName()) : getAnnotatedType(id);
+    }
+
+    public <T> AnnotatedType<T> getAnnotatedType(String id) {
+        AnnotatedType<T> annotatedType = getAnnotatedType(id, beanTypes::get);
+
+        if (annotatedType == null) {
+            annotatedType = getAnnotatedType(id, alternativeTypes::get);
+        }
+
+        if (annotatedType == null) {
+            annotatedType = getAnnotatedType(id, interceptorTypes::get);
+        }
+
+        if (annotatedType == null) {
+            annotatedType = getAnnotatedType(id, decoratorTypes::get);
+        }
+
+        return annotatedType;
+    }
+
+    private <T> AnnotatedType<T> getAnnotatedType(String id, Function<Object, AnnotatedType<?>> typeMapping) {
+        return (AnnotatedType<T>) typeMapping.apply(id);
+    }
+
+    public <T> Iterable<AnnotatedType<T>> getAnnotatedTypes(Class<T> type) {
+        List<AnnotatedType<T>> annotatedTypes = new LinkedList<>();
+        addAnnotatedType(type, beanTypes, annotatedTypes);
+        addAnnotatedType(type, alternativeTypes, annotatedTypes);
+        addAnnotatedType(type, interceptorTypes, annotatedTypes);
+        addAnnotatedType(type, decoratorTypes, annotatedTypes);
+        return unmodifiableList(annotatedTypes);
+    }
+
+    private <T> void addAnnotatedType(Class<T> type, Map<String, AnnotatedType<?>> types,
+                                      List<AnnotatedType<T>> annotatedTypes) {
+        AnnotatedType<T> annotatedType = getAnnotatedType(type.getName(), types::get);
+        if (annotatedType != null) {
+            annotatedTypes.add(annotatedType);
+        }
+    }
+
+    /**
+     *
+     * @param context {@link Context}
+     * @throws DeploymentException If the scope of specified {@link Context} has been registered
+     */
+    public void addContext(Context context) throws DeploymentException {
+        Class<? extends Annotation> scope = context.getScope();
+        if(contexts.containsKey(scope)){
+            throw new DeploymentException(format("The context[scope : @%s] has been registered!",scope.getName()));
+        }
+        contexts.put(scope,context);
+    }
+
+}

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

@@ -0,0 +1,59 @@
+/*
+ * 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.context;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.context.spi.Context;
+import javax.enterprise.context.spi.Contextual;
+import javax.enterprise.context.spi.CreationalContext;
+import javax.enterprise.inject.spi.BeanManager;
+import java.lang.annotation.Annotation;
+
+/**
+ * The Context for {@link ApplicationScoped}
+ *
+ * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
+ * @since 1.0.0
+ */
+public class ApplicationScopedContext implements Context {
+
+    private final BeanManager beanManager;
+
+    public ApplicationScopedContext(BeanManager beanManager) {
+        this.beanManager = beanManager;
+    }
+
+    @Override
+    public Class<? extends Annotation> getScope() {
+        return ApplicationScoped.class;
+    }
+
+    @Override
+    public <T> T get(Contextual<T> contextual, CreationalContext<T> creationalContext) {
+        return null;
+    }
+
+    @Override
+    public <T> T get(Contextual<T> contextual) {
+        return get(contextual, beanManager.createCreationalContext(contextual));
+    }
+
+    @Override
+    public boolean isActive() {
+        return false;
+    }
+}

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

@@ -44,7 +44,7 @@ public AfterBeanDiscoveryEvent(StandardBeanManager standardBeanManager) {
 
     @Override
     public void addDefinitionError(Throwable t) {
-
+        standardBeanManager.addDefinitionError(t);
     }
 
     @Override
@@ -71,16 +71,16 @@ public <T> ObserverMethodConfigurator<T> addObserverMethod() {
 
     @Override
     public void addContext(Context context) {
-
+        standardBeanManager.addContext(context);
     }
 
     @Override
     public <T> AnnotatedType<T> getAnnotatedType(Class<T> type, String id) {
-        return null;
+        return standardBeanManager.getAnnotatedType(type, id);
     }
 
     @Override
     public <T> Iterable<AnnotatedType<T>> getAnnotatedTypes(Class<T> type) {
-        return null;
+        return standardBeanManager.getAnnotatedTypes(type);
     }
 }