@Override public String toString() { return "Weld instance for deployment " + BeanManagerProxy.unwrap(rootBeanManager).getContextId(); }
WeldInjectionContext createInjectionContext() { return new WeldInjectionContext(beanManager.createCreationalContext(bean), bean, delegateProduce, injectionTarget, interceptorInjections); }
private void addInterceptorInstance(Interceptor<Object> interceptor, BeanManagerImpl beanManager, Map<String, SerializableContextualInstance<Interceptor<Object>, Object>> instances, final CreationalContext<Object> creationalContext) { Object instance = beanManager.getReference(interceptor, interceptor.getBeanClass(), creationalContext, true); SerializableContextualInstance<Interceptor<Object>, Object> serializableContextualInstance = beanManager.getServices().get(ContextualStore.class).<Interceptor<Object>, Object>getSerializableContextualInstance(interceptor, instance, creationalContext); instances.put(interceptor.getBeanClass().getName(), serializableContextualInstance); }
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()); final String bdaId = beanManager.getId() + classLoader.hashCode(); type = transformer.getEnhancedAnnotatedType(clazz, bdaId); return beanManager.getInjectionTargetFactory(type).createNonProducibleInjectionTarget(); WeldInjectionTargetBuilder<T> builder = beanManager.createInjectionTargetBuilder(type); builder.setBean(bean); builder.setResourceInjectionEnabled(false); // because these are all EE components where resource injection is not handled by Weld if (interceptionSupport) { return builder.build(); } else { return builder.setInterceptionEnabled(false).setTargetClassLifecycleCallbacksEnabled(false).setDecorationEnabled(false).build();
AnnotatedType<?> type = beanManager.createAnnotatedType(interceptor); @SuppressWarnings("rawtypes") InjectionTarget injectionTarget = beanManager.getInjectionTargetFactory(type).createInterceptorInjectionTarget(); interceptorInjections.put(interceptor, beanManager.fireProcessInjectionTarget(type, injectionTarget)); EjbDescriptor<Object> descriptor = beanManager.getEjbDescriptor(ejbName); bean = beanManager.getBean(descriptor); beanManager.getServices().get(InjectionTargetService.class).validateProducer(injectionTarget);
@Override public ContextHandle createContextHandle() { final BeanManagerImpl beanManager = getBeanManager(); return () -> { if (beanManager == null || beanManager.isContextActive(RequestScoped.class)) { return () -> { }; } final RequestContext requestContext = beanManager.instance().select(RequestContext.class, UnboundLiteral.INSTANCE).get(); requestContext.activate(); return () -> { requestContext.invalidate(); requestContext.deactivate(); }; }; }
private InterceptorBindings getInterceptorBindings(final String ejbName, final BeanManagerImpl manager) { InterceptorBindings retVal = null; if (ejbName != null) { retVal = interceptorSupport.getInterceptorBindings(ejbName, manager); } else { // This is a managed bean SlimAnnotatedType<?> type = (SlimAnnotatedType<?>) manager.createAnnotatedType(componentClass); if (!manager.getInterceptorModelRegistry().containsKey(type)) { EnhancedAnnotatedType<?> enhancedType = manager.getServices().get(ClassTransformer.class).getEnhancedAnnotatedType(type); InterceptionModelInitializer.of(manager, enhancedType, null).init(); } InterceptionModel model = manager.getInterceptorModelRegistry().get(type); if (model != null) { retVal = new InterceptorBindingsAdapter(manager.getInterceptorModelRegistry().get(type)); } } return retVal != null ? retVal : NullInterceptorBindings.INSTANCE; }
interceptionModel = beanManager.getInterceptorModelRegistry().get(getType()); decorators = beanManager.resolveDecorators(getBean().getTypes(), getBean().getQualifiers()); getBeanManager().getContextId(), getInstantiator(), getBean(), decorators));
bm = ((WeldManager) bm).unwrap(); Set<Bean<?>> beans = beanManager.getBeans(beanClass, new AnnotationLiteral<Any>() {}); EnhancedAnnotatedType eat = createAnnotatedTypeForExistingBeanClass(bdaId, bean); if (!eat.isAbstract() || !eat.getJavaClass().isInterface()) { // injectionTargetCannotBeCreatedForInterface ((AbstractClassBean)bean).setProducer(beanManager.getLocalInjectionTargetFactory(eat).createInjectionTarget(eat, bean, false)); if (isReinjectingContext(bean)) { doReloadAbstractClassBean(beanManager, (AbstractClassBean) bean, oldSignatures, reloadStrategy);
EjbDescriptor<Object> descriptor = beanManager.getEjbDescriptor(this.ejbName); if (descriptor != null) { bean = beanManager.getBean(descriptor); CreationalContext<Object> creationalContext = beanManager.createCreationalContext(bean); HashMap<String, SerializableContextualInstance<Interceptor<Object>, Object>> interceptorInstances = new HashMap<String, SerializableContextualInstance<Interceptor<Object>, Object>>();
private void checkNoArgsConstructor(EnhancedAnnotatedType<T> type) { if (!beanManager.getServices().get(ProxyInstantiator.class).isUsingConstructor()) { return; } EnhancedAnnotatedConstructor<T> constructor = type.getNoArgsEnhancedConstructor(); if (constructor == null) { throw BeanLogger.LOG.decoratedHasNoNoargsConstructor(this); } else if (constructor.isPrivate()) { throw BeanLogger.LOG .decoratedNoargsConstructorIsPrivate(this, Formats.formatAsStackTraceElement(constructor.getJavaMember())); } }
@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); } }
private InjectionTarget getInjectionTarget(Class<?> clazz) { InjectionTarget<?> target = injectionTargets.get(clazz); if (target != null) { return target; } final BeanManagerImpl beanManager = BeanManagerProxy.unwrap(beanManagerSupplier.get()); Bean<?> bean = null; Set<Bean<?>> beans = new HashSet<>(beanManager.getBeans(clazz, Any.Literal.INSTANCE)); Iterator<Bean<?>> it = beans.iterator(); //we may have resolved some sub-classes //go through and remove them from the bean set while (it.hasNext()) { Bean<?> b = it.next(); if(b.getBeanClass() != clazz) { it.remove(); } } if(beans.size() == 1) { bean = beans.iterator().next(); } InjectionTarget<?> newTarget = InjectionTargets.createInjectionTarget(clazz, bean, beanManager, true); target = injectionTargets.putIfAbsent(clazz, newTarget); if (target == null) { return newTarget; } else { return target; } }
private static void doReinjectBean(BeanManagerImpl beanManager, AbstractClassBean<?> bean) { try { if (!bean.getScope().equals(ApplicationScoped.class) && HaCdiCommons.isRegisteredScope(bean.getScope())) { doReinjectRegisteredBeanInstances(beanManager, bean); } else { doReinjectBeanInstance(beanManager, bean, beanManager.getContext(bean.getScope())); } } catch (Exception e) { if (e.getClass().getSimpleName().equals("ContextNotActiveException")) { LOGGER.info("No active contexts for bean '{}'", bean.getBeanClass().getName()); } else { throw e; } } }
private void initializeInterceptionModel(EnhancedAnnotatedType<T> annotatedType) { AbstractInstantiator<T> instantiator = (AbstractInstantiator<T>) getInstantiator(); if (instantiator.getConstructorInjectionPoint() == null) { return; // this is a non-producible InjectionTarget (only created to inject existing instances) } if (isInterceptionCandidate() && !beanManager.getInterceptorModelRegistry().containsKey(getType())) { buildInterceptionModel(annotatedType, instantiator); } }
beanManager = ((BeanManagerImpl) CDI.current().getBeanManager()).unwrap(); } else { beanManager = ((BeanManagerProxy) CDI.current().getBeanManager()).unwrap();
private void checkDecoratedMethods(EnhancedAnnotatedType<T> type, List<Decorator<?>> decorators) { if (type.isFinal()) { throw BeanLogger.LOG.finalBeanClassWithDecoratorsNotAllowed(this); } checkNoArgsConstructor(type); for (Decorator<?> decorator : decorators) { EnhancedAnnotatedType<?> decoratorClass; if (decorator instanceof DecoratorImpl<?>) { DecoratorImpl<?> decoratorBean = (DecoratorImpl<?>) decorator; decoratorClass = decoratorBean.getBeanManager().getServices().get(ClassTransformer.class) .getEnhancedAnnotatedType(decoratorBean.getAnnotated()); } else if (decorator instanceof CustomDecoratorWrapper<?>) { decoratorClass = ((CustomDecoratorWrapper<?>) decorator).getEnhancedAnnotated(); } else { throw BeanLogger.LOG.nonContainerDecorator(decorator); } for (EnhancedAnnotatedMethod<?, ?> decoratorMethod : decoratorClass.getEnhancedMethods()) { EnhancedAnnotatedMethod<?, ?> method = type.getEnhancedMethod(decoratorMethod.getSignature()); if (method != null && !method.isStatic() && !method.isPrivate() && method.isFinal()) { throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(this); } } } }
/** * Creates a new Jersey-specific {@link javax.enterprise.inject.spi.Bean} instance. * * @param binding {@link javax.enterprise.inject.spi.BeanAttributes} part of the bean. */ @SuppressWarnings("unchecked") SupplierThreadScopeBean(SupplierInstanceBinding binding, BeanManagerImpl manager) { super(binding); this.binding = binding; this.beanInstance = new ThreadScopeBeanInstance<>(binding.getSupplier(), this, manager.getContextId()); this.proxy = createClientProxy(beanInstance, manager.getContextId()); }
/** * Will re-inject any managed beans in the target. Will not call any other life-cycle methods * * @param ctx * @param managedBean */ public static void reinitialize(Context ctx, Contextual<Object> contextual) { try { ManagedBean<Object> managedBean = ManagedBean.class.cast(contextual); LOGGER.debug("Re-Initializing........ {},: {}", managedBean, ctx); Object get = ctx.get(managedBean); if (get != null) { LOGGER.debug("Bean injection points are reinitialized '{}'", managedBean); managedBean.getProducer().inject(get, managedBean.getBeanManager().createCreationalContext(managedBean)); } } catch (Exception e) { LOGGER.error("Error reinitializing bean {},: {}", e, contextual, ctx); } } }
InjectionTargetService injectionTargetService = it.getBeanManager().getServices().get(InjectionTargetService.class); injectionTargetService.addInjectionTargetToBeInitialized(jit.getEnhancedAnnotatedType(), jit); return jit;