Java Examples for javax.enterprise.inject.Alternative
The following java examples will help you to understand the usage of javax.enterprise.inject.Alternative. These source code samples are taken from different open source projects.
Example 1
Project: solder-master File: GenericBeanExtension.java View source code |
void createGenericBeans(@Observes AfterBeanDiscovery event, BeanManager beanManager) {
beanDiscoveryOver = true;
// For each generic configuration type, we iterate the generic configurations
for (Entry<GenericIdentifier, GenericConfigurationHolder> genericConfigurationEntry : genericConfigurationPoints.entrySet()) {
Class<? extends Annotation> producerScope = Dependent.class;
for (Annotation annotation : genericConfigurationEntry.getValue().getAnnotated().getAnnotations()) {
if (beanManager.isScope(annotation.annotationType())) {
producerScope = annotation.annotationType();
}
}
GenericConfigurationHolder genericConfigurationHolder = genericConfigurationEntry.getValue();
GenericIdentifier identifier = genericConfigurationEntry.getKey();
Class<? extends Annotation> genericConfigurationType = identifier.getAnnotationType();
if (!genericBeans.containsKey(genericConfigurationType)) {
throw new IllegalStateException("No generic bean definition exists for " + genericConfigurationType + ", but a generic producer does: " + genericConfigurationHolder.getAnnotated());
}
// Add a generic configuration bean for each generic configuration producer (allows us to inject the generic configuration annotation back into the generic bean)
event.addBean(createGenericConfigurationBean(beanManager, identifier));
// Register the GenericProduct bean
event.addBean(createGenericProductAnnotatedMemberBean(beanManager, identifier));
boolean alternative = genericConfigurationHolder.getAnnotated().isAnnotationPresent(Alternative.class);
Class<?> javaClass = genericConfigurationHolder.getJavaClass();
if (genericBeanProducerMethods.containsKey(genericConfigurationType)) {
for (ProducerMethodHolder<?, ?> holder : genericBeanProducerMethods.get(genericConfigurationType)) {
Class<? extends Annotation> scopeOverride = null;
if (holder.getProducerMethod().isAnnotationPresent(ApplyScope.class)) {
scopeOverride = producerScope;
}
event.addBean(createGenericProducerMethod(holder, identifier, beanManager, scopeOverride, alternative, javaClass));
}
}
if (genericBeanProducerFields.containsKey(genericConfigurationType)) {
for (FieldHolder<?, ?> holder : genericBeanProducerFields.get(genericConfigurationType)) {
Class<? extends Annotation> scopeOverride = null;
if (holder.getField().isAnnotationPresent(ApplyScope.class)) {
scopeOverride = producerScope;
}
event.addBean(createGenericProducerField(holder.getBean(), identifier, holder.getField(), beanManager, scopeOverride, alternative, javaClass));
}
}
if (genericBeanObserverMethods.containsKey(genericConfigurationType)) {
for (ObserverMethodHolder<?, ?> holder : genericBeanObserverMethods.get(genericConfigurationType)) {
event.addObserverMethod(createGenericObserverMethod(holder.getObserverMethod(), identifier, holder.getMethod(), null, beanManager));
}
}
if (unwrapsMethods.containsKey(genericConfigurationType)) {
for (AnnotatedMethod<?> i : unwrapsMethods.get(genericConfigurationType)) {
Annotated annotated = genericConfigurationHolder.getAnnotated();
Set<Annotation> unwrapsQualifiers = Beans.getQualifiers(beanManager, i.getAnnotations(), annotated.getAnnotations());
if (unwrapsQualifiers.isEmpty()) {
unwrapsQualifiers.add(DefaultLiteral.INSTANCE);
}
Set<Annotation> beanQualifiers = Beans.getQualifiers(beanManager, i.getDeclaringType().getAnnotations(), annotated.getAnnotations());
beanQualifiers.remove(AnyLiteral.INSTANCE);
if (beanQualifiers.isEmpty()) {
beanQualifiers.add(DefaultLiteral.INSTANCE);
}
beanQualifiers.remove(genericBeanQualifier);
event.addBean(new UnwrapsProducerBean(i, unwrapsQualifiers, beanQualifiers, beanManager));
}
}
// For each generic bean that uses this genericConfigurationType, register a generic bean for this generic configuration
for (BeanHolder<?> genericBeanHolder : genericBeans.get(genericConfigurationType)) {
// Register the generic bean, this is the underlying definition, with the synthetic qualifier
Class<? extends Annotation> scopeOverride = null;
if (genericBeanHolder.getType().isAnnotationPresent(ApplyScope.class)) {
scopeOverride = producerScope;
}
Bean<?> genericBean = createGenericBean(genericBeanHolder, identifier, beanManager, scopeOverride, alternative, javaClass);
event.addBean(genericBean);
}
}
}
Example 2
Project: guvnor-master File: TestIdentityFactory.java View source code |
@Produces
@Alternative
public AuthenticationService authenticationService() {
return new AuthenticationService() {
boolean isLoggedIn = false;
User user;
@Override
public User login(String username, String password) {
isLoggedIn = true;
user = new UserImpl(username);
return user;
}
@Override
public boolean isLoggedIn() {
return false;
}
@Override
public void logout() {
user = null;
isLoggedIn = false;
}
@Override
public User getUser() {
return user;
}
};
}
Example 3
Project: autobind-master File: AnnotationCollector.java View source code |
@SuppressWarnings("unchecked")
@Override
public void visitEnd() {
if (!_ignore && _annotations.size() > 0 && !_annotations.containsKey("javax.enterprise.inject.Alternative")) {
for (ScannerFeature listener : _features) {
listener.found((Class<Object>) _class, _annotations);
}
}
_name = null;
_class = null;
_ignore = false;
_annotations.clear();
}
Example 4
Project: camel-master File: CamelCdiTestExtension.java View source code |
/** * Activates the alternatives declared with {@code @Beans} globally for the * application. * <p/> * For every types and every methods of every types declared with * {@link Beans#alternatives()}, the {@code Priority} annotation is added * so that the corresponding alternatives are selected globally for the * entire application. * * @see Beans */ private <T> void alternatives(@Observes @WithAnnotations(Alternative.class) ProcessAnnotatedType<T> pat) { AnnotatedType<T> type = pat.getAnnotatedType(); if (!Arrays.asList(beans.alternatives()).contains(type.getJavaClass())) { // Only select globally the alternatives that are declared with @Beans return; } Set<AnnotatedMethod<? super T>> methods = new HashSet<>(); for (AnnotatedMethod<? super T> method : type.getMethods()) { if (method.isAnnotationPresent(Alternative.class) && !method.isAnnotationPresent(Priority.class)) { methods.add(new AnnotatedMethodDecorator<>(method, PriorityLiteral.of(APPLICATION))); } } if (type.isAnnotationPresent(Alternative.class) && !type.isAnnotationPresent(Priority.class)) { pat.setAnnotatedType(new AnnotatedTypeDecorator<>(type, PriorityLiteral.of(APPLICATION), methods)); } else if (!methods.isEmpty()) { pat.setAnnotatedType(new AnnotatedTypeDecorator<>(type, methods)); } }
Example 5
Project: deltaspike-master File: ExcludeExtension.java View source code |
private void activateGlobalAlternatives(ProcessAnnotatedType processAnnotatedType, BeanManager beanManager) { Class<Object> currentBean = processAnnotatedType.getAnnotatedType().getJavaClass(); if (currentBean.isInterface()) { return; } Set<Class> beanBaseTypes = resolveBeanTypes(currentBean); boolean isAlternativeBeanImplementation = currentBean.isAnnotationPresent(Alternative.class); List<Annotation> qualifiersOfCurrentBean = resolveQualifiers(processAnnotatedType.getAnnotatedType().getAnnotations(), beanManager); String configuredBeanName; List<Annotation> qualifiersOfConfiguredBean; Class<Object> alternativeBeanClass; Set<Annotation> alternativeBeanAnnotations; for (Class currentType : beanBaseTypes) { alternativeBeanAnnotations = new HashSet<Annotation>(); configuredBeanName = globalAlternatives.get(currentType.getName()); if (configuredBeanName != null && configuredBeanName.length() > 0) { alternativeBeanClass = ClassUtils.tryToLoadClassForName(configuredBeanName); if (alternativeBeanClass == null) { throw new IllegalStateException("Can't find class " + configuredBeanName + " which is configured" + " for " + currentType.getName()); } //check that the configured class is an alternative if (!alternativeBeanClass.isAnnotationPresent(Alternative.class)) { //we have to continue because other classes can be configured as well continue; } alternativeBeanAnnotations.addAll(Arrays.asList(alternativeBeanClass.getAnnotations())); qualifiersOfConfiguredBean = resolveQualifiers(alternativeBeanAnnotations, beanManager); } else { continue; } if (!doQualifiersMatch(qualifiersOfCurrentBean, qualifiersOfConfiguredBean)) { continue; } //current bean is annotated with @Alternative and of the same type as the configured bean if (isAlternativeBeanImplementation && alternativeBeanClass.equals(currentBean)) { LOG.info(processAnnotatedType.getAnnotatedType().getJavaClass().getName() + " is configured as global-alternative"); //cdi 1.0 if (priorityAnnotationInstance == null) { AnnotatedTypeBuilder<Object> annotatedTypeBuilder = new AnnotatedTypeBuilder<Object>().readFromType(processAnnotatedType.getAnnotatedType()); annotatedTypeBuilder.removeFromClass(Alternative.class); processAnnotatedType.setAnnotatedType(annotatedTypeBuilder.create()); return; } else //cdi 1.1+ { AnnotatedTypeBuilder<Object> annotatedTypeBuilder = new AnnotatedTypeBuilder<Object>().readFromType(processAnnotatedType.getAnnotatedType()); annotatedTypeBuilder.addToClass(priorityAnnotationInstance); processAnnotatedType.setAnnotatedType(annotatedTypeBuilder.create()); return; } } else //current bean is the original implementation { //cdi 1.0 (no change needed with cdi 1.1+) if (priorityAnnotationInstance == null) { //veto this original implementation because the alternative will be added processAnnotatedType.veto(); return; } } } }
Example 6
Project: forge-beanstest-master File: MockitoFacet.java View source code |
private void createStereotype(String beanstestPackage, String stereotype) throws FileNotFoundException { // @Stereotype // @Alternative // @Target(ElementType.METHOD) // @Retention(RetentionPolicy.RUNTIME) // public @interface BeanstestAlternative { // } //TODO how do i create a nested annotation with Forge ? JavaResource stereotypeResource = getStereotype(stereotype); if (!stereotypeResource.exists()) { JavaAnnotation javaAnnotation = JavaParser.create(JavaAnnotation.class); javaAnnotation.setName(stereotype); javaAnnotation.setPackage(beanstestPackage); javaAnnotation.addAnnotation(Stereotype.class); javaAnnotation.addAnnotation(Alternative.class); javaAnnotation.addAnnotation(Target.class).setEnumValue(ElementType.METHOD); javaAnnotation.addAnnotation(Retention.class).setEnumValue(RetentionPolicy.RUNTIME); stereotypeResource.setContents(javaAnnotation); BeansDescriptor beansDescriptor = project.getFacet(CDITestFacet.class).getConfig(); if (!beansDescriptor.getAlternativeStereotypes().contains(javaAnnotation.getCanonicalName())) { beansDescriptor.alternativeStereotype(javaAnnotation.getCanonicalName()); project.getFacet(CDITestFacet.class).saveConfig(beansDescriptor); } } }
Example 7
Project: guice-automatic-injection-master File: ReflectionsScanner.java View source code |
@SuppressWarnings("unchecked")
@Override
public void scan(final Object cls) {
ClassFile classFile = (ClassFile) cls;
AnnotationsAttribute annotationsAttribute = (AnnotationsAttribute) classFile.getAttribute(AnnotationsAttribute.visibleTag);
if (annotationsAttribute == null) {
return;
}
Class<Object> objectClass;
try {
objectClass = (Class<Object>) Class.forName(classFile.getName(), true, Thread.currentThread().getContextClassLoader());
} catch (ClassNotFoundException e) {
ReflectionsScanner.this._logger.log(Level.WARNING, "Failure while trying to load the Class \"" + classFile.getName() + "\" from Classpath.", e);
return;
}
Map<String, java.lang.annotation.Annotation> map = new HashMap<String, java.lang.annotation.Annotation>();
for (Annotation annotation : annotationsAttribute.getAnnotations()) {
Class<java.lang.annotation.Annotation> annotationClass;
try {
annotationClass = (Class<java.lang.annotation.Annotation>) Class.forName(annotation.getTypeName());
map.put(annotationClass.getName(), objectClass.getAnnotation(annotationClass));
} catch (ClassNotFoundException e) {
ReflectionsScanner.this._logger.log(Level.WARNING, "Failure while trying to load the Annotations from Classpath.", e);
continue;
}
}
if (map.containsKey("javax.enterprise.inject.Alternative")) {
return;
}
for (ScannerFeature feature : features) {
feature.found(objectClass, map);
}
}
Example 8
Project: jbosstools-integration-tests-master File: SeamConfigEEOpenOnTest.java View source code |
@Test public void testAlternativeOpenOn() { /* open on bean class */ new DefaultStyledText().selectText("s:Alternative"); KeyboardFactory.getKeyboard().invokeKeyCombination(SWT.F3); new DefaultEditor("Alternative.class"); /* test opened object */ assertExpectedOpenedClass("javax.enterprise.inject.Alternative"); }
Example 9
Project: shrinkwrap-sandbox-master File: BeansDef.java View source code |
public BeansDef alternativeClasses(Class<?>... classes) {
for (Class<?> c : classes) {
// FIXME this validation needs to be thorough
if (!c.isAnnotationPresent(Alternative.class)) {
throw new IllegalArgumentException("Class is not an alternative");
}
beans.getAlternatives().getClasses().add(c.getName());
}
return this;
}
Example 10
Project: blaze-utils-master File: ExcludeIfExistsExtension.java View source code |
private BeanBuilder<Object> readFromMember(BeanBuilder<Object> beanBuilder, AnnotatedMember<Object> annotatedMember, Bean<Object> bean, boolean isOwbBug) {
// Init the qualifiers set
beanBuilder.qualifiers();
Set<Class<? extends Annotation>> stereotypes = new HashSet<Class<? extends Annotation>>();
for (Annotation annotation : annotatedMember.getAnnotations()) {
if (beanBuilder.getBeanManager().isQualifier(annotation.annotationType())) {
beanBuilder.addQualifier(annotation);
} else if (beanBuilder.getBeanManager().isScope(annotation.annotationType())) {
beanBuilder.scope(annotation.annotationType());
} else if (beanBuilder.getBeanManager().isStereotype(annotation.annotationType())) {
stereotypes.add(annotation.annotationType());
}
if (annotation instanceof Named) {
beanBuilder.name(((Named) annotation).value());
}
if (annotation instanceof Alternative) {
beanBuilder.alternative(true);
}
}
beanBuilder.stereotypes(stereotypes);
if (beanBuilder.getScope() == null) {
beanBuilder.scope(Dependent.class);
}
boolean isDependent = beanBuilder.getScope() == Dependent.class;
Class<?> declaringClass = annotatedMember.getDeclaringType().getJavaClass();
if (annotatedMember instanceof AnnotatedField<?>) {
AnnotatedField<Object> annotatedField = (AnnotatedField<Object>) annotatedMember;
Field field = annotatedField.getJavaMember();
Class<?> rawType = ReflectionUtils.getResolvedFieldType(declaringClass, field);
beanBuilder.beanClass(rawType);
beanBuilder.beanLifecycle(new ProducerFieldCreationalContext(bean, annotatedField, beanBuilder.getBeanManager()));
} else {
AnnotatedMethod<Object> annotatedMethod = (AnnotatedMethod<Object>) annotatedMember;
Method method = annotatedMethod.getJavaMember();
Class<?> rawType = ReflectionUtils.getResolvedMethodReturnType(declaringClass, method);
beanBuilder.beanClass(rawType);
ProducerMethodCreationalContext ctx = new ProducerMethodCreationalContext(bean, annotatedMethod, beanBuilder.getBeanManager(), isDependent && isOwbBug);
beanBuilder.beanLifecycle(ctx);
beanBuilder.injectionPoints(ctx.getInjectionPoints());
}
beanBuilder.types(annotatedMember.getTypeClosure());
if (beanBuilder.getQualifiers().isEmpty()) {
beanBuilder.addQualifier(new DefaultLiteral());
}
beanBuilder.addQualifier(new AnyLiteral());
return beanBuilder;
}
Example 11
Project: quercus-master File: InjectManager.java View source code |
public int getDeploymentPriority(Bean<?> bean) {
int priority = DEFAULT_PRIORITY;
Set<Class<? extends Annotation>> stereotypes = bean.getStereotypes();
if (bean.isAlternative()) {
priority = -1;
Integer value = _deploymentMap.get(bean.getBeanClass());
if (value != null)
priority = value;
}
if (stereotypes != null) {
for (Class<? extends Annotation> annType : stereotypes) {
Integer value = _deploymentMap.get(annType);
if (value != null) {
if (priority < value)
priority = value;
} else if (annType.isAnnotationPresent(Alternative.class) && priority == DEFAULT_PRIORITY)
priority = -1;
}
}
if (priority < 0)
return priority;
else if (bean instanceof AbstractBean<?>) {
// ioc/0213
AbstractBean<?> absBean = (AbstractBean<?>) bean;
if (absBean.getBeanManager() == this)
priority += 1000000;
} else
priority += 1000000;
return priority;
}
Example 12
Project: resin-master File: InjectManager.java View source code |
public int getDeploymentPriority(Bean<?> bean) {
int priority = DEFAULT_PRIORITY;
if (bean.isAlternative()) {
priority = -1;
Integer value = getPriority(bean.getBeanClass());
if (value != null)
priority = value;
}
Set<Class<? extends Annotation>> stereotypes = bean.getStereotypes();
if (stereotypes != null) {
for (Class<? extends Annotation> annType : stereotypes) {
Integer value = _deploymentMap.get(annType);
if (value != null) {
if (priority < value)
priority = value;
} else if (annType.isAnnotationPresent(Alternative.class) && priority == DEFAULT_PRIORITY)
priority = -1;
}
}
if (priority < 0)
return priority;
else if (bean instanceof AbstractBean<?>) {
// ioc/0213
AbstractBean<?> absBean = (AbstractBean<?>) bean;
if (absBean.getBeanManager() == this)
priority += 1000000;
} else
priority += 1000000;
return priority;
}
Example 13
Project: deltaspike-solder-master File: GenericBeanExtension.java View source code |
void createGenericBeans(@Observes AfterBeanDiscovery event, BeanManager beanManager) {
beanDiscoveryOver = true;
// For each generic configuration type, we iterate the generic configurations
for (Entry<GenericIdentifier, GenericConfigurationHolder> genericConfigurationEntry : genericConfigurationPoints.entrySet()) {
Class<? extends Annotation> producerScope = Dependent.class;
for (Annotation annotation : genericConfigurationEntry.getValue().getAnnotated().getAnnotations()) {
if (beanManager.isScope(annotation.annotationType())) {
producerScope = annotation.annotationType();
}
}
GenericConfigurationHolder genericConfigurationHolder = genericConfigurationEntry.getValue();
GenericIdentifier identifier = genericConfigurationEntry.getKey();
Class<? extends Annotation> genericConfigurationType = identifier.getAnnotationType();
if (!genericBeans.containsKey(genericConfigurationType)) {
throw new IllegalStateException("No generic bean definition exists for " + genericConfigurationType + ", but a generic producer does: " + genericConfigurationHolder.getAnnotated());
}
// Add a generic configuration bean for each generic configuration producer (allows us to inject the generic configuration annotation back into the generic bean)
event.addBean(createGenericConfigurationBean(beanManager, identifier));
// Register the GenericProduct bean
event.addBean(createGenericProductAnnotatedMemberBean(beanManager, identifier));
boolean alternative = genericConfigurationHolder.getAnnotated().isAnnotationPresent(Alternative.class);
Class<?> javaClass = genericConfigurationHolder.getJavaClass();
if (genericBeanProducerMethods.containsKey(genericConfigurationType)) {
for (ProducerMethodHolder<?, ?> holder : genericBeanProducerMethods.get(genericConfigurationType)) {
Class<? extends Annotation> scopeOverride = null;
if (holder.getProducerMethod().isAnnotationPresent(ApplyScope.class)) {
scopeOverride = producerScope;
}
event.addBean(createGenericProducerMethod(holder, identifier, beanManager, scopeOverride, alternative, javaClass));
}
}
if (genericBeanProducerFields.containsKey(genericConfigurationType)) {
for (FieldHolder<?, ?> holder : genericBeanProducerFields.get(genericConfigurationType)) {
Class<? extends Annotation> scopeOverride = null;
if (holder.getField().isAnnotationPresent(ApplyScope.class)) {
scopeOverride = producerScope;
}
event.addBean(createGenericProducerField(holder.getBean(), identifier, holder.getField(), beanManager, scopeOverride, alternative, javaClass));
}
}
if (genericBeanObserverMethods.containsKey(genericConfigurationType)) {
for (ObserverMethodHolder<?, ?> holder : genericBeanObserverMethods.get(genericConfigurationType)) {
event.addObserverMethod(createGenericObserverMethod(holder.getObserverMethod(), identifier, holder.getMethod(), null, beanManager));
}
}
if (unwrapsMethods.containsKey(genericConfigurationType)) {
for (AnnotatedMethod<?> i : unwrapsMethods.get(genericConfigurationType)) {
Annotated annotated = genericConfigurationHolder.getAnnotated();
Set<Annotation> unwrapsQualifiers = Beans.getQualifiers(beanManager, i.getAnnotations(), annotated.getAnnotations());
if (unwrapsQualifiers.isEmpty()) {
unwrapsQualifiers.add(DefaultLiteral.INSTANCE);
}
Set<Annotation> beanQualifiers = Beans.getQualifiers(beanManager, i.getDeclaringType().getAnnotations(), annotated.getAnnotations());
beanQualifiers.remove(AnyLiteral.INSTANCE);
if (beanQualifiers.isEmpty()) {
beanQualifiers.add(DefaultLiteral.INSTANCE);
}
beanQualifiers.remove(genericBeanQualifier);
event.addBean(new UnwrapsProducerBean(i, unwrapsQualifiers, beanQualifiers, beanManager));
}
}
// For each generic bean that uses this genericConfigurationType, register a generic bean for this generic configuration
for (BeanHolder<?> genericBeanHolder : genericBeans.get(genericConfigurationType)) {
// Register the generic bean, this is the underlying definition, with the synthetic qualifier
Class<? extends Annotation> scopeOverride = null;
if (genericBeanHolder.getType().isAnnotationPresent(ApplyScope.class)) {
scopeOverride = producerScope;
}
Bean<?> genericBean = createGenericBean(genericBeanHolder, identifier, beanManager, scopeOverride, alternative, javaClass);
event.addBean(genericBean);
}
}
}
Example 14
Project: solder-old-master File: GenericBeanExtension.java View source code |
void createGenericBeans(@Observes AfterBeanDiscovery event, BeanManager beanManager) {
// For each generic configuration type, we iterate the generic configurations
for (Entry<Annotation, ProducerHolder<?, ?>> genericConfigurationEntry : genericProducers.entrySet()) {
Class<? extends Annotation> producerScope = Dependent.class;
for (Annotation annotation : genericConfigurationEntry.getValue().getMember().getAnnotations()) {
if (beanManager.isScope(annotation.annotationType())) {
producerScope = annotation.annotationType();
}
}
ProducerHolder<?, ?> producerHolder = genericConfigurationEntry.getValue();
Annotation genericConfiguration = genericConfigurationEntry.getKey();
Set<Annotation> qualifiers = new HashSet<Annotation>();
qualifiers.addAll(Beans.getQualifiers(beanManager, genericConfigurationEntry.getValue().getMember().getAnnotations()));
if (qualifiers.isEmpty()) {
qualifiers.add(DefaultLiteral.INSTANCE);
}
Class<? extends Annotation> genericConfigurationType = genericConfiguration.annotationType();
if (!genericBeans.containsKey(genericConfigurationType)) {
throw new IllegalStateException("No generic bean definition exists for " + genericConfigurationType + ", but a generic producer does: " + producerHolder.getMember());
}
// Add a generic configuration bean for each generic configuration producer (allows us to inject the generic configuration annotation back into the generic bean)
event.addBean(createGenericConfigurationBean(beanManager, genericConfiguration, qualifiers));
// Register the GenericProduct bean
event.addBean(createGenericProductAnnotatedMemberBean(beanManager, genericConfiguration, qualifiers));
boolean alternative = producerHolder.getMember().isAnnotationPresent(Alternative.class);
Class<?> javaClass = producerHolder.getMember().getDeclaringType().getJavaClass();
if (genericBeanProducerMethods.containsKey(genericConfigurationType)) {
for (ProducerMethodHolder<?, ?> holder : genericBeanProducerMethods.get(genericConfigurationType)) {
Class<? extends Annotation> scopeOverride = null;
if (holder.getProducerMethod().isAnnotationPresent(ApplyScope.class)) {
scopeOverride = producerScope;
}
event.addBean(createGenericProducerMethod(holder, genericConfiguration, beanManager, scopeOverride, alternative, javaClass));
}
}
if (genericBeanProducerFields.containsKey(genericConfigurationType)) {
for (FieldHolder<?, ?> holder : genericBeanProducerFields.get(genericConfigurationType)) {
Class<? extends Annotation> scopeOverride = null;
if (holder.getField().isAnnotationPresent(ApplyScope.class)) {
scopeOverride = producerScope;
}
event.addBean(createGenericProducerField(holder.getBean(), genericConfiguration, holder.getField(), beanManager, scopeOverride, alternative, javaClass));
}
}
if (genericBeanObserverMethods.containsKey(genericConfigurationType)) {
for (ObserverMethodHolder<?, ?> holder : genericBeanObserverMethods.get(genericConfigurationType)) {
event.addObserverMethod(createGenericObserverMethod(holder.getObserverMethod(), genericConfiguration, holder.getMethod(), null, beanManager));
}
}
if (unwrapsMethods.containsKey(genericConfigurationType)) {
for (AnnotatedMethod<?> i : unwrapsMethods.get(genericConfigurationType)) {
AnnotatedMember<?> member = producerHolder.getMember();
Set<Annotation> unwrapsQualifiers = Beans.getQualifiers(beanManager, i.getAnnotations(), member.getAnnotations());
if (unwrapsQualifiers.isEmpty()) {
unwrapsQualifiers.add(DefaultLiteral.INSTANCE);
}
Set<Annotation> beanQualifiers = Beans.getQualifiers(beanManager, i.getDeclaringType().getAnnotations(), member.getAnnotations());
beanQualifiers.remove(AnyLiteral.INSTANCE);
if (beanQualifiers.isEmpty()) {
beanQualifiers.add(DefaultLiteral.INSTANCE);
}
beanQualifiers.remove(genericBeanQualifier);
event.addBean(new UnwrapsProducerBean(i, unwrapsQualifiers, beanQualifiers, beanManager));
}
}
// For each generic bean that uses this genericConfigurationType, register a generic bean for this generic configuration
for (BeanHolder<?> genericBeanHolder : genericBeans.get(genericConfigurationType)) {
// Register the generic bean, this is the underlying definition, with the synthetic qualifier
Class<? extends Annotation> scopeOverride = null;
if (genericBeanHolder.getType().isAnnotationPresent(ApplyScope.class)) {
scopeOverride = producerScope;
}
Bean<?> genericBean = createGenericBean(genericBeanHolder, genericConfiguration, beanManager, scopeOverride, alternative, javaClass);
event.addBean(genericBean);
}
}
}
Example 15
Project: errai-master File: IOCProcessor.java View source code |
private WiringElementType[] getWiringTypes(final MetaClass type, final Class<? extends Annotation> directScope) {
final List<WiringElementType> wiringTypes = new ArrayList<>();
wiringTypes.addAll(getWiringTypesForScopeAnnotation(directScope));
if (type.isAnnotationPresent(Alternative.class)) {
wiringTypes.add(WiringElementType.AlternativeBean);
}
if (isPublishableJsType(type)) {
wiringTypes.add(WiringElementType.JsType);
}
if (type.isAnnotationPresent(SharedSingleton.class)) {
wiringTypes.add(WiringElementType.SharedSingleton);
}
if (type.isAnnotationPresent(Specializes.class)) {
wiringTypes.add(WiringElementType.Specialization);
}
if (type.isAnnotationPresent(LoadAsync.class)) {
wiringTypes.add(WiringElementType.LoadAsync);
}
return wiringTypes.toArray(new WiringElementType[wiringTypes.size()]);
}
Example 16
Project: furnace-cdi-master File: BeanBuilder.java View source code |
/**
* <p>
* Read the {@link AnnotatedType}, creating a bean from the class and it's annotations.
* </p>
* <p/>
* <p>
* By default the bean lifecycle will wrap the result of calling
* {@link BeanManager#createInjectionTarget(AnnotatedType)}.
* </p>
* <p/>
* <p>
* {@link BeanBuilder} does <em>not</em> support reading members of the class to create producers or observer
* methods.
* </p>
*
* @param type the type to read
*/
public BeanBuilder<T> readFromType(AnnotatedType<T> type) {
this.beanClass = type.getJavaClass();
InjectionTarget<T> injectionTarget;
if (!type.getJavaClass().isInterface()) {
injectionTarget = beanManager.createInjectionTarget(type);
} else {
injectionTarget = new DummyInjectionTarget<>();
}
this.beanLifecycle = new DelegatingContextualLifecycle<>(injectionTarget);
this.injectionPoints = injectionTarget.getInjectionPoints();
this.qualifiers = new HashSet<>();
this.stereotypes = new HashSet<>();
this.types = new HashSet<>();
for (Annotation annotation : type.getAnnotations()) {
if (beanManager.isQualifier(annotation.annotationType())) {
this.qualifiers.add(annotation);
} else if (beanManager.isScope(annotation.annotationType())) {
this.scope = annotation.annotationType();
} else if (beanManager.isStereotype(annotation.annotationType())) {
this.stereotypes.add(annotation.annotationType());
}
if (annotation instanceof Named) {
this.name = ((Named) annotation).value();
}
if (annotation instanceof Alternative) {
this.alternative = true;
}
}
if (this.scope == null) {
this.scope = Dependent.class;
}
for (Class<?> c = type.getJavaClass(); c != Object.class && c != null; c = c.getSuperclass()) {
this.types.add(c);
}
for (Class<?> i : type.getJavaClass().getInterfaces()) {
this.types.add(i);
}
if (qualifiers.isEmpty()) {
qualifiers.add(DefaultLiteral.INSTANCE);
}
qualifiers.add(AnyLiteral.INSTANCE);
this.id = ImmutableBeanWrapper.class.getName() + ":" + Annotateds.createTypeId(type);
return this;
}
Example 17
Project: infinispan-master File: BeanBuilder.java View source code |
/**
* <p>
* Read the {@link AnnotatedType}, creating a bean from the class and it's
* annotations.
* </p>
* <p/>
* <p>
* By default the bean lifecycle will wrap the result of calling
* {@link BeanManager#createInjectionTarget(AnnotatedType)}.
* </p>
* <p/>
* <p>
* {@link BeanBuilder} does <em>not</em> support reading members of the class
* to create producers or observer methods.
* </p>
*
* @param type the type to read
*/
public BeanBuilder<T> readFromType(AnnotatedType<T> type) {
this.beanClass = type.getJavaClass();
InjectionTarget<T> injectionTarget;
if (!type.getJavaClass().isInterface()) {
injectionTarget = beanManager.createInjectionTarget(type);
} else {
injectionTarget = new DummyInjectionTarget<T>();
}
this.beanLifecycle = new DelegatingContextualLifecycle<T>(injectionTarget);
this.injectionPoints = injectionTarget.getInjectionPoints();
this.qualifiers = new HashSet<Annotation>();
this.stereotypes = new HashSet<Class<? extends Annotation>>();
for (Annotation annotation : type.getAnnotations()) {
if (beanManager.isQualifier(annotation.annotationType())) {
this.qualifiers.add(annotation);
} else if (beanManager.isScope(annotation.annotationType())) {
this.scope = annotation.annotationType();
} else if (beanManager.isStereotype(annotation.annotationType())) {
this.stereotypes.add(annotation.annotationType());
}
if (annotation instanceof Named) {
this.name = ((Named) annotation).value();
}
if (annotation instanceof Alternative) {
this.alternative = true;
}
}
if (this.scope == null) {
this.scope = Dependent.class;
}
for (Class<?> c = type.getJavaClass(); c != Object.class && c != null; c = c.getSuperclass()) {
this.types.add(c);
}
for (Class<?> i : type.getJavaClass().getInterfaces()) {
this.types.add(i);
}
if (qualifiers.isEmpty()) {
qualifiers.add(DefaultLiteral.INSTANCE);
}
qualifiers.add(AnyLiteral.INSTANCE);
this.id = ImmutableBean.class.getName() + ":" + Annotateds.createTypeId(type);
return this;
}
Example 18
Project: agorava-utils-master File: GenericBeanExtension.java View source code |
void createGenericBeans(@Observes AfterBeanDiscovery event, BeanManager beanManager) {
beanDiscoveryOver = true;
// For each generic configuration type, we iterate the generic configurations
for (Entry<GenericIdentifier, GenericConfigurationHolder> genericConfigurationEntry : genericConfigurationPoints.entrySet()) {
Class<? extends Annotation> producerScope = Dependent.class;
for (Annotation annotation : genericConfigurationEntry.getValue().getAnnotated().getAnnotations()) {
if (beanManager.isScope(annotation.annotationType())) {
producerScope = annotation.annotationType();
}
}
GenericConfigurationHolder genericConfigurationHolder = genericConfigurationEntry.getValue();
GenericIdentifier identifier = genericConfigurationEntry.getKey();
Class<? extends Annotation> genericConfigurationType = identifier.getAnnotationType();
if (!genericBeans.containsKey(genericConfigurationType)) {
throw new IllegalStateException("No generic bean definition exists for " + genericConfigurationType + ", but a generic producer does: " + genericConfigurationHolder.getAnnotated());
}
// Add a generic configuration bean for each generic configuration producer (allows us to inject the generic configuration annotation back into the generic bean)
event.addBean(createGenericConfigurationBean(beanManager, identifier));
// Register the GenericProduct bean
event.addBean(createGenericProductAnnotatedMemberBean(beanManager, identifier));
boolean alternative = genericConfigurationHolder.getAnnotated().isAnnotationPresent(Alternative.class);
Class<?> javaClass = genericConfigurationHolder.getJavaClass();
if (genericBeanProducerMethods.containsKey(genericConfigurationType)) {
for (ProducerMethodHolder<?, ?> holder : genericBeanProducerMethods.get(genericConfigurationType)) {
Class<? extends Annotation> scopeOverride = null;
if (holder.getProducerMethod().isAnnotationPresent(ApplyScope.class)) {
scopeOverride = producerScope;
}
event.addBean(createGenericProducerMethod(holder, identifier, beanManager, scopeOverride, alternative, javaClass));
}
}
if (genericBeanProducerFields.containsKey(genericConfigurationType)) {
for (FieldHolder<?, ?> holder : genericBeanProducerFields.get(genericConfigurationType)) {
Class<? extends Annotation> scopeOverride = null;
if (holder.getField().isAnnotationPresent(ApplyScope.class)) {
scopeOverride = producerScope;
}
event.addBean(createGenericProducerField(holder.getBean(), identifier, holder.getField(), beanManager, scopeOverride, alternative, javaClass));
}
}
if (genericBeanObserverMethods.containsKey(genericConfigurationType)) {
for (ObserverMethodHolder<?, ?> holder : genericBeanObserverMethods.get(genericConfigurationType)) {
event.addObserverMethod(createGenericObserverMethod(holder.getObserverMethod(), identifier, holder.getMethod(), null, beanManager));
}
}
if (unwrapsMethods.containsKey(genericConfigurationType)) {
for (AnnotatedMethod<?> i : unwrapsMethods.get(genericConfigurationType)) {
Annotated annotated = genericConfigurationHolder.getAnnotated();
Set<Annotation> unwrapsQualifiers = Beans.getQualifiers(beanManager, i.getAnnotations(), annotated.getAnnotations());
if (unwrapsQualifiers.isEmpty()) {
unwrapsQualifiers.add(DefaultLiteral.INSTANCE);
}
Set<Annotation> beanQualifiers = Beans.getQualifiers(beanManager, i.getDeclaringType().getAnnotations(), annotated.getAnnotations());
beanQualifiers.remove(AnyLiteral.INSTANCE);
if (beanQualifiers.isEmpty()) {
beanQualifiers.add(DefaultLiteral.INSTANCE);
}
beanQualifiers.remove(genericBeanQualifier);
event.addBean(new UnwrapsProducerBean(i, unwrapsQualifiers, beanQualifiers, beanManager));
}
}
// For each generic bean that uses this genericConfigurationType, register a generic bean for this generic configuration
for (BeanHolder<?> genericBeanHolder : genericBeans.get(genericConfigurationType)) {
// Register the generic bean, this is the underlying definition, with the synthetic qualifier
Class<? extends Annotation> scopeOverride = null;
if (genericBeanHolder.getType().isAnnotationPresent(ApplyScope.class)) {
scopeOverride = producerScope;
}
Bean<?> genericBean = createGenericBean(genericBeanHolder, identifier, beanManager, scopeOverride, alternative, javaClass);
event.addBean(genericBean);
}
}
}
Example 19
Project: core-master File: Validator.java View source code |
private boolean isAlternativeCandidate(Class<?> enabledClass, BeanManagerImpl beanManager) {
// <class> exists and is annotated with @Alternative or alternative stereotype
if (isAlternativeOrHasAlternativeStereotype(enabledClass, beanManager)) {
return true;
}
// Intentionally do not process the class hierarchy -
for (Method declaredMethod : AccessController.doPrivileged(new GetDeclaredMethodsAction(enabledClass))) {
if (declaredMethod.isAnnotationPresent(Produces.class) && isAlternativeOrHasAlternativeStereotype(declaredMethod, beanManager)) {
return true;
}
}
for (Field declaredField : AccessController.doPrivileged(new GetDeclaredFieldsAction(enabledClass))) {
if (declaredField.isAnnotationPresent(Produces.class) && isAlternativeOrHasAlternativeStereotype(declaredField, beanManager)) {
return true;
}
}
return false;
}
Example 20
Project: fsw-demo-master File: AlternativeLogger.java View source code |
@Override
public void logMessage(String message) {
System.out.println("Alternative: " + message);
}
Example 21
Project: javaee7-samples-master File: ProducerMethodGreeting.java View source code |
@Produces
@Alternative
public Greeting getGreeting() {
return new SimpleGreeting();
}
Example 22
Project: JavaIncrementalParser-master File: ProducerMethodGreeting.java View source code |
@Produces
@Alternative
public Greeting getGreeting() {
return new SimpleGreeting();
}
Example 23
Project: cdi-tck-master File: BarProducer.java View source code |
@Alternative
@Produces
@Tame
public Bar produceTameBar() {
return new Bar();
}
Example 24
Project: compatibility-master File: BarAlternative.java View source code |
@Override
public String ping() {
return super.ping() + "Alternative";
}
Example 25
Project: kie-wb-common-master File: TestAppSetup.java View source code |
@Produces
@Alternative
public M2RepoService m2RepoService() {
return mock(M2RepoService.class);
}
Example 26
Project: jbosstools-javaee-master File: CatProducer.java View source code |
@Produces
@Tame
@Alternative
public Cat produce() {
return cat;
}
Example 27
Project: glassfish-master File: TestAlternativeBeanInWebInfLib.java View source code |
@Override
public String testInjection() {
ALTERNATIVE_BEAN_HAS_BEEN_CALLED = true;
System.out.println("*************** testinjection in alternative bean in web-inf/lib called");
return "Alternative";
}
Example 28
Project: cdi-master File: AnnotationLiteralTest.java View source code |
@SuppressWarnings("serial") @Test public void testAlternativeLiteral() { assertEquals(new AnnotationLiteral<Alternative>() { }, Alternative.Literal.INSTANCE); }
Example 29
Project: spring-data-redis-master File: CdiBean.java View source code |
/*
* (non-Javadoc)
* @see javax.enterprise.inject.spi.Bean#isAlternative()
*/
public boolean isAlternative() {
return beanClass.isAnnotationPresent(Alternative.class);
}
Example 30
Project: cdi-unit-master File: WeldTestUrlDeployment.java View source code |
private boolean isAlternativeStereotype(Class<?> c) {
return c.isAnnotationPresent(Stereotype.class) && c.isAnnotationPresent(Alternative.class);
}
Example 31
Project: spring-data-commons-master File: CdiRepositoryBean.java View source code |
/*
* (non-Javadoc)
* @see javax.enterprise.inject.spi.Bean#isAlternative()
*/
public boolean isAlternative() {
return repositoryType.isAnnotationPresent(Alternative.class);
}