protected <X> void createObserverMethods(AbstractClassBean<X> declaringBean, EnhancedAnnotatedType<? super X> annotatedClass) { for (EnhancedAnnotatedMethod<?, ? super X> method : BeanMethods.getObserverMethods(annotatedClass)) { createObserverMethod(declaringBean, method, false); } for (EnhancedAnnotatedMethod<?, ? super X> method : BeanMethods.getAsyncObserverMethods(annotatedClass)) { createObserverMethod(declaringBean, method, true); } }
protected <X> void createProducerFields(AbstractClassBean<X> declaringBean, EnhancedAnnotatedType<X> annotatedClass) { for (EnhancedAnnotatedField<?, ? super X> field : annotatedClass.getDeclaredEnhancedFields(Produces.class)) { createProducerField(declaringBean, field); } }
protected <X> void createProducerMethods(AbstractClassBean<X> declaringBean, EnhancedAnnotatedType<X> type) { for (EnhancedAnnotatedMethod<?, ? super X> method : BeanMethods.filterMethods(type.getDeclaredEnhancedMethods(Produces.class))) { // create method for now // specialization and PBA processing is handled later createProducerMethod(declaringBean, method); } }
protected AbstractBeanDeployer<E> fireProcessBeanEvents() { for (RIBean<?> bean : getEnvironment().getBeans()) { if (!(bean instanceof NewBean)) { containerLifecycleEvents.fireProcessBean(getManager(), bean); } } return this; }
protected <T> void createDecorator(EnhancedAnnotatedType<T> weldClass) { BeanAttributes<T> attributes = BeanAttributesFactory.forBean(weldClass, getManager()); DecoratorImpl<T> bean = DecoratorImpl.of(attributes, weldClass, manager); getEnvironment().addDecorator(bean); }
protected <T> ManagedBean<T> createManagedBean(EnhancedAnnotatedType<T> weldClass) { BeanAttributes<T> attributes = BeanAttributesFactory.forBean(weldClass, getManager()); ManagedBean<T> bean = ManagedBean.of(attributes, weldClass, manager); getEnvironment().addManagedBean(bean); return bean; }
protected <X, T> void createProducerMethod(AbstractClassBean<X> declaringBean, EnhancedAnnotatedMethod<T, ? super X> annotatedMethod) { BeanAttributes<T> attributes = BeanAttributesFactory.forBean(annotatedMethod, getManager()); DisposalMethod<X, ?> disposalMethod = resolveDisposalMethod(attributes, declaringBean); ProducerMethod<? super X, T> bean = ProducerMethod.of(attributes, annotatedMethod, declaringBean, disposalMethod, manager, services); containerLifecycleEvents.preloadProcessBeanAttributes(bean.getType()); containerLifecycleEvents.preloadProcessBean(ProcessProducerMethod.class, annotatedMethod.getBaseType(), bean.getBeanClass()); containerLifecycleEvents.preloadProcessProducer(bean.getBeanClass(), annotatedMethod.getBaseType()); getEnvironment().addProducerMethod(bean); }
protected <X, T> void createProducerField(AbstractClassBean<X> declaringBean, EnhancedAnnotatedField<T, ? super X> field) { BeanAttributes<T> attributes = BeanAttributesFactory.forBean(field, getManager()); DisposalMethod<X, ?> disposalMethod = resolveDisposalMethod(attributes, declaringBean); ProducerField<X, T> bean; if (EEResourceProducerField.isEEResourceProducerField(manager, field)) { if (field.isStatic()) { bean = StaticEEResourceProducerField.of(attributes, field, declaringBean, disposalMethod, manager, services); } else { bean = EEResourceProducerField.of(attributes, field, declaringBean, disposalMethod, manager, services); } } else { bean = ProducerField.of(attributes, field, declaringBean, disposalMethod, manager, services); } containerLifecycleEvents.preloadProcessBeanAttributes(bean.getType()); containerLifecycleEvents.preloadProcessBean(ProcessProducerField.class, field.getBaseType(), bean.getBeanClass()); containerLifecycleEvents.preloadProcessProducer(bean.getBeanClass(), field.getBaseType()); getEnvironment().addProducerField(bean); }
protected <T> void createNewManagedBean(EnhancedAnnotatedType<T> annotatedClass) { // TODO resolve existing beans first slimAnnotatedTypeStore.put(annotatedClass.slim()); getEnvironment().addManagedBean(NewManagedBean.of(BeanAttributesFactory.forNewManagedBean(annotatedClass, manager), annotatedClass, manager)); }
protected AbstractBeanDeployer<E> deploySpecialized() { // ensure that all decorators are initialized before initializing // the rest of the beans for (DecoratorImpl<?> bean : getEnvironment().getDecorators()) { bean.initialize(getEnvironment()); containerLifecycleEvents.fireProcessBean(getManager(), bean); manager.addDecorator(bean); BootstrapLogger.LOG.foundDecorator(bean); } for (InterceptorImpl<?> bean : getEnvironment().getInterceptors()) { bean.initialize(getEnvironment()); containerLifecycleEvents.fireProcessBean(getManager(), bean); manager.addInterceptor(bean); BootstrapLogger.LOG.foundInterceptor(bean); } return this; }
/** * Creates the sub bean for an class (simple or enterprise) bean * * @param bean The class bean */ protected <T> void createObserversProducersDisposers(AbstractClassBean<T> bean) { if (bean instanceof ManagedBean<?> || bean instanceof SessionBean<?>) { // disposal methods have to go first as we want them to be ready for resolution when initializing producer method/fields createDisposalMethods(bean, bean.getEnhancedAnnotated()); createProducerMethods(bean, bean.getEnhancedAnnotated()); createProducerFields(bean, bean.getEnhancedAnnotated()); if (manager.isBeanEnabled(bean)) { createObserverMethods(bean, bean.getEnhancedAnnotated()); } } }
protected AbstractBeanDeployer<E> deployObserverMethods() { for (ObserverInitializationContext<?, ?> observerInitializer : getEnvironment().getObservers()) { if (Observers.isObserverMethodEnabled(observerInitializer.getObserver(), manager)) { BootstrapLogger.LOG.foundObserverMethod(observerInitializer.getObserver()); ObserverMethod<?> processedObserver = containerLifecycleEvents.fireProcessObserverMethod(manager, observerInitializer.getObserver()); if (processedObserver != null) { manager.addObserver(processedObserver); } } } return this; }
protected <X> void createDisposalMethods(AbstractClassBean<X> declaringBean, EnhancedAnnotatedType<X> annotatedClass) { for (EnhancedAnnotatedMethod<?, ? super X> method : BeanMethods.filterMethods(annotatedClass .getDeclaredEnhancedMethodsWithAnnotatedParameters(Disposes.class))) { DisposalMethod<? super X, ?> disposalBean = DisposalMethod.of(manager, method, declaringBean); getEnvironment().addDisposesMethod(disposalBean); } }
protected <T, X> void createObserverMethod(AbstractClassBean<X> declaringBean, EnhancedAnnotatedMethod<T, ? super X> method) { ObserverMethodImpl<T, X> observer = ObserverFactory.create(method, declaringBean, manager); ObserverInitializationContext<T, ? super X> observerInitializer = ObserverInitializationContext.of(observer, method); containerLifecycleEvents.preloadProcessObserverMethod(observer.getObservedType(), declaringBean.getBeanClass()); getEnvironment().addObserverMethod(observerInitializer); }
protected AbstractBeanDeployer<E> initializeObserverMethods() { for (ObserverInitializationContext<?, ?> observerInitializer : getEnvironment().getObservers()) { if (Observers.isObserverMethodEnabled(observerInitializer.getObserver(), manager)) { observerInitializer.initialize(); } } return this; }
protected <T> void createInterceptor(EnhancedAnnotatedType<T> weldClass) { BeanAttributes<T> attributes = BeanAttributesFactory.forBean(weldClass, getManager()); InterceptorImpl<T> bean = InterceptorImpl.of(attributes, weldClass, manager); getEnvironment().addInterceptor(bean); }
protected <T> void createNewSessionBean(InternalEjbDescriptor<T> ejbDescriptor, BeanAttributes<?> originalAttributes, EnhancedAnnotatedType<?> type) { slimAnnotatedTypeStore.put(type.slim()); BeanAttributes<T> attributes = Reflections.cast(BeanAttributesFactory.forNewSessionBean(originalAttributes, type.getJavaClass())); getEnvironment().addSessionBean(NewSessionBean.of(attributes, ejbDescriptor, manager)); }
protected <T> SessionBean<T> createSessionBean(InternalEjbDescriptor<T> descriptor) { EnhancedAnnotatedType<T> type = classTransformer.getEnhancedAnnotatedType(descriptor.getBeanClass(), getManager().getId()); slimAnnotatedTypeStore.put(type.slim()); return createSessionBean(descriptor, type); } protected <T> SessionBean<T> createSessionBean(InternalEjbDescriptor<T> descriptor, EnhancedAnnotatedType<T> weldClass) {
protected AbstractBeanDeployer<E> deployBeans() { manager.addBeans(getEnvironment().getBeans()); return this; }
protected void processInjectionTargetEvents(Iterable<? extends AbstractBean<?, ?>> beans) { if (!containerLifecycleEvents.isProcessInjectionTargetObserved()) { return; } for (AbstractBean<?, ?> bean : beans) { if (!(bean instanceof NewBean) && bean instanceof AbstractClassBean<?>) { containerLifecycleEvents.fireProcessInjectionTarget(getManager(), (AbstractClassBean<?>) bean); } } }