protected <Z extends Annotation> Z getAnnotation( Class<Z> annotationType, AnnotatedMethod<?> apiMethod, AnnotatedType<?> apiClass, AnnotatedMethod<?> implementationMethod, AnnotatedType<?> implementationClass) { Z annotation = null; if (apiMethod != null) { annotation = apiMethod.getAnnotation(annotationType); } if (annotation == null && apiClass != null) { annotation = apiClass.getAnnotation(annotationType); } if ((annotation == null) && (implementationMethod != null)) { annotation = implementationMethod.getAnnotation(annotationType); } if ((annotation == null) && (implementationClass != null)) { annotation = implementationClass.getAnnotation(annotationType); } return annotation; }
@Override public ConfigProgram introspectType(AnnotatedType<?> type) { for (Class<?> parentClass = type.getJavaClass().getSuperclass(); parentClass != null; parentClass = parentClass.getSuperclass()) { Resources resources = parentClass.getAnnotation(Resources.class); if (resources != null) { for (Resource resource : resources.value()) { introspectClass(getClass().getName(), resource); } } Resource resource = parentClass.getAnnotation(Resource.class); if (resource != null) introspectClass(getClass().getName(), resource); } Resources resources = type.getAnnotation(Resources.class); if (resources != null) { for (Resource resource : resources.value()) { introspectClass(getClass().getName(), resource); } } Resource resource = type.getAnnotation(Resource.class); if (resource != null) introspectClass(getClass().getName(), resource); return new NullProgram(); }
protected <Z extends Annotation> Z getAnnotation( Class<Z> annotationType, AnnotatedType<?> apiClass, AnnotatedType<?> implClass) { Z annotation = null; if (apiClass != null) annotation = apiClass.getAnnotation(annotationType); if ((annotation == null) && (implClass != null)) { annotation = implClass.getAnnotation(annotationType); } return annotation; }
<T, X> void registerGenericBeanObserverMethod(@Observes ProcessObserverMethod<T, X> event) { AnnotatedType<X> declaringType = event.getAnnotatedMethod().getDeclaringType(); if (declaringType.isAnnotationPresent(GenericConfiguration.class)) { AnnotatedMethod<X> method = event.getAnnotatedMethod(); Class<? extends Annotation> genericConfigurationType = declaringType.getAnnotation(GenericConfiguration.class).value(); genericBeanObserverMethods.put( genericConfigurationType, new ObserverMethodHolder<X, T>(method, event.getObserverMethod())); } }
<X> void processType(@Observes ProcessAnnotatedType<X> event) { AnnotatedType<X> original = event.getAnnotatedType(); if (original.isAnnotationPresent(ManagedBean.class) && !original.isAnnotationPresent(Named.class)) { AnnotatedType<X> modified = new AnnotatedTypeBuilder<X>() .readFromType(event.getAnnotatedType(), true) .addToClass(new NamedLiteral(original.getAnnotation(ManagedBean.class).value())) .create(); event.setAnnotatedType(modified); } }
<X, T> void registerGenericBeanProducerMethod(@Observes ProcessProducerMethod<X, T> event) { AnnotatedType<X> declaringType = event.getAnnotatedProducerMethod().getDeclaringType(); Annotation genericConfiguration = getGenericConfiguration(event.getAnnotated()); if (declaringType.isAnnotationPresent(GenericConfiguration.class)) { genericBeanProducerMethods.put( declaringType.getAnnotation(GenericConfiguration.class).value(), getProducerMethodHolder(event)); } else if (genericConfiguration != null) { if (validateGenericProducer( genericConfiguration, event.getBean(), event.getAnnotatedProducerMethod())) { genericProducerBeans.put(event.getAnnotatedProducerMethod(), event.getBean()); } } }
<X> void registerGenericBean(@Observes ProcessManagedBean<X> event) { AnnotatedType<X> type = event.getAnnotatedBeanClass(); if (type.isAnnotationPresent(GenericConfiguration.class)) { Class<? extends Annotation> genericType = type.getAnnotation(GenericConfiguration.class).value(); genericBeans.put( genericType, new BeanHolder<X>(event.getAnnotatedBeanClass(), event.getBean())); for (AnnotatedMethod<? super X> m : event.getAnnotatedBeanClass().getMethods()) { if (m.isAnnotationPresent(Unwraps.class)) { unwrapsMethods.put(genericType, m); } } } }
<X, T> void registerGenericBeanProducerField(@Observes ProcessProducerField<X, T> event) { AnnotatedType<X> declaringType = event.getAnnotatedProducerField().getDeclaringType(); Annotation genericConfiguration = getGenericConfiguration(event.getAnnotated()); if (declaringType.isAnnotationPresent(GenericConfiguration.class)) { AnnotatedField<X> field = event.getAnnotatedProducerField(); Class<? extends Annotation> genericConfigurationType = declaringType.getAnnotation(GenericConfiguration.class).value(); genericBeanProducerFields.put( genericConfigurationType, new FieldHolder<X, T>(field, event.getBean())); } else if (genericConfiguration != null) { if (validateGenericProducer( genericConfiguration, event.getBean(), event.getAnnotatedProducerField())) { genericProducerBeans.put(event.getAnnotatedProducerField(), event.getBean()); } } }
@Override public ConfigProgram introspectType(AnnotatedType<?> type) { PersistenceContext pContext = type.getAnnotation(PersistenceContext.class); String location = type.getJavaClass().getName() + ": "; String jndiName = null; if (!"".equals(pContext.name())) jndiName = pContext.name(); Bean<?> bean = bindEntityManager(location, pContext); BeanValueGenerator gen = new BeanValueGenerator(location, bean); if (jndiName != null) bindJndi(jndiName, gen, null); return new NullProgram(); }
<X> void replaceInjectOnGenericBeans(@Observes ProcessAnnotatedType<X> event) { AnnotatedType<X> type = event.getAnnotatedType(); if (type.isAnnotationPresent(GenericConfiguration.class)) { final Class<? extends Annotation> genericConfigurationType = type.getAnnotation(GenericConfiguration.class).value(); // validate that the configuration type is annotated correctly if (!genericConfigurationType.isAnnotationPresent(GenericType.class)) { errors.add( "Bean " + type.getJavaClass().getName() + " specifies generic annotation " + type.getAnnotation(GenericConfiguration.class) + " however " + genericConfigurationType + " is not annotated @GenericConfiguration."); } else { Class<?> configType = genericConfigurationType.getAnnotation(GenericType.class).value(); if (configType.isAnnotationPresent(GenericConfiguration.class)) { errors.add( "Generic configuration type " + genericConfigurationType + " specifies a value() of " + configType + " however " + configType + " is a generic bean. Generic configuration types may not be generic beans"); } } final AnnotatedTypeBuilder<X> builder = new AnnotatedTypeBuilder<X>().readFromType(type); builder.addToClass(genericBeanQualifier); builder.redefine( Inject.class, new AnnotationRedefiner<Inject>() { public void redefine(RedefinitionContext<Inject> ctx) { if (ctx.getAnnotatedElement() instanceof Field) { if (ctx.getAnnotatedElement().isAnnotationPresent(Generic.class)) { // This is a Generic bean injection point ctx.getAnnotationBuilder() .remove(Inject.class) .add(InjectGenericLiteral.INSTANCE); } } } }); builder.redefine( Produces.class, new AnnotationRedefiner<Produces>() { public void redefine(RedefinitionContext<Produces> ctx) { // Add the marker qualifier ctx.getAnnotationBuilder() .add(GenericMarkerLiteral.INSTANCE) .add(genericBeanQualifier); } }); builder.redefine( Disposes.class, new AnnotationRedefiner<Disposes>() { public void redefine(RedefinitionContext<Disposes> ctx) { // Add the marker qualifier ctx.getAnnotationBuilder() .add(GenericMarkerLiteral.INSTANCE) .add(genericBeanQualifier); } }); builder.redefine( Generic.class, new AnnotationRedefiner<Generic>() { public void redefine(RedefinitionContext<Generic> ctx) { // if it is a parameter annotation if (!(ctx.getAnnotatedElement() instanceof AccessibleObject)) { // stick an InjectGeneric as a marker. ctx.getAnnotationBuilder().remove(Generic.class).add(InjectGenericLiteral.INSTANCE); if (ctx.getRawType().isAnnotationPresent(GenericConfiguration.class)) { ctx.getAnnotationBuilder().add(genericBeanQualifier); } } } }); event.setAnnotatedType(builder.create()); } }