javax.enterprise.inject.spi.WithAnnotations Java Examples

/**
 * Scans all annotated types with the {@link Aggregate} annotation and
 * collects them for registration.
 *
 * @param processAnnotatedType annotated type processing event.
 */
// Mark: All I need to do here is look up what the aggregate classes are
// and what the value of the @Aggregate annotation is. This feels a little
// overkill. That said, currently I do need these values in afterBeanDiscovery
// and this might be the most efficient way of collecting these anyway.
// Other than being a bit ugly, this is not anything that is causing any
// functional issues.
<T> void processAggregate(@Observes @WithAnnotations({Aggregate.class})
        final ProcessAnnotatedType<T> processAnnotatedType) {
    // TODO Aggregate classes may need to be vetoed so that CDI does not
    // actually try to manage them.
    
    final Class<?> clazz = processAnnotatedType.getAnnotatedType().getJavaClass();

    logger.debug("Found aggregate: {}.", clazz);

    aggregates.add(new AggregateDefinition(clazz));
}
 

private <X> void findAnnotatedInterfaces(@Observes @WithAnnotations({ Counted.class, Gauge.class, Metered.class,
        SimplyTimed.class, Timed.class, ConcurrentGauge.class }) ProcessAnnotatedType<X> pat) {
    Class<X> clazz = pat.getAnnotatedType().getJavaClass();
    Package pack = clazz.getPackage();
    if (pack != null && pack.getName().equals(GaugeRegistrationInterceptor.class.getPackage().getName())) {
        return;
    }
    if (clazz.isInterface()) {
        // All declared metrics of an annotated interface are registered during AfterDeploymentValidation
        metricsInterfaces.add(clazz);
    }
}
 

public <T> void observeProviders(@WithAnnotations({ Provider.class }) @Observes ProcessAnnotatedType<T> event) {
    AnnotatedType<T> annotatedType = event.getAnnotatedType();

    if (!annotatedType.getJavaClass().isInterface()) {
        this.providers.add(annotatedType.getJavaClass());
    }
}
 

public <T> void observeResources(@WithAnnotations({ Path.class }) @Observes ProcessAnnotatedType<T> event) {
    AnnotatedType<T> annotatedType = event.getAnnotatedType();

    if (!annotatedType.getJavaClass().isInterface()) {
        this.resources.add(annotatedType.getJavaClass());
    }
}
 

public void findClients(@Observes @WithAnnotations({RegisterRestClient.class}) ProcessAnnotatedType<?> pat) {
    Class<?> restClient = pat.getAnnotatedType().getJavaClass();
    if (restClient.isInterface()) {
        restClientClasses.add(restClient);
        pat.veto();
    } else {
        errors.add(new IllegalArgumentException("The class " + restClient
                + " is not an interface"));
    }
}
 

<T> void processAnnotatedType(@Observes @WithAnnotations({EnableEurekaClient.class}) ProcessAnnotatedType<T> pat) {
   
   LOGGER.config(() -> "Found @EnableEurekaClient annotated class: " + pat.getAnnotatedType().getJavaClass().getName());
   eurekaEnabled = true;
   applicationName = pat.getAnnotatedType().getAnnotation(EnableEurekaClient.class).name();
   LOGGER.config(() -> "Eureka application name is: " + applicationName);
}
 

<T> void processAnnotatedType(@Observes @WithAnnotations(EnableSnoopClient.class) ProcessAnnotatedType<T> pat) {

        // workaround for WELD bug revealed by JDK8u60
        final ProcessAnnotatedType<T> snoopAnnotated = pat;

        LOGGER.config(() -> "Found @EnableSnoopClient annotated class: " + snoopAnnotated.getAnnotatedType().getJavaClass().getName());
        snoopEnabled = true;
        serviceName = snoopAnnotated.getAnnotatedType().getAnnotation(EnableSnoopClient.class).serviceName();
        LOGGER.config(() -> "Snoop Service name is: " + serviceName);
    }
 

void processAuthenticationMechanismDefinitions(@Observes
                                               @WithAnnotations({
                                                       BasicAuthenticationMechanismDefinition.class,
                                                       FormAuthenticationMechanismDefinition.class
                                               }) final ProcessAnnotatedType<?> processAnnotatedType) {
    final AnnotatedType<?> annotatedType = processAnnotatedType.getAnnotatedType();

    if (annotatedType.isAnnotationPresent(BasicAuthenticationMechanismDefinition.class)) {
        basicAuthentication.add(annotatedType);
    }

    if (annotatedType.isAnnotationPresent(FormAuthenticationMechanismDefinition.class)) {
        formAuthentication.add(annotatedType);
    }
}
 

public void registerGraphQlClientApis(@Observes @WithAnnotations(GraphQlClientApi.class) ProcessAnnotatedType<?> type) {
    Class<?> javaClass = type.getAnnotatedType().getJavaClass();
    if (javaClass.isInterface()) {
        log.info("register {}", javaClass.getName());
        apis.add(javaClass);
    } else {
        log.error("failed to register", new IllegalArgumentException(
                "a GraphQlClientApi must be an interface: " + javaClass.getName()));
    }
}
 

void findServiceInterfaces(@Observes @WithAnnotations(ProxyGen.class) ProcessAnnotatedType<?> event, BeanManager beanManager) {
    AnnotatedType<?> annotatedType = event.getAnnotatedType();
    if (annotatedType.isAnnotationPresent(ProxyGen.class) && annotatedType.getJavaClass().isInterface()) {
        LOGGER.debug("Service interface {0} discovered", annotatedType.getJavaClass());
        serviceInterfaces.add(annotatedType.getJavaClass());
    }
}
 

<T> void excludeBeans(@Observes @WithAnnotations({Scope.class, NormalScope.class}) ProcessAnnotatedType<T> pat) {

        if (excludedBeanClasses.contains(pat.getAnnotatedType().getJavaClass())) {
            pat.veto();
            return;
        }

        Set<Type> typeClosure = pat.getAnnotatedType().getTypeClosure();
        for (Type excludedBeanType : excludedBeanTypes) {
            if (typeClosure.contains(excludedBeanType)) {
                pat.veto();
                return;
            }
        }
    }
 

<T> void processSaga(@Observes @WithAnnotations({Saga.class})
        final ProcessAnnotatedType<T> processAnnotatedType) {
    // TODO Saga classes may need to be vetoed so that CDI does not
    // actually try to manage them.        
    
    final Class<?> clazz = processAnnotatedType.getAnnotatedType().getJavaClass();

    logger.debug("Found saga: {}.", clazz);

    sagas.add(new SagaDefinition(clazz));
}
 

private <X> void applyMetricsBinding(@Observes @WithAnnotations({ Gauge.class }) ProcessAnnotatedType<X> pat) {
    Class<X> clazz = pat.getAnnotatedType().getJavaClass();
    Package pack = clazz.getPackage();
    if (pack == null || !pack.getName().equals(GaugeRegistrationInterceptor.class.getPackage().getName())) {
        if (!clazz.isInterface()) {
            AnnotatedTypeDecorator newPAT = new AnnotatedTypeDecorator<>(pat.getAnnotatedType(), METRICS_BINDING);
            pat.setAnnotatedType(newPAT);
        }
    }

}
 

public void findWebSocketServers(@Observes @WithAnnotations(ServerEndpoint.class)ProcessAnnotatedType<?> pat) {
    endpointClasses.add(pat.getAnnotatedType().getJavaClass());
}
 

public void findFilters(@Observes @WithAnnotations({WebFilter.class})
                                  ProcessAnnotatedType<? extends Filter> pat) {
    filters.add(pat.getAnnotatedType().getJavaClass());
}
 

private <X> void metricsAnnotations(@Observes @WithAnnotations({CachedGauge.class, Counted.class, ExceptionMetered.class, Gauge.class, Metered.class, Timed.class}) ProcessAnnotatedType<X> pat) {
    pat.setAnnotatedType(new AnnotatedTypeDecorator<>(pat.getAnnotatedType(), METRICS_BINDING));
}
 

public void findServlets(@Observes @WithAnnotations({WebServlet.class})
                                  ProcessAnnotatedType<? extends HttpServlet> pat) {
    servlets.add(pat.getAnnotatedType().getJavaClass());
}
 

public void findListeners(@Observes @WithAnnotations({WebListener.class})
                          ProcessAnnotatedType<? extends ServletContextListener> pat) {
    listeners.add(pat.getAnnotatedType().getJavaClass());
}
 

void collectEntities(@Observes @WithAnnotations({Entity.class, MappedSuperclass.class, Embeddable.class}) final ProcessAnnotatedType<?> jpa) {
    jpaClasses.add(jpa.getAnnotatedType().getJavaClass().getName());
}
 

<T> void addJpaToEmConsumers(@Observes @WithAnnotations(Unit.class) final ProcessAnnotatedType<T> pat) {
    if (pat.getAnnotatedType().isAnnotationPresent(Jpa.class)) {
        return;
    }
    pat.setAnnotatedType(new AutoJpaAnnotationType<T>(pat.getAnnotatedType()));
}
 

/**
 * For any {@link AnnotatedType} that includes a {@link Context} injection point, this method replaces
 * the field with the following code:
 * <pre>
 *     @Inject @ContextResolved T field;
 * </pre>
 * For any usage of T that is a valid context object in JAX-RS.
 *
 * It also has a side effect of capturing the context object type, in case no
 * {@link org.apache.cxf.jaxrs.ext.ContextClassProvider} was registered for the type.
 *
 * @param processAnnotatedType the annotated type being investigated
 * @param <X> the generic type of that processAnnotatedType
 */
public <X> void convertContextsToCdi(@Observes @WithAnnotations({Context.class})
                                         ProcessAnnotatedType<X> processAnnotatedType) {
    AnnotatedType<X> annotatedType = processAnnotatedType.getAnnotatedType();
    DelegateContextAnnotatedType<X> type = new DelegateContextAnnotatedType<>(annotatedType);
    contextTypes.addAll(type.getContextFieldTypes());
    processAnnotatedType.setAnnotatedType(type);
}
 

/**
 * Replaces the meta data of the {@link ProcessAnnotatedType}.
 * 
 * <p>
 * The ProcessAnnotatedType's meta data will be replaced, if the annotated type has one of the following annotations:
 * <ul>
 * <li> {@link Stateless}
 * <li> {@link MessageDriven}
 * <li> {@link Interceptor}
 * <li> {@link Singleton}
 * </ul>
 *
 * @param <X> the type of the ProcessAnnotatedType
 * @param pat the annotated type representing the class being processed
 */
public <X> void processInjectionTarget(@Observes @WithAnnotations({Stateless.class, MessageDriven.class, Interceptor.class, Singleton.class}) ProcessAnnotatedType<X> pat) {
    if (pat.getAnnotatedType().isAnnotationPresent(Stateless.class) || pat.getAnnotatedType().isAnnotationPresent(MessageDriven.class)) {
        modifiyAnnotatedTypeMetadata(pat);
    } else if (pat.getAnnotatedType().isAnnotationPresent(Interceptor.class)) {
        processInterceptorDependencies(pat);
    } else if(pat.getAnnotatedType().isAnnotationPresent(Singleton.class)) {
        addApplicationScopedAndTransactionalToSingleton(pat);
    }
}