private static void doReloadAbstractClassBean(BeanManagerImpl beanManager, AbstractClassBean<?> bean, Map<String, String> oldSignatures, BeanReloadStrategy reloadStrategy) { String signatureByStrategy = WeldClassSignatureHelper.getSignatureByStrategy(reloadStrategy, bean.getBeanClass()); String oldSignature = oldSignatures.get(bean.getBeanClass().getName()); if (bean instanceof ManagedBean && ( reloadStrategy == BeanReloadStrategy.CLASS_CHANGE || (reloadStrategy != BeanReloadStrategy.NEVER && signatureByStrategy != null && !signatureByStrategy.equals(oldSignature))) ) { // Reload bean in contexts - invalidates existing instances doReloadBeanInBeanContexts(beanManager, (ManagedBean<?>) bean); } else { // Reinjects bean instances in aproperiate contexts doReinjectBean(beanManager, bean); } }
@SuppressWarnings("unchecked") private static void doCallInject(BeanManagerImpl beanManager, AbstractClassBean bean, Object instance) { // In whatever reason, we have to use reflection call for beanManager.createCreationalContext() in weld>=3.0 Method m = null; try { m = beanManager.getClass().getMethod("createCreationalContext", Contextual.class); } catch (Exception e) { LOGGER.error("BeanManager.createCreationalContext() method not found beanManagerClass='{}'", e, bean.getBeanClass().getName()); return; } try { bean.getProducer().inject(instance, (CreationalContext) m.invoke(beanManager, bean)); LOGGER.debug("Bean instance '{}' injection points was reinjected.", instance); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { LOGGER.error("beanManager.createCreationalContext(beanManager, bean) invocation failed beanManagerClass='{}', beanClass='{}'", e, bean.getBeanClass().getName(), bean.getClass().getName()); } }
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; } } }
@Override // Overridden to provide the class of the bean that declares the producer // method/field public Class<?> getBeanClass() { return getDeclaringBean().getBeanClass(); }
@Override // Overridden to provide the class of the bean that declares the producer // method/field public Class<?> getBeanClass() { return getDeclaringBean().getBeanClass(); }
@Override public Iterable<AbstractClassBean<?>> transform(AbstractClassBean<?> bean, BeanDeployerEnvironment environment) { return environment.getClassBeans(bean.getBeanClass().getSuperclass()); } };
@Override // Overridden to provide the class of the bean that declares the producer // method/field public Class<?> getBeanClass() { return getDeclaringBean().getBeanClass(); }
protected void addAbstractClassBean(AbstractClassBean<?> bean) { if (!(bean instanceof NewBean)) { classBeanMap.get(bean.getBeanClass()).add(bean); } addAbstractBean(bean); }
protected void addAbstractClassBean(AbstractClassBean<?> bean) { if (!(bean instanceof NewBean)) { classBeanMap.get(bean.getBeanClass()).add(bean); } addAbstractBean(bean); }
protected void addAbstractClassBean(AbstractClassBean<?> bean) { if (!(bean instanceof NewBean)) { classBeanMap.get(bean.getBeanClass()).add(bean); } addAbstractBean(bean); }
protected void addAbstractClassBean(AbstractClassBean<?> bean) { if (!(bean instanceof NewBean)) { classBeanMap.put(bean.getBeanClass(), bean); } addAbstractBean(bean); }
protected <T, X> void createObserverMethod(AbstractClassBean<X> declaringBean, EnhancedAnnotatedMethod<T, ? super X> method, boolean isAsync) { ObserverMethodImpl<T, X> observer = ObserverFactory.create(method, declaringBean, manager, isAsync); ObserverInitializationContext<T, ? super X> observerInitializer = ObserverInitializationContext.of(observer, method); containerLifecycleEvents.preloadProcessObserverMethod(observer.getObservedType(), declaringBean.getBeanClass()); getEnvironment().addObserverMethod(observerInitializer); }
protected ResourceInjection<T> getResourceInjection(EnhancedAnnotatedField<T, ? super X> field, AbstractClassBean<X> declaringBean, BeanManagerImpl manager) { FieldInjectionPoint<T, X> injectionPoint = cast(InjectionPointFactory.silentInstance().createFieldInjectionPoint(field, declaringBean, declaringBean.getBeanClass(), manager)); return manager.getServices().get(ResourceInjectionFactory.class).getStaticProducerFieldResourceInjection(injectionPoint, beanManager); }
protected ResourceInjection<T> getResourceInjection(EnhancedAnnotatedField<T, ? super X> field, AbstractClassBean<X> declaringBean, BeanManagerImpl manager) { FieldInjectionPoint<T, X> injectionPoint = cast(InjectionPointFactory.silentInstance().createFieldInjectionPoint(field, declaringBean, declaringBean.getBeanClass(), manager)); return manager.getServices().get(ResourceInjectionFactory.class).getStaticProducerFieldResourceInjection(injectionPoint, beanManager); }
protected ResourceInjection<T> getResourceInjection(EnhancedAnnotatedField<T, ? super X> field, AbstractClassBean<X> declaringBean, BeanManagerImpl manager) { FieldInjectionPoint<T, X> injectionPoint = cast(InjectionPointFactory.silentInstance().createFieldInjectionPoint(field, declaringBean, declaringBean.getBeanClass(), manager)); return manager.getServices().get(ResourceInjectionFactory.class).getStaticProducerFieldResourceInjection(injectionPoint, beanManager); }
protected DisposalMethod(BeanManagerImpl beanManager, EnhancedAnnotatedMethod<T, ? super X> enhancedAnnotatedMethod, AbstractClassBean<X> declaringBean) { this.disposalMethodInjectionPoint = InjectionPointFactory.instance().createMethodInjectionPoint(MethodInjectionPointType.DISPOSER, enhancedAnnotatedMethod, declaringBean, declaringBean.getBeanClass(), SPECIAL_PARAM_MARKERS, beanManager); this.beanManager = beanManager; this.declaringBean = declaringBean; EnhancedAnnotatedParameter<?, ? super X> enhancedDisposesParameter = getEnhancedDisposesParameter(enhancedAnnotatedMethod); this.disposesParameter = enhancedDisposesParameter.slim(); this.requiredQualifiers = getRequiredQualifiers(enhancedDisposesParameter); checkDisposalMethod(enhancedAnnotatedMethod, declaringBean); this.invocationStrategy = MethodInvocationStrategy.forDisposer(disposalMethodInjectionPoint, beanManager); }
protected DisposalMethod(BeanManagerImpl beanManager, EnhancedAnnotatedMethod<T, ? super X> enhancedAnnotatedMethod, AbstractClassBean<X> declaringBean) { this.disposalMethodInjectionPoint = InjectionPointFactory.instance().createMethodInjectionPoint(MethodInjectionPointType.DISPOSER, enhancedAnnotatedMethod, declaringBean, declaringBean.getBeanClass(), Disposes.class, beanManager); this.beanManager = beanManager; this.declaringBean = declaringBean; EnhancedAnnotatedParameter<?, ? super X> enhancedDisposesParameter = getEnhancedDisposesParameter(enhancedAnnotatedMethod); this.disposesParameter = enhancedDisposesParameter.slim(); this.requiredQualifiers = getRequiredQualifiers(enhancedDisposesParameter); checkDisposalMethod(enhancedAnnotatedMethod, declaringBean); this.invocationStrategy = MethodInvocationStrategy.forDisposer(disposalMethodInjectionPoint, beanManager); }
protected DisposalMethod(BeanManagerImpl beanManager, EnhancedAnnotatedMethod<T, ? super X> enhancedAnnotatedMethod, AbstractClassBean<X> declaringBean) { this.disposalMethodInjectionPoint = InjectionPointFactory.instance().createMethodInjectionPoint(MethodInjectionPointType.DISPOSER, enhancedAnnotatedMethod, declaringBean, declaringBean.getBeanClass(), SPECIAL_PARAM_MARKERS, beanManager); this.beanManager = beanManager; this.declaringBean = declaringBean; EnhancedAnnotatedParameter<?, ? super X> enhancedDisposesParameter = getEnhancedDisposesParameter(enhancedAnnotatedMethod); this.disposesParameter = enhancedDisposesParameter.slim(); this.requiredQualifiers = getRequiredQualifiers(enhancedDisposesParameter); checkDisposalMethod(enhancedAnnotatedMethod, declaringBean); this.invocationStrategy = MethodInvocationStrategy.forDisposer(disposalMethodInjectionPoint, beanManager); }
protected DisposalMethod(BeanManagerImpl beanManager, EnhancedAnnotatedMethod<T, ? super X> enhancedAnnotatedMethod, AbstractClassBean<X> declaringBean) { this.disposalMethodInjectionPoint = InjectionPointFactory.instance().createMethodInjectionPoint(MethodInjectionPointType.DISPOSER, enhancedAnnotatedMethod, declaringBean, declaringBean.getBeanClass(), SPECIAL_PARAM_MARKERS, beanManager); this.beanManager = beanManager; this.declaringBean = declaringBean; EnhancedAnnotatedParameter<?, ? super X> enhancedDisposesParameter = getEnhancedDisposesParameter(enhancedAnnotatedMethod); this.disposesParameter = enhancedDisposesParameter.slim(); this.requiredQualifiers = getRequiredQualifiers(enhancedDisposesParameter); checkDisposalMethod(enhancedAnnotatedMethod, declaringBean); this.invocationStrategy = MethodInvocationStrategy.forDisposer(disposalMethodInjectionPoint, beanManager); }
protected DisposalMethod(BeanManagerImpl beanManager, EnhancedAnnotatedMethod<T, ? super X> enhancedAnnotatedMethod, AbstractClassBean<X> declaringBean) { this.disposalMethodInjectionPoint = InjectionPointFactory.instance().createMethodInjectionPoint(MethodInjectionPointType.DISPOSER, enhancedAnnotatedMethod, declaringBean, declaringBean.getBeanClass(), SPECIAL_PARAM_MARKERS, beanManager); this.beanManager = beanManager; this.declaringBean = declaringBean; EnhancedAnnotatedParameter<?, ? super X> enhancedDisposesParameter = getEnhancedDisposesParameter(enhancedAnnotatedMethod); this.disposesParameter = enhancedDisposesParameter.slim(); this.requiredQualifiers = getRequiredQualifiers(enhancedDisposesParameter); checkDisposalMethod(enhancedAnnotatedMethod, declaringBean); this.invocationStrategy = MethodInvocationStrategy.forDisposer(disposalMethodInjectionPoint, beanManager); }