@SuppressWarnings({ "rawtypes", "unchecked" }) private static void doDefineNewManagedBean(BeanManagerImpl beanManager, String bdaId, Class<?> beanClass) { try { ClassTransformer classTransformer = getClassTransformer(); SlimAnnotatedType<?> annotatedType = classTransformer.getBackedAnnotatedType(beanClass, bdaId); boolean managedBeanOrDecorator = Beans.isTypeManagedBeanOrDecoratorOrInterceptor(annotatedType); if (managedBeanOrDecorator) { EnhancedAnnotatedType eat = EnhancedAnnotatedTypeImpl.of(annotatedType, classTransformer); BeanAttributes attributes = BeanAttributesFactory.forBean(eat, beanManager); ManagedBean<?> bean = ManagedBean.of(attributes, eat, beanManager); ReflectionHelper.set(beanManager, beanManager.getClass(), "beanSet", Collections.synchronizedSet(new HashSet<Bean<?>>())); beanManager.addBean(bean); beanManager.getBeanResolver().clear(); bean.initializeAfterBeanDiscovery(); LOGGER.debug("Bean defined '{}'", beanClass.getName()); } else { // TODO : define session bean LOGGER.warning("Bean NOT? defined '{}', session bean?", beanClass.getName()); } } catch (Exception e) { LOGGER.debug("Bean definition failed.", e); } }
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 <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 <T> void createInterceptor(EnhancedAnnotatedType<T> weldClass) { BeanAttributes<T> attributes = BeanAttributesFactory.forBean(weldClass, getManager()); InterceptorImpl<T> bean = InterceptorImpl.of(attributes, weldClass, manager); getEnvironment().addInterceptor(bean); }
public static <T> BeanAttributes<T> forNewManagedBean(EnhancedAnnotatedType<T> weldClass, BeanManagerImpl manager) { return forNewBean(SharedObjectCache.instance(manager).getSharedSet(Beans.getTypes(weldClass)), weldClass.getJavaClass()); }
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)); }
@Override public <T> BeanAttributes<T> createBeanAttributes(AnnotatedType<T> type) { EnhancedAnnotatedType<T> clazz = services.get(ClassTransformer.class).getEnhancedAnnotatedType(type, getId()); if (services.get(EjbDescriptors.class).contains(type.getJavaClass())) { return BeanAttributesFactory.forSessionBean(clazz, services.get(EjbDescriptors.class).getUnique(clazz.getJavaClass()), this); } return BeanAttributesFactory.forBean(clazz, this); }
protected <T> SessionBean<T> createSessionBean(InternalEjbDescriptor<T> descriptor, EnhancedAnnotatedType<T> weldClass) { // TODO Don't create enterprise bean if it has no local interfaces! BeanAttributes<T> attributes = BeanAttributesFactory.forSessionBean(weldClass, descriptor, getManager()); SessionBean<T> bean = SessionBean.of(attributes, descriptor, manager, weldClass); getEnvironment().addSessionBean(bean); return bean; }
public static <T> BeanAttributes<T> forNewSessionBean(BeanAttributes<T> originalAttributes, Class<?> javaClass) { return forNewBean(originalAttributes.getTypes(), javaClass); }
public void createNewBeans() { for (EnhancedAnnotatedType<?> clazz : getEnvironment().getNewManagedBeanClasses()) { createNewManagedBean(clazz); } for (Entry<InternalEjbDescriptor<?>, EnhancedAnnotatedType<?>> entry : getEnvironment().getNewSessionBeanDescriptorsFromInjectionPoint().entrySet()) { InternalEjbDescriptor<?> descriptor = entry.getKey(); createNewSessionBean(descriptor, BeanAttributesFactory.forSessionBean(entry.getValue(), descriptor, getManager()), entry.getValue()); } }
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(Class<T> clazz, Type type) { EnhancedAnnotatedType<T> enhancedType = classTransformer.getEnhancedAnnotatedType(clazz, type, manager.getId()); slimAnnotatedTypeStore.put(enhancedType.slim()); getEnvironment().addManagedBean(NewManagedBean.of(BeanAttributesFactory.forNewManagedBean(enhancedType, manager), enhancedType, manager)); }
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 <T> void createInterceptor(EnhancedAnnotatedType<T> weldClass) { BeanAttributes<T> attributes = BeanAttributesFactory.forBean(weldClass, getManager()); InterceptorImpl<T> bean = InterceptorImpl.of(attributes, weldClass, manager); getEnvironment().addInterceptor(bean); }
public static <T> BeanAttributes<T> forNewManagedBean(EnhancedAnnotatedType<T> weldClass, BeanManagerImpl manager) { return forNewBean(SharedObjectCache.instance(manager).getSharedSet(Beans.getTypes(weldClass)), weldClass.getJavaClass()); }