use of org.jboss.weld.bean.AbstractProducerBean in project core by weld.
the class JsonObjects method createFullBeanJson.
/**
* @param bean
* @param transientDependencies
* @param transientDependents
* @param probe
* @return the full bean representation
*/
static JsonObjectBuilder createFullBeanJson(Bean<?> bean, boolean transientDependencies, boolean transientDependents, BeanManagerImpl beanManager, Probe probe) {
JsonObjectBuilder beanBuilder = createBasicBeanJson(bean, probe);
// NAME
if (bean.getName() != null) {
beanBuilder.add(NAME, bean.getName());
}
// STEREOTYPES
if (bean.getStereotypes() != null && !bean.getStereotypes().isEmpty()) {
JsonArrayBuilder stereotypesBuilder = Json.arrayBuilder();
for (Class<?> stereotype : Components.getSortedProbeComponetCandidates(bean.getStereotypes())) {
stereotypesBuilder.add(Json.objectBuilder().add(CLASS, stereotype.getName()).add(PROBE_COMPONENT, Components.isProbeComponent(stereotype)));
}
beanBuilder.add(STEREOTYPES, stereotypesBuilder);
}
if (bean instanceof SessionBean) {
// SESSION BEAN
SessionBean<?> sessionBean = (SessionBean<?>) bean;
if (sessionBean.getEjbDescriptor().getEjbName() != null) {
beanBuilder.add(EJB_NAME, true);
}
beanBuilder.add(SESSION_BEAN_TYPE, Components.getSessionBeanType(sessionBean.getEjbDescriptor()).toString());
} else if (bean instanceof AbstractProducerBean) {
// PRODUCERS
AbstractProducerBean<?, ?, ?> producerBean = (AbstractProducerBean<?, ?, ?>) bean;
if (producerBean.getDeclaringBean() != null) {
beanBuilder.add(DECLARING_BEAN, createSimpleBeanJson(producerBean.getDeclaringBean(), probe));
}
if (producerBean.getProducer() instanceof ProducerMethodProducer) {
ProducerMethodProducer<?, ?> producer = (ProducerMethodProducer<?, ?>) producerBean.getProducer();
if (producer.getDisposalMethod() != null) {
beanBuilder.add(DISPOSAL_METHOD, annotatedMethodToString(producer.getDisposalMethod().getAnnotated(), bean.getBeanClass()));
}
beanBuilder.add(PRODUCER_METHOD, annotatedMethodToString((AnnotatedMethod<?>) producer.getAnnotated(), bean.getBeanClass()));
} else if (producerBean.getProducer() instanceof ProducerFieldProducer) {
ProducerFieldProducer<?, ?> producer = (ProducerFieldProducer<?, ?>) producerBean.getProducer();
if (producer.getDisposalMethod() != null) {
beanBuilder.add(DISPOSAL_METHOD, annotatedMethodToString(producer.getDisposalMethod().getAnnotated(), bean.getBeanClass()));
}
beanBuilder.add(PRODUCER_FIELD, annotatedFieldToString(producer.getAnnotated(), bean.getBeanClass()));
}
}
// DEPENDENCIES
JsonArrayBuilder dependencies = createDependencies(null, bean, probe, transientDependencies);
if (dependencies != null) {
beanBuilder.add(DEPENDENCIES, dependencies);
}
// DEPENDENTS
JsonArrayBuilder dependents = createDependents(null, bean, probe, transientDependents);
if (dependents != null) {
beanBuilder.add(DEPENDENTS, dependents);
}
// DECLARED OBSERVERS
JsonArrayBuilder declaredObservers = Json.arrayBuilder();
for (ObserverMethod<?> observerMethod : probe.getObservers()) {
if (observerMethod instanceof ObserverMethodImpl) {
ObserverMethodImpl<?, ?> observerMethodImpl = (ObserverMethodImpl<?, ?>) observerMethod;
if (bean.equals(observerMethodImpl.getDeclaringBean())) {
JsonObjectBuilder observerBuilder = createSimpleObserverJson(observerMethodImpl, probe);
observerBuilder.add(RECEPTION, observerMethodImpl.getReception().toString());
observerBuilder.add(TX_PHASE, observerMethodImpl.getTransactionPhase().toString());
observerBuilder.add(ANNOTATED_METHOD, annotatedMethodToString(observerMethodImpl.getMethod().getAnnotated(), bean.getBeanClass()));
declaredObservers.add(observerBuilder);
}
}
}
beanBuilder.add(DECLARED_OBSERVERS, declaredObservers);
// DECLARED PRODUCERS
beanBuilder.add(DECLARED_PRODUCERS, createDeclaredProducers(bean, probe));
// ENABLEMENT
BeanKind kind = BeanKind.from(bean);
if (BeanKind.INTERCEPTOR.equals(kind) || BeanKind.DECORATOR.equals(kind) || bean.isAlternative()) {
JsonObjectBuilder enablementBuilder = Json.objectBuilder();
AnnotationApiAbstraction annotationApi = beanManager.getServices().get(AnnotationApiAbstraction.class);
Object priority = bean.getBeanClass().getAnnotation(annotationApi.PRIORITY_ANNOTATION_CLASS);
if (priority != null) {
int priorityValue = annotationApi.getPriority(priority);
enablementBuilder.add(PRIORITY, priorityValue);
enablementBuilder.add(PRIORITY_RANGE, Components.PriorityRange.of(priorityValue).toString());
if (!probe.getLocalEnablementOfBean(bean.getBeanClass()).isEmpty()) {
enablementBuilder.add(WARNING, WARNING_CONFLICTING_ENABLEMENT);
JsonArrayBuilder conflictingBdas = Json.arrayBuilder();
for (String bdaId : probe.getLocalEnablementOfBean(bean.getBeanClass())) {
conflictingBdas.add(createSimpleBdaJson(bdaId));
}
enablementBuilder.add(CONFLICTS, conflictingBdas);
}
} else {
JsonArrayBuilder bdasBuilder = Json.arrayBuilder();
Collection<BeanManagerImpl> beanManagers = Container.instance(beanManager).beanDeploymentArchives().values();
for (BeanManagerImpl manager : beanManagers) {
ModuleEnablement enablement = manager.getEnabled();
if ((BeanKind.INTERCEPTOR.equals(kind) && enablement.isInterceptorEnabled(bean.getBeanClass())) || (BeanKind.DECORATOR.equals(kind) && enablement.isDecoratorEnabled(bean.getBeanClass())) || isSelectedAlternative(enablement, bean)) {
bdasBuilder.add(createSimpleBdaJson(manager.getId()));
}
}
enablementBuilder.add(BDAS, bdasBuilder);
}
beanBuilder.add(ENABLEMENT, enablementBuilder);
}
// INTERCEPTOR BINDINGS
if (BeanKind.INTERCEPTOR.equals(kind)) {
Interceptor<?> interceptor = (Interceptor<?>) bean;
JsonArrayBuilder bindings = Json.arrayBuilder(true);
for (Annotation binding : interceptor.getInterceptorBindings()) {
bindings.add(binding.toString());
}
beanBuilder.add(BINDINGS, bindings);
}
// DECORATOR
if (BeanKind.DECORATOR.equals(kind)) {
Decorator<?> decorator = (Decorator<?>) bean;
beanBuilder.add(DELEGATE_TYPE, Formats.formatType(decorator.getDelegateType(), false));
beanBuilder.add(DELEGATE_QUALIFIERS, createQualifiers(decorator.getDelegateQualifiers(), false));
JsonArrayBuilder decoratedTypes = Json.arrayBuilder(true);
for (Type type : decorator.getDecoratedTypes()) {
decoratedTypes.add(Formats.formatType(type, false));
}
beanBuilder.add(DECORATED_TYPES, decoratedTypes);
// ASSOCIATED TO BEANS
Set<Bean<?>> decoratedBeans = findDecoratedBeans(decorator, beanManager, probe);
if (!decoratedBeans.isEmpty()) {
JsonArrayBuilder decoratedBeansBuilder = Json.arrayBuilder();
for (Bean<?> decoratedBean : decoratedBeans) {
decoratedBeansBuilder.add(createSimpleBeanJson(decoratedBean, probe));
}
beanBuilder.add(ASSOCIATED_TO, decoratedBeansBuilder);
}
}
if (bean instanceof AbstractClassBean) {
AbstractClassBean<?> abstractClassBean = (AbstractClassBean<?>) bean;
InterceptionModel interceptionModel = abstractClassBean.getInterceptors();
// CLASS-LEVEL BINDINGS
if (interceptionModel != null) {
Set<Annotation> classInterceptorBindings = interceptionModel.getClassInterceptorBindings();
if (!classInterceptorBindings.isEmpty()) {
JsonArrayBuilder bindingsBuilder = Json.arrayBuilder();
for (Annotation binding : Components.getSortedProbeComponetAnnotationCandidates(classInterceptorBindings)) {
bindingsBuilder.add(Json.objectBuilder().add(VALUE, binding.toString()).add(PROBE_COMPONENT, Components.isProbeAnnotation(binding)));
}
beanBuilder.add(CLASS_INTERCEPTOR_BINDINGS, bindingsBuilder);
}
}
// ASSOCIATED DECORATORS
List<Decorator<?>> decorators = abstractClassBean.getDecorators();
if (!decorators.isEmpty()) {
JsonArrayBuilder decoratorsBuilder = Json.arrayBuilder();
for (Decorator<?> decorator : decorators) {
decoratorsBuilder.add(createSimpleBeanJson(decorator, probe));
}
beanBuilder.add(DECORATORS, decoratorsBuilder);
}
}
return beanBuilder;
}
use of org.jboss.weld.bean.AbstractProducerBean in project core by weld.
the class Probe method init.
/**
* @param beanManager
*/
void init(BeanManagerImpl beanManager) {
ContextualStore contextualStore = beanManager.getServices().get(ContextualStore.class);
bdaToManager.putAll(Container.instance(beanManager).beanDeploymentArchives());
for (Entry<BeanDeploymentArchive, BeanManagerImpl> entry : bdaToManager.entrySet()) {
ProbeLogger.LOG.processingBeanDeploymentArchive(entry.getKey().getId());
BeanManagerImpl manager = entry.getValue();
// Beans
for (Bean<?> bean : manager.getBeans()) {
// there's only one Instance bean though
if (bean instanceof ExtensionBean) {
// ExtensionBean does not include BeanManager in its BeanIdentifier
ExtensionBean<?> extensionBean = (ExtensionBean<?>) bean;
if (!idToBean.containsValue(extensionBean)) {
putBean(Components.getId(extensionBean.getIdentifier()), manager, extensionBean);
}
} else if (bean instanceof AbstractBuiltInBean<?>) {
// Built-in beans are identified by the set of types
String id = Components.getBuiltinBeanId((AbstractBuiltInBean<?>) bean);
if (!idToBean.containsKey(id)) {
putBean(id, bean);
}
} else {
if (manager.isBeanEnabled(bean)) {
// Make sure the bean is truly enabled
putBean(contextualStore, manager, bean);
}
}
}
// Interceptors
for (Interceptor<?> interceptor : manager.getInterceptors()) {
putBean(contextualStore, manager, interceptor);
}
// Decorators
for (Decorator<?> decorator : manager.getDecorators()) {
putBean(contextualStore, manager, decorator);
}
// Observers
int customObservers = 0;
for (ObserverMethod<?> observerMethod : manager.getObservers()) {
if (observerMethod instanceof ObserverMethodImpl) {
ObserverMethodImpl<?, ?> observerMethodImpl = (ObserverMethodImpl<?, ?>) observerMethod;
putObserver(Components.getId(observerMethodImpl.getId()), observerMethodImpl);
} else {
// Custom observer methods
putObserver(Components.getId("" + customObservers++), observerMethod);
}
}
}
// Find declared producers
for (Bean<?> candidate : idToBean.values()) {
BeanKind kind = BeanKind.from(candidate);
if ((BeanKind.PRODUCER_FIELD.equals(kind) || BeanKind.PRODUCER_METHOD.equals(kind) || BeanKind.RESOURCE.equals(kind)) && candidate instanceof AbstractProducerBean) {
AbstractProducerBean<?, ?, ?> producerBean = (AbstractProducerBean<?, ?, ?>) candidate;
beanToDeclaredProducers.put(producerBean.getDeclaringBean(), producerBean);
}
}
findUnusedBeans();
initTs.set(System.currentTimeMillis());
}
use of org.jboss.weld.bean.AbstractProducerBean in project core by weld.
the class Validator method validateRIBean.
/**
* Validate an RIBean. This includes validating whether two beans specialize
* the same bean
*
* @param bean the bean to validate
* @param beanManager the current manager
* @param specializedBeans the existing specialized beans
*/
protected void validateRIBean(CommonBean<?> bean, BeanManagerImpl beanManager, Collection<CommonBean<?>> specializedBeans) {
validateGeneralBean(bean, beanManager);
if (bean instanceof NewBean) {
return;
}
if (bean instanceof DecorableBean) {
validateDecorators(beanManager, (DecorableBean<?>) bean);
}
if ((bean instanceof AbstractClassBean<?>)) {
AbstractClassBean<?> classBean = (AbstractClassBean<?>) bean;
// validate CDI-defined interceptors
if (classBean.hasInterceptors()) {
validateInterceptors(beanManager, classBean);
}
}
// for each producer bean validate its disposer method
if (bean instanceof AbstractProducerBean<?, ?, ?>) {
AbstractProducerBean<?, ?, ?> producerBean = Reflections.<AbstractProducerBean<?, ?, ?>>cast(bean);
if (producerBean.getProducer() instanceof AbstractMemberProducer<?, ?>) {
AbstractMemberProducer<?, ?> producer = Reflections.<AbstractMemberProducer<?, ?>>cast(producerBean.getProducer());
if (producer.getDisposalMethod() != null) {
for (InjectionPoint ip : producer.getDisposalMethod().getInjectionPoints()) {
// pass the producer bean instead of the disposal method bean
validateInjectionPointForDefinitionErrors(ip, null, beanManager);
validateMetadataInjectionPoint(ip, null, ValidatorLogger.INJECTION_INTO_DISPOSER_METHOD);
validateEventMetadataInjectionPoint(ip);
validateInjectionPointForDeploymentProblems(ip, null, beanManager);
}
}
}
}
}
use of org.jboss.weld.bean.AbstractProducerBean in project core by weld.
the class Validator method reallyValidatePseudoScopedBean.
/**
* checks if a bean has been seen before in the dependencyPath. If not, it
* resolves the InjectionPoints and adds the resolved beans to the set of
* beans to be validated
*/
private static void reallyValidatePseudoScopedBean(Bean<?> bean, BeanManagerImpl beanManager, Set<Object> dependencyPath, Set<Bean<?>> validatedBeans) {
// see if we have already seen this bean in the dependency path
if (dependencyPath.contains(bean)) {
// create a list that shows the path to the bean
List<Object> realDependencyPath = new ArrayList<Object>(dependencyPath);
realDependencyPath.add(bean);
throw ValidatorLogger.LOG.pseudoScopedBeanHasCircularReferences(WeldCollections.toMultiRowString(realDependencyPath));
}
if (validatedBeans.contains(bean)) {
return;
}
dependencyPath.add(bean);
for (InjectionPoint injectionPoint : bean.getInjectionPoints()) {
if (!injectionPoint.isDelegate()) {
dependencyPath.add(injectionPoint);
validatePseudoScopedInjectionPoint(injectionPoint, beanManager, dependencyPath, validatedBeans);
dependencyPath.remove(injectionPoint);
}
}
if (bean instanceof DecorableBean<?>) {
final List<Decorator<?>> decorators = Reflections.<DecorableBean<?>>cast(bean).getDecorators();
if (!decorators.isEmpty()) {
for (final Decorator<?> decorator : decorators) {
reallyValidatePseudoScopedBean(decorator, beanManager, dependencyPath, validatedBeans);
}
}
}
if (bean instanceof AbstractProducerBean<?, ?, ?> && !(bean instanceof EEResourceProducerField<?, ?>)) {
AbstractProducerBean<?, ?, ?> producer = (AbstractProducerBean<?, ?, ?>) bean;
if (!beanManager.isNormalScope(producer.getDeclaringBean().getScope()) && !producer.getAnnotated().isStatic()) {
reallyValidatePseudoScopedBean(producer.getDeclaringBean(), beanManager, dependencyPath, validatedBeans);
}
}
validatedBeans.add(bean);
dependencyPath.remove(bean);
}
Aggregations