public static boolean isObserverMethodEnabled(ObserverMethod<?> method, BeanManagerImpl manager) { if (method instanceof ObserverMethodImpl<?, ?>) { Bean<?> declaringBean = Reflections.<ObserverMethodImpl<?, ?>> cast(method).getDeclaringBean(); return manager.getServices().get(SpecializationAndEnablementRegistry.class).isCandidateForLifecycleEvent(declaringBean); } return true; }
@Override public int hashCode() { return getId().hashCode(); }
public void addObserverMethod(ObserverInitializationContext<?, ?> observerInitializer) { this.observers.add(observerInitializer); addNewBeansFromInjectionPoints(observerInitializer.getObserver().getInjectionPoints()); }
this.beanManager = manager; this.declaringBean = declaringBean; this.observerMethod = initMethodInjectionPoint(observer, declaringBean, manager); EnhancedAnnotatedParameter<?, ? super X> eventParameter = observer.getEnhancedParameters(Observes.class).get(0); this.eventType = new HierarchyDiscovery(declaringBean.getBeanClass()).resolveType(eventParameter.getBaseType()); this.id = createId(observer, declaringBean); this.bindings = manager.getServices().get(SharedObjectCache.class) .getSharedSet(observer.getEnhancedParameters(Observes.class).get(0).getMetaAnnotations(Qualifier.class)); Observes observesAnnotation = observer.getEnhancedParameters(Observes.class).get(0).getAnnotation(Observes.class); this.reception = observesAnnotation.notifyObserver(); transactionPhase = ObserverFactory.getTransactionalPhase(observer); for (ParameterInjectionPoint<?, ?> injectionPoint : observerMethod.getParameterInjectionPoints()) { if (injectionPoint instanceof SpecialParameterInjectionPoint) { continue; this.isStatic = observer.isStatic(); this.eventMetadataRequired = initMetadataRequired(this.injectionPoints); this.notificationStrategy = MethodInvocationStrategy.forObserver(observerMethod, beanManager);
ContextualStore contextualStore = beanManager.getServices().get(ContextualStore.class); bdaToManager.putAll(Container.instance(beanManager).beanDeploymentArchives()); for (Bean<?> bean : manager.getBeans()) { if (manager.isBeanEnabled(bean)) { if (observerMethod instanceof ObserverMethodImpl) { ObserverMethodImpl<?, ?> observerMethodImpl = (ObserverMethodImpl<?, ?>) observerMethod; putObserver(Components.getId(observerMethodImpl.getId()), observerMethodImpl); } else {
List<EnhancedAnnotatedParameter<?, Y>> eventObjects = annotated.getEnhancedParameters(Observes.class); eventObjects.addAll(annotated.getEnhancedParameters(ObservesAsync.class)); if (this.reception.equals(Reception.IF_EXISTS) && declaringBean.getScope().equals(Dependent.class)) { throw EventLogger.LOG.invalidScopedConditionalObserver(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); throw EventLogger.LOG.multipleEventParameters(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); checkRequiredTypeAnnotations(eventParameter); List<?> disposeParams = annotated.getEnhancedParameters(Disposes.class); if (disposeParams.size() > 0) { throw EventLogger.LOG.invalidDisposesParameter(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); if (this.observerMethod.getAnnotated().isAnnotationPresent(Produces.class)) { throw EventLogger.LOG.invalidProducer(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); if (this.observerMethod.getAnnotated().isAnnotationPresent(Inject.class)) { throw EventLogger.LOG.invalidInitializer(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); for (EnhancedAnnotatedParameter<?, ?> parameter : annotated.getEnhancedParameters()) { if (containerLifecycleObserverMethod && !parameter.isAnnotationPresent(Observes.class) && !parameter.isAnnotationPresent(ObservesAsync.class) && !BeanManager.class.equals(parameter.getBaseType())) { throw EventLogger.LOG.invalidInjectionPoint(this, Formats.formatAsStackTraceElement(annotated.getJavaMember()));
static JsonObjectBuilder createEventJson(EventInfo event, Probe probe) { JsonObjectBuilder builder = Json.objectBuilder(); builder.add(TYPE, Formats.formatType(event.getType(), event.isContainerEvent())); builder.add(QUALIFIERS, createQualifiers(event.getQualifiers(), true)); builder.add(EVENT_INFO, event.getEventString()); builder.add(KIND, (event.isContainerEvent() ? CONTAINER : APPLICATION).toUpperCase()); builder.add(TIMESTAMP, event.getTimestamp()); JsonArrayBuilder observersBuilder = Json.arrayBuilder(); for (ObserverMethod<?> observer : event.getObservers()) { JsonObjectBuilder b = createSimpleObserverJson(observer, probe); if (observer instanceof ObserverMethodImpl<?, ?>) { ObserverMethodImpl<?, ?> weldObserver = (ObserverMethodImpl<?, ?>) observer; AnnotatedMethod<?> method = weldObserver.getMethod().getAnnotated(); b.add(METHOD, method.getJavaMember().getName()); // b.add(METHOD, method.getJavaMember().getName() + Formats.formatAsFormalParameterList(method.getParameters())); } observersBuilder.add(b); } builder.add(OBSERVERS, observersBuilder); return builder; }
/** * * @param observerMethod * @param probe * @return */ static JsonObjectBuilder createFullObserverJson(ObserverMethod<?> observerMethod, Probe probe) { JsonObjectBuilder observerBuilder = createBasicObserverJson(observerMethod, probe); if (observerMethod instanceof ObserverMethodImpl) { ObserverMethodImpl<?, ?> observerMethodImpl = (ObserverMethodImpl<?, ?>) observerMethod; observerBuilder.add(ANNOTATED_METHOD, annotatedMethodToString(observerMethodImpl.getMethod().getAnnotated(), observerMethodImpl.getBeanClass())); } return observerBuilder; }
public <T, X> ObserverMethod<T> fireProcessObserverMethod(BeanManagerImpl beanManager, ObserverMethodImpl<T, X> observer) { return fireProcessObserverMethod(beanManager, observer.getMethod().getAnnotated(), observer, null); }
protected String createId(final EnhancedAnnotatedMethod<?, ?> observer, final RIBean<?> declaringBean) { return new StringBuilder().append(ID_PREFIX).append(ID_SEPARATOR).append(ObserverMethod.class.getSimpleName()).append(ID_SEPARATOR) .append(createTypeId(declaringBean)).append(".").append(observer.getSignature()).toString(); }
@Override boolean test(ObserverMethod<?> observer) { final Bean<?> declaringBean; if (observer instanceof ObserverMethodImpl) { declaringBean = ((ObserverMethodImpl<?, ?>) observer).getDeclaringBean(); } else { declaringBean = null; } return testBda(bda, declaringBean) && testEquals(declaringBeanKind, BeanKind.from(declaringBean)) && testEquals(reception, observer.getReception()) && testEquals(txPhase, observer.getTransactionPhase()) && testContainsIgnoreCase(beanClass, observer.getBeanClass()) && testContainsIgnoreCase(observedType, observer.getObservedType()) && testAnyContains(qualifier, observer.getObservedQualifiers()); }
/** * Completes initialization of the observer and allows derived types to override behavior. */ public void initialize(EnhancedAnnotatedMethod<T, ? super X> annotated) { checkObserverMethod(annotated); }
protected String createTypeId(RIBean<?> declaringBean) { if (declaringBean instanceof ExtensionBean) { ExtensionBean<?> extensionBean = (ExtensionBean<?>) declaringBean; return extensionBean.getAnnotatedType().getIdentifier().asString(); } return super.createTypeId(declaringBean); }
/** * Creates an observer * * @param method The observer method abstraction * @param declaringBean The declaring bean * @param manager The Bean manager * @return An observer implementation built from the method abstraction */ public static <T, X> ObserverMethodImpl<T, X> create(EnhancedAnnotatedMethod<T, ? super X> method, RIBean<X> declaringBean, BeanManagerImpl manager, boolean isAsync) { if (declaringBean instanceof ExtensionBean) { return new ExtensionObserverMethodImpl<T, X>(method, declaringBean, manager, isAsync); } return new ObserverMethodImpl<T, X>(method, declaringBean, manager, isAsync); }
@Override public boolean equals(Object obj) { if (obj == null) { return false; } if (this == obj) { return true; } if (getClass() != obj.getClass()) { return false; } ExtensionObserverMethodImpl<?, ?> that = (ExtensionObserverMethodImpl<?, ?>) obj; return super.equals(that); }
this.beanManager = manager; this.declaringBean = declaringBean; this.observerMethod = initMethodInjectionPoint(observer, declaringBean, manager); this.id = createId(observer, declaringBean); this.isAsync = isAsync; final EnhancedAnnotatedParameter<?, ? super X> eventParameter = getEventParameter(observer); if (isAsync) { this.reception = eventParameter.getAnnotation(ObservesAsync.class).notifyObserver(); this.reception = eventParameter.getAnnotation(Observes.class).notifyObserver(); this.transactionPhase = ObserverFactory.getTransactionalPhase(observer); this.bindings = manager.getServices().get(SharedObjectCache.class) .getSharedSet(eventParameter.getMetaAnnotations(Qualifier.class)); this.eventType = new HierarchyDiscovery(declaringBean.getBeanClass()).resolveType(eventParameter.getBaseType()); for (ParameterInjectionPoint<?, ?> injectionPoint : observerMethod.getParameterInjectionPoints()) { if (injectionPoint instanceof SpecialParameterInjectionPoint) { continue; this.priority = priority.value(); this.isStatic = observer.isStatic(); this.eventMetadataRequired = initMetadataRequired(this.injectionPoints); this.notificationStrategy = MethodInvocationStrategy.forObserver(observerMethod, beanManager);
List<EnhancedAnnotatedParameter<?, Y>> eventObjects = annotated.getEnhancedParameters(Observes.class); eventObjects.addAll(annotated.getEnhancedParameters(ObservesAsync.class)); if (this.reception.equals(Reception.IF_EXISTS) && declaringBean.getScope().equals(Dependent.class)) { throw EventLogger.LOG.invalidScopedConditionalObserver(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); throw EventLogger.LOG.multipleEventParameters(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); checkRequiredTypeAnnotations(eventParameter); List<?> disposeParams = annotated.getEnhancedParameters(Disposes.class); if (disposeParams.size() > 0) { throw EventLogger.LOG.invalidDisposesParameter(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); if (this.observerMethod.getAnnotated().isAnnotationPresent(Produces.class)) { throw EventLogger.LOG.invalidProducer(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); if (this.observerMethod.getAnnotated().isAnnotationPresent(Inject.class)) { throw EventLogger.LOG.invalidInitializer(this, Formats.formatAsStackTraceElement(annotated.getJavaMember())); for (EnhancedAnnotatedParameter<?, ?> parameter : annotated.getEnhancedParameters()) { if (containerLifecycleObserverMethod && !parameter.isAnnotationPresent(Observes.class) && !parameter.isAnnotationPresent(ObservesAsync.class) && !BeanManager.class.equals(parameter.getBaseType())) { throw EventLogger.LOG.invalidInjectionPoint(this, Formats.formatAsStackTraceElement(annotated.getJavaMember()));
static JsonObjectBuilder createEventJson(EventInfo event, Probe probe) { JsonObjectBuilder builder = Json.objectBuilder(); builder.add(TYPE, Formats.formatType(event.getType(), event.isContainerEvent())); builder.add(QUALIFIERS, createQualifiers(event.getQualifiers(), true)); builder.add(EVENT_INFO, event.getEventString()); builder.add(KIND, (event.isContainerEvent() ? CONTAINER : APPLICATION).toUpperCase()); builder.add(TIMESTAMP, event.getTimestamp()); JsonArrayBuilder observersBuilder = Json.arrayBuilder(); for (ObserverMethod<?> observer : event.getObservers()) { JsonObjectBuilder b = createSimpleObserverJson(observer, probe); if (observer instanceof ObserverMethodImpl<?, ?>) { ObserverMethodImpl<?, ?> weldObserver = (ObserverMethodImpl<?, ?>) observer; AnnotatedMethod<?> method = weldObserver.getMethod().getAnnotated(); b.add(METHOD, method.getJavaMember().getName()); // b.add(METHOD, method.getJavaMember().getName() + Formats.formatAsFormalParameterList(method.getParameters())); } observersBuilder.add(b); } builder.add(OBSERVERS, observersBuilder); return builder; }
/** * * @param observerMethod * @param probe * @return */ static JsonObjectBuilder createFullObserverJson(ObserverMethod<?> observerMethod, Probe probe) { JsonObjectBuilder observerBuilder = createBasicObserverJson(observerMethod, probe); if (observerMethod instanceof ObserverMethodImpl) { ObserverMethodImpl<?, ?> observerMethodImpl = (ObserverMethodImpl<?, ?>) observerMethod; observerBuilder.add(ANNOTATED_METHOD, annotatedMethodToString(observerMethodImpl.getMethod().getAnnotated(), observerMethodImpl.getBeanClass())); } return observerBuilder; }
public <T, X> ObserverMethod<T> fireProcessObserverMethod(BeanManagerImpl beanManager, ObserverMethodImpl<T, X> observer) { return fireProcessObserverMethod(beanManager, observer.getMethod().getAnnotated(), observer, null); }