final ClassTransformer transformer = beanManager.getServices().get(ClassTransformer.class); @SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>) componentClass; EnhancedAnnotatedType<T> type = transformer.getEnhancedAnnotatedType(clazz, beanManager.getId()); if (!type.getJavaClass().equals(componentClass)) { final String bdaId = beanManager.getId() + classLoader.hashCode(); type = transformer.getEnhancedAnnotatedType(clazz, bdaId); if (Beans.getBeanConstructor(type) == null) {
@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); } }
/** * Gets the annotated item representing the method * * @return The annotated item */ @Override public EnhancedAnnotatedMethod<T, ? super X> getEnhancedAnnotated() { return Beans.checkEnhancedAnnotatedAvailable(enhancedAnnotatedMethod); }
@Override protected boolean matches(Resolvable resolvable, T bean) { AssignabilityRules rules = null; if (resolvable.isDelegate()) { rules = DelegateInjectionPointAssignabilityRules.instance(); } else { rules = BeanTypeAssignabilityRules.instance(); } return rules.matches(resolvable.getTypes(), bean.getTypes()) && Beans.containsAllQualifiers(resolvable.getQualifiers(), QualifierInstance.of(bean, store)); }
this.cache = ComputingCacheBuilder.newBuilder().<Key, Optional<InterceptionFactoryData<?>>> build((key) -> { ClassTransformer classTransformer = beanManager.getServices().get(ClassTransformer.class); UnbackedAnnotatedType<?> slimAnnotatedType = classTransformer.getUnbackedAnnotatedType(key.annotatedType, beanManager.getId(), id); new InterceptionModelInitializer(beanManager, enhancedAnnotatedType, Beans.getBeanConstructor(enhancedAnnotatedType), null).init(); InterceptionModel interceptionModel = beanManager.getInterceptorModelRegistry().get(slimAnnotatedType); && (interceptionModel.hasExternalNonConstructorInterceptors() || interceptionModel.hasTargetClassInterceptors()); Set<MethodSignature> interceptedMethodSignatures = new HashSet<MethodSignature>(); for (AnnotatedMethod<?> method : Beans.getInterceptableMethods(enhancedAnnotatedType)) { enhancedMethodSignatures.add(MethodSignatureImpl.of(method)); if (!interceptionModel.getInterceptors(InterceptionType.AROUND_INVOKE, method.getJavaMember()).isEmpty()) { interceptedMethodSignatures.add(MethodSignatureImpl.of(method)); InterceptedProxyFactory<?> proxyFactory = new InterceptedProxyFactory<>(beanManager.getContextId(), enhancedAnnotatedType.getJavaClass(), Collections.singleton(enhancedAnnotatedType.getJavaClass()), enhancedMethodSignatures, interceptedMethodSignatures, "" + idx);
public DefaultInstantiator(EnhancedAnnotatedType<T> type, Bean<T> bean, BeanManagerImpl manager) { EnhancedAnnotatedConstructor<T> constructor = Beans.getBeanConstructor(type); this.constructor = InjectionPointFactory.instance().createConstructorInjectionPoint(bean, type.getJavaClass(), constructor, manager); }
protected void createClassBean(SlimAnnotatedType<?> annotatedType, SetMultimap<Class<?>, SlimAnnotatedType<?>> otherWeldClasses) { boolean managedBeanOrDecorator = !ejbSupport.isEjb(annotatedType.getJavaClass()) && Beans.isTypeManagedBeanOrDecoratorOrInterceptor(annotatedType); if (managedBeanOrDecorator) { containerLifecycleEvents.preloadProcessInjectionTarget(annotatedType.getJavaClass()); containerLifecycleEvents.preloadProcessBeanAttributes(annotatedType.getJavaClass()); EnhancedAnnotatedType<?> weldClass = classTransformer.getEnhancedAnnotatedType(annotatedType); if (weldClass.isAnnotationPresent(Decorator.class)) { containerLifecycleEvents.preloadProcessBean(ProcessBean.class, annotatedType.getJavaClass()); validateDecorator(weldClass); createDecorator(weldClass); } else if (weldClass.isAnnotationPresent(Interceptor.class)) { containerLifecycleEvents.preloadProcessBean(ProcessBean.class, annotatedType.getJavaClass()); validateInterceptor(weldClass); createInterceptor(weldClass); } else if (!weldClass.isAbstract()) { containerLifecycleEvents.preloadProcessBean(ProcessManagedBean.class, annotatedType.getJavaClass()); createManagedBean(weldClass); } } else { if (Beans.isDecoratorDeclaringInAppropriateConstructor(annotatedType)) { BootstrapLogger.LOG.decoratorWithNonCdiConstructor(annotatedType.getJavaClass().getName()); } Class<? extends Annotation> scopeClass = Beans.getBeanDefiningAnnotationScope(annotatedType); if (scopeClass != null && !Beans.hasSimpleCdiConstructor(annotatedType)) { BootstrapLogger.LOG.annotatedTypeNotRegisteredAsBeanDueToMissingAppropriateConstructor(annotatedType.getJavaClass().getName(), scopeClass.getSimpleName()); } otherWeldClasses.put(annotatedType.getJavaClass(), annotatedType); } }
LifecycleCallbackInvoker<T> invoker, BeanManagerImpl beanManager) { try { if (type.isAbstract()) { if (type.getJavaClass().isInterface()) { throw BeanLogger.LOG.injectionTargetCannotBeCreatedForInterface(type); BeanLogger.LOG.injectionTargetCreatedForAbstractClass(type.getJavaClass()); return NonProducibleInjectionTarget.create(type, bean, injector, invoker, beanManager); if (!Reflections.isTopLevelOrStaticNestedClass(type.getJavaClass())) { BeanLogger.LOG.injectionTargetCreatedForNonStaticInnerClass(type.getJavaClass()); return NonProducibleInjectionTarget.create(type, bean, injector, invoker, beanManager); if (Beans.getBeanConstructor(type) == null) { if (bean != null) { throw BeanLogger.LOG.injectionTargetCreatedForClassWithoutAppropriateConstructorException(type.getJavaClass());
/** * Illegal bean types are ignored except for array and primitive types and unless {@link Typed} is used. * * @return the set of bean types from an annotated element */ public static Set<Type> getTypes(EnhancedAnnotated<?, ?> annotated) { // array and primitive types require special treatment if (annotated.getJavaClass().isArray() || annotated.getJavaClass().isPrimitive()) { return ImmutableSet.<Type>builder().addAll(annotated.getBaseType(), Object.class).build(); } else { if (annotated.isAnnotationPresent(Typed.class)) { return ImmutableSet.<Type>builder().addAll(getTypedTypes(Reflections.buildTypeMap(annotated.getTypeClosure()), annotated.getJavaClass(), annotated.getAnnotation(Typed.class))).build(); } else { if (annotated.getJavaClass().isInterface()) { return getLegalBeanTypes(annotated.getTypeClosure(), annotated, Object.class); } return getLegalBeanTypes(annotated.getTypeClosure(), annotated); } } }
@Override protected void doWork(InternalEjbDescriptor<?> descriptor) { if (!getEnvironment().isVetoed(descriptor.getBeanClass()) && !Beans.isVetoed(descriptor.getBeanClass())) { if (descriptor.isSingleton() || descriptor.isStateful() || descriptor.isStateless()) { if (otherWeldClasses.get(descriptor.getBeanClass()) != null) { for (SlimAnnotatedType<?> annotatedType : otherWeldClasses.get(descriptor.getBeanClass())) { EnhancedAnnotatedType<?> weldClass = classTransformer.getEnhancedAnnotatedType(annotatedType); createSessionBean(descriptor, Reflections.<EnhancedAnnotatedType> cast(weldClass)); } } else { createSessionBean(descriptor); } } } } });
@Override protected boolean matches(InterceptorResolvable resolvable, Interceptor<?> bean) { return bean.intercepts(resolvable.getInterceptionType()) && bean.getInterceptorBindings().size() > 0 && Beans.containsAllInterceptionBindings(bean.getInterceptorBindings(), resolvable.getQualifiers(), getManager()) && manager.getEnabled().isInterceptorEnabled(bean.getBeanClass()); }
@Override protected boolean matches(Resolvable resolvable, Decorator<?> bean) { return rules.matches(Collections.singleton(bean.getDelegateType()), resolvable.getTypes()) && Beans.containsAllQualifiers(QualifierInstance.of(bean.getDelegateQualifiers(), getStore()), resolvable.getQualifiers()) && getBeanManager().getEnabled().isDecoratorEnabled(bean.getBeanClass()); }
public static <T> void injectFieldsAndInitializers(T instance, CreationalContext<T> ctx, BeanManagerImpl beanManager, List<? extends Iterable<? extends FieldInjectionPoint<?, ?>>> injectableFields, List<? extends Iterable<? extends MethodInjectionPoint<?, ?>>> initializerMethods) { if (injectableFields.size() != initializerMethods.size()) { throw UtilLogger.LOG.invalidQuantityInjectableFieldsAndInitializerMethods(injectableFields, initializerMethods); } for (int i = 0; i < injectableFields.size(); i++) { injectBoundFields(instance, ctx, beanManager, injectableFields.get(i)); callInitializers(instance, ctx, beanManager, initializerMethods.get(i)); } }
if (Beans.isDecoratorDeclaringInAppropriateConstructor(classFileInfo)) { BootstrapLogger.LOG.decoratorWithNonCdiConstructor(classFileInfo.getClassName()); if (Beans.isTypeManagedBeanOrDecoratorOrInterceptor(classFileInfo, checkTypeModifiers)) { return createContext(className, classFileInfo, observerMethods, bdaId);
@Override public void createSessionBeans(BeanDeployerEnvironment environment, SetMultimap<Class<?>, SlimAnnotatedType<?>> types, BeanManagerImpl manager) { final ClassTransformer transformer = manager.getServices().get(ClassTransformer.class); for (InternalEjbDescriptor<?> ejbDescriptor : getEjbDescriptors()) { if (environment.isVetoed(ejbDescriptor.getBeanClass()) || Beans.isVetoed(ejbDescriptor.getBeanClass())) { continue; } if (ejbDescriptor.isSingleton() || ejbDescriptor.isStateful() || ejbDescriptor.isStateless()) { Set<SlimAnnotatedType<?>> classes = types.get(ejbDescriptor.getBeanClass()); if (!classes.isEmpty()) { for (SlimAnnotatedType<?> annotatedType : classes) { createSessionBean(ejbDescriptor, annotatedType, environment, manager, transformer); } } else { createSessionBean(ejbDescriptor, environment, manager, transformer); } } } }
protected void addSyntheticAnnotatedType(AnnotatedType<?> type, String id) { AnnotatedTypeValidator.validateAnnotatedType(type); if (type.getJavaClass().isAnnotation() || Beans.isVetoed(type)) { return; } storeSyntheticAnnotatedType(getOrCreateBeanDeployment(type.getJavaClass()), type, id); }
types.addAll(getTypedTypes(typeMap, annotated.getJavaClass(), annotated.getAnnotation(Typed.class))); } else { typeMap.put(Object.class, Object.class); types.addAll(typeMap.values()); return getLegalBeanTypes(types.build(), annotated);
public static String forBuilderBean(BeanAttributes<?> attributes, Class<?> beanClass) { return new StringBuilder(PREFIX_BUILDER).append(beanClass.getName()).append(BEAN_ID_SEPARATOR) .append(Beans.createBeanAttributesId(attributes)).toString(); } }
@Override public BeanAttributesConfigurator<T> addTransitiveTypeClosure(Type type) { checkArgumentNotNull(type); this.types.addAll(Beans.getLegalBeanTypes(new HierarchyDiscovery(type).getTypeClosure(), type)); return this; }
public static <T> EnhancedAnnotatedConstructor<T> getBeanConstructorStrict(EnhancedAnnotatedType<T> type) { EnhancedAnnotatedConstructor<T> constructor = getBeanConstructor(type); if (constructor == null) { throw UtilLogger.LOG.unableToFindConstructor(type); } return constructor; }