Polish code

Author: mercyblitz

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

@@ -111,12 +111,13 @@ public Object intercept(InterceptionType type, T instance, InvocationContext ctx
     @Override
     public T create(CreationalContext<T> creationalContext) {
         // TODO
-        return null;
+        return super.create(creationalContext);
     }
 
     @Override
     public void destroy(T instance, CreationalContext<T> creationalContext) {
         // TODO
+        super.destroy(instance,creationalContext);
     }
 
     @Override

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

@@ -117,12 +117,20 @@ public class StandardBeanManager implements BeanManager, Instance<Object> {
 
     private final Map<String, AnnotatedType<?>> syntheticTypes;
 
+
     private final List<ManagedBean<?>> managedBeans;
 
     private final List<Interceptor<?>> interceptorBeans;
 
     private final List<Decorator<?>> decoratorBeans;
 
+    private final List<Bean<?>> genericBeans;
+
+
+    private Set<Throwable> definitionErrors;
+
+    private Set<Throwable> deploymentProblems;
+
     public StandardBeanManager() {
         this.classLoader = ClassLoaderUtils.getClassLoader(getClass());
 
@@ -142,6 +150,10 @@ public StandardBeanManager() {
         this.managedBeans = new LinkedList<>();
         this.interceptorBeans = new LinkedList<>();
         this.decoratorBeans = new LinkedList<>();
+        this.genericBeans = new LinkedList<>();
+
+        this.definitionErrors = new LinkedHashSet<>();
+        this.deploymentProblems = new LinkedHashSet<>();
     }
 
     @Override
@@ -474,6 +486,19 @@ public void initialize() {
         // TODO
     }
 
+    public void addDefinitionError(Throwable t) {
+        this.definitionErrors.add(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);
+    }
+
     private void initializeBeanArchiveManager() {
         beanArchiveManager.setClassLoader(classLoader);
         beanArchiveManager.enableScanImplicit(isScanImplicitEnabled());
@@ -548,11 +573,6 @@ private void performBeanDiscovery() {
         determineAlternativeBeans();
         determineInterceptorBeans();
         determineDecoratorBeans();
-
-        // register the instances of enabled Beans, Interceptors and Decorator
-        registerBeans();
-        registerInterceptorBeans();
-        registerDecoratorBeans();
     }
 
     private void determineManagedBeans() {
@@ -687,12 +707,24 @@ private void determineInterceptorBean(AnnotatedType<?> interceptorType) {
         fireProcessBeanAttributesEvent(interceptorType, interceptorBean);
         if (!interceptorBean.isVetoed()) {
             fireProcessBeanEvent(interceptorType, interceptorBean);
-            registerInterceptorBean(interceptorType, interceptorBean);
+            registerInterceptorClass(interceptorType);
+            registerInterceptorBean(interceptorBean);
         }
     }
 
-    private void registerInterceptorBean(AnnotatedType<?> interceptorType, Interceptor<?> interceptorBean) {
-        registerInterceptorClass(interceptorType);
+    public void registerBean(Bean<?> bean) {
+        if (bean instanceof Interceptor) {
+            registerInterceptorBean((Interceptor) bean);
+        } else if (bean instanceof Decorator) {
+            registerDecoratorBean((Decorator) bean);
+        } else if (bean instanceof ManagedBean){
+            registerManagedBean((ManagedBean) bean);
+        } else {
+            genericBeans.add(bean);
+        }
+    }
+
+    private void registerInterceptorBean(Interceptor<?> interceptorBean) {
         this.interceptorBeans.add(interceptorBean);
     }
 
@@ -708,15 +740,15 @@ private void determineDecoratorBeans() {
     }
 
     private void determineDecoratorBean(AnnotatedType<?> decoratorType) {
-        DecoratorBean<?> decoratorBean = new DecoratorBean(decoratorType,this);
+        DecoratorBean<?> decoratorBean = new DecoratorBean(decoratorType, this);
         fireProcessBeanAttributesEvent(decoratorType, decoratorBean);
         if (!decoratorBean.isVetoed()) { // vetoed if ProcessBeanAttributes.veto() method was invoked
             fireProcessBeanEvent(decoratorType, decoratorBean);
             registerDecoratorBean(decoratorBean);
         }
     }
 
-    private void registerDecoratorBean(DecoratorBean<?> decoratorBean) {
+    private void registerDecoratorBean(Decorator<?> decoratorBean) {
         this.decoratorBeans.add(decoratorBean);
     }
 
@@ -737,7 +769,7 @@ private void registerDecoratorBeans() {
      * initialization of the application if any observer registers a definition error.
      */
     private void performAfterBeanDiscovery() {
-        // TODO
+        fireAfterBeanDiscoveryEvent();
     }
 
     /**
@@ -754,7 +786,7 @@ private void performDeploymentValidation() {
      * and abort initialization of the application if any observer registers a deployment problem.
      */
     private void performAfterDeploymentValidation() {
-        // TODO
+        fireAfterDeploymentValidationEvent();
     }
 
     private StandardBeanManager discoverExtensions() {
@@ -833,6 +865,24 @@ private void fireProcessProducerEvent(AnnotatedMember annotatedMember, Producer
         fireEvent(new ProcessProducerEvent(annotatedMember, producer, this));
     }
 
+    /**
+     * Fire fire an event when it has fully completed the bean discovery process, validated that there are
+     * no definition errors relating to the discovered beans, and registered Bean and ObserverMethod objects
+     * for the discovered beans.
+     */
+    private void fireAfterBeanDiscoveryEvent() {
+        fireEvent(new AfterBeanDiscoveryEvent(this));
+    }
+
+
+    /**
+     * Fire an event after it has validated that there are no deployment problems and before creating contexts
+     * or processing requests.
+     */
+    private void fireAfterDeploymentValidationEvent() {
+        fireEvent(new AfterDeploymentValidationEvent(this));
+    }
+
     private void fireEvent(Object event) {
         observerMethodsManager.fire(event);
     }
@@ -908,6 +958,10 @@ private void registerObserverMethods(Object beanInstance) {
         observerMethodsManager.registerObserverMethods(beanInstance);
     }
 
+    public void registerObserverMethod(ObserverMethod<?> observerMethod){
+        observerMethodsManager.registerObserverMethod(observerMethod);
+    }
+
     public StandardBeanManager extensions(Extension... extensions) {
         iterate(extensions, this::addExtension);
         return this;
@@ -959,10 +1013,6 @@ public BeanArchiveManager getBeanArchiveManager() {
         return beanArchiveManager;
     }
 
-    public void addBeanDiscoveryDefinitionError(Throwable t) {
-        // TODO
-    }
-
     public Boolean getScanImplicitProperty() {
         Boolean value = (Boolean) properties.get(SCAN_IMPLICIT_PROPERTY_NAME);
         if (value == null) {
@@ -1003,4 +1053,5 @@ private Set<AnnotatedType<?>> createAnnotatedTypes(Iterable<Class<?>> classes) {
         }
         return annotatedTypes;
     }
+
 }

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

@@ -0,0 +1,86 @@
+/*
+ * 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.event;
+
+import org.geektimes.enterprise.inject.standard.beans.manager.StandardBeanManager;
+
+import javax.enterprise.context.spi.Context;
+import javax.enterprise.inject.spi.AfterBeanDiscovery;
+import javax.enterprise.inject.spi.AnnotatedType;
+import javax.enterprise.inject.spi.Bean;
+import javax.enterprise.inject.spi.ObserverMethod;
+import javax.enterprise.inject.spi.configurator.BeanConfigurator;
+import javax.enterprise.inject.spi.configurator.ObserverMethodConfigurator;
+
+/**
+ * An event was raised when it has fully completed the bean discovery process, validated that there are
+ * no definition errors relating to the discovered beans, and registered Bean and ObserverMethod
+ * objects for the discovered beans.
+ *
+ * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
+ * @since 1.0.0
+ */
+public class AfterBeanDiscoveryEvent implements AfterBeanDiscovery {
+
+    private final StandardBeanManager standardBeanManager;
+
+    public AfterBeanDiscoveryEvent(StandardBeanManager standardBeanManager) {
+        this.standardBeanManager = standardBeanManager;
+    }
+
+    @Override
+    public void addDefinitionError(Throwable t) {
+
+    }
+
+    @Override
+    public void addBean(Bean<?> bean) {
+        standardBeanManager.registerBean(bean);
+    }
+
+    @Override
+    public <T> BeanConfigurator<T> addBean() {
+        // TODO
+        return null;
+    }
+
+    @Override
+    public void addObserverMethod(ObserverMethod<?> observerMethod) {
+        standardBeanManager.registerObserverMethod(observerMethod);
+    }
+
+    @Override
+    public <T> ObserverMethodConfigurator<T> addObserverMethod() {
+        // TODO
+        return null;
+    }
+
+    @Override
+    public void addContext(Context context) {
+
+    }
+
+    @Override
+    public <T> AnnotatedType<T> getAnnotatedType(Class<T> type, String id) {
+        return null;
+    }
+
+    @Override
+    public <T> Iterable<AnnotatedType<T>> getAnnotatedTypes(Class<T> type) {
+        return null;
+    }
+}

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

@@ -0,0 +1,42 @@
+/*
+ * 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.event;
+
+import org.geektimes.enterprise.inject.standard.beans.manager.StandardBeanManager;
+
+import javax.enterprise.inject.spi.AfterDeploymentValidation;
+
+/**
+ * an event is raised after it has validated that there are no deployment problems and before creating
+ * contexts or processing requests.
+ *
+ * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
+ * @since 1.0.0
+ */
+public class AfterDeploymentValidationEvent implements AfterDeploymentValidation {
+
+    private final StandardBeanManager standardBeanManager;
+
+    public AfterDeploymentValidationEvent(StandardBeanManager standardBeanManager) {
+        this.standardBeanManager = standardBeanManager;
+    }
+
+    @Override
+    public void addDeploymentProblem(Throwable t) {
+        standardBeanManager.addDeploymentProblem(t);
+    }
+}

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

@@ -73,12 +73,12 @@ public void registerObserverMethods(Object beanInstance) {
                 .forEach(this::registerObserverMethod);
     }
 
-    public void registerObserverMethods(Bean bean) {
+    public void registerObserverMethods(Bean<?> bean) {
         observerMethodDiscoverer.getObserverMethods(bean, bean.getBeanClass())
                 .forEach(this::registerObserverMethod);
     }
 
-    public void registerObserverMethod(ObserverMethod observerMethod) {
+    public void registerObserverMethod(ObserverMethod<?> observerMethod) {
         Type observerType = observerMethod.getObservedType();
         Set<Type> eventTypes = getAllTypes(observerType);
         fireProcessInjectionPointEvents(observerMethod);
@@ -90,7 +90,7 @@ public void registerObserverMethod(ObserverMethod observerMethod) {
         });
     }
 
-    private void fireProcessInjectionPointEvents(ObserverMethod observerMethod) {
+    private void fireProcessInjectionPointEvents(ObserverMethod<?> observerMethod) {
         List<InjectionPoint> injectionPoints = createInjectionPoints(observerMethod);
         injectionPoints.forEach(this::fireProcessInjectionPointEvent);
     }
@@ -103,7 +103,7 @@ public void fireProcessInjectionPointEvent(ProcessInjectionPoint processInjectio
         fire(processInjectionPoint);
     }
 
-    private void fireProcessObserverMethodEvent(ObserverMethod observerMethod) {
+    private void fireProcessObserverMethodEvent(ObserverMethod<?> observerMethod) {
         fire(new ProcessObserverMethodEvent(observerMethod, standardBeanManager));
     }
 
@@ -164,7 +164,7 @@ protected void fire(Object event, boolean async) {
                 });
     }
 
-    private InjectionPoint createObservedInjectionPoint(ObserverMethod observerMethod) {
+    private InjectionPoint createObservedInjectionPoint(ObserverMethod<?> observerMethod) {
         if (observerMethod instanceof ReflectiveObserverMethod) {
             ReflectiveObserverMethod reflectiveObserverMethod = (ReflectiveObserverMethod) observerMethod;
             ObserverMethodParameter observedParameter = reflectiveObserverMethod.getObservedParameter();
@@ -173,7 +173,7 @@ private InjectionPoint createObservedInjectionPoint(ObserverMethod observerMetho
         return null;
     }
 
-    private List<InjectionPoint> createInjectionPoints(ObserverMethod observerMethod) {
+    private List<InjectionPoint> createInjectionPoints(ObserverMethod<?> observerMethod) {
         List<InjectionPoint> injectionPoints = new LinkedList<>();
         if (observerMethod instanceof ReflectiveObserverMethod) {
             ReflectiveObserverMethod method = (ReflectiveObserverMethod) observerMethod;
@@ -185,7 +185,7 @@ private List<InjectionPoint> createInjectionPoints(ObserverMethod observerMethod
         return injectionPoints;
     }
 
-    private InjectionPoint createInjectionPoint(ObserverMethodParameter observedParameter, ReflectiveObserverMethod observerMethod) {
+    private InjectionPoint createInjectionPoint(ObserverMethodParameter observedParameter, ReflectiveObserverMethod<?> observerMethod) {
         Parameter parameter = observedParameter.getParameter();
         int index = observedParameter.getIndex();
         AnnotatedMethod method = new ReflectiveAnnotatedMethod(observerMethod.getMethod());

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

@@ -99,7 +99,7 @@ public BeanAttributesConfigurator<T> configureBeanAttributes() {
 
     @Override
     public void addDefinitionError(Throwable t) {
-        standardBeanManager.addBeanDiscoveryDefinitionError(t);
+        standardBeanManager.addDefinitionError(t);
     }
 
     @Override