Java AnnotatedType.getJavaClass方法代码示例

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
<T> void findJobs( @Observes @WithAnnotations({Cron.class}) ProcessAnnotatedType<T> pat, BeanManager beanManager )
{
    // Ensure we are named otherwise job won't fire as we can't locate it
    AnnotatedType<?> type = pat.getAnnotatedType();
    Class<?> clazz = type.getJavaClass();
    CDIUtils.addTypeAnnotation( pat, Named.class, () -> new NamedImpl( "Schedule_" + (id++) ) );

    if( type.isAnnotationPresent( Cron.class ) ) {
        if( Job.class.isAssignableFrom( clazz ) ) {
            jobClasses.add( clazz );
        }
        else {
            throw new UnsupportedOperationException( "@Cron on type must implement Job" );
        }
    }
    else {
        for( AnnotatedMethod<?> meth: type.getMethods() ) {
            if( meth.isAnnotationPresent( Cron.class ) ) {
                jobClasses.add( clazz );
            }
        }
    }
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
/**
 * Instantiates <em>unmanaged instances</em> of HealthCheckProcedure and
 * handle manually their CDI creation lifecycle.
 * Add them to the {@link Monitor}.
 */
private void afterDeploymentValidation(@Observes final AfterDeploymentValidation abd, BeanManager beanManager) {
    try {
        for (AnnotatedType delegate : delegates) {
            Unmanaged<HealthCheck> unmanagedHealthCheck = new Unmanaged<HealthCheck>(beanManager, delegate.getJavaClass());
            Unmanaged.UnmanagedInstance<HealthCheck> healthCheckInstance = unmanagedHealthCheck.newInstance();
            HealthCheck healthCheck =  healthCheckInstance.produce().inject().postConstruct().get();
            healthChecks.add(healthCheck);
            healthCheckInstances.add(healthCheckInstance);

            monitor.registerHealthBean(healthCheck);

            log.info(">> Added health bean impl " + healthCheck);
        }

        // we don't need the references anymore
        delegates.clear();

    } catch (Exception e) {
        throw new RuntimeException("Failed to register health bean", e);
    }
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
/**
 * Discover all classes that implements HealthCheckProcedure
 */
public void observeResources(@Observes @WithAnnotations({Health.class})  ProcessAnnotatedType<? extends HealthCheck> event) {
   AnnotatedType<? extends HealthCheck> annotatedType = event.getAnnotatedType();
   Class<? extends HealthCheck> javaClass = annotatedType.getJavaClass();
   MicroProfileHealthLogger.ROOT_LOGGER.debugf("Discovered health check procedure %s", javaClass);
   delegates.add(annotatedType);
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
/**
 * Instantiates <em>unmanaged instances</em> of HealthCheckProcedure and
 * handle manually their CDI creation lifecycle.
 * Add them to the {@link HealthMonitor}.
 */
private void afterDeploymentValidation(@Observes final AfterDeploymentValidation avd, BeanManager bm) {
   for (AnnotatedType delegate : delegates) {
      try {
         Unmanaged<HealthCheck> unmanagedHealthCheck = new Unmanaged<HealthCheck>(bm, delegate.getJavaClass());
         UnmanagedInstance<HealthCheck> healthCheckInstance = unmanagedHealthCheck.newInstance();
         HealthCheck healthCheck =  healthCheckInstance.produce().inject().postConstruct().get();
         healthChecks.add(healthCheck);
         healthCheckInstances.add(healthCheckInstance);
         healthMonitor.addHealthCheck(healthCheck);
      } catch (Exception e) {
         throw new RuntimeException("Failed to register health bean", e);
      }
   }
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
/**
 * For each method in a type that has a specific annotation pass the class and method to a consumer
 *
 * @param <T>
 * @param pat
 * @param annotationType
 * @param c
 */
public static <T> void forEachMethod( ProcessAnnotatedType<T> pat, Class<? extends Annotation> annotationType,
                                      BiConsumer<Class<?>, ? super AnnotatedMethod<? extends Object>> c )
{
    AnnotatedType<?> type = pat.getAnnotatedType();
    Class<?> clazz = type.getJavaClass();
    type.getMethods()
            .stream().
            filter( meth -> meth.isAnnotationPresent( annotationType ) ).
            forEach( m -> c.accept( clazz, m ) );
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
public <T> void observeResources(@Observes @WithAnnotations({Health.class}) ProcessAnnotatedType<T> event) {

        AnnotatedType<T> annotatedType = event.getAnnotatedType();
        Class<T> javaClass = annotatedType.getJavaClass();
        for (Class<?> intf : javaClass.getInterfaces()) {
            if (intf.getName().equals(HealthCheck.class.getName())) {
                log.info(">> Discovered health check procedure " + javaClass);
                delegates.add(annotatedType);
            }
        }
    }
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
<X> void processAnnotatedType(@Observes final javax.enterprise.inject.spi.ProcessAnnotatedType<X> pat,
                              BeanManager beanManager) {
    if (isHttpRequestSupportAvailable) {

        final AnnotatedType<X> annotatedType = pat.getAnnotatedType();
        final Class<X> javaClass = annotatedType.getJavaClass();

        if (javaClass != null && javaClass.getName().equals(HttpRequestProducer.class.getName())) {
            pat.veto();
        }
    }
    return;
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
public void annotates(@Observes ProcessAnnotatedType pat) {
	AnnotatedType annotatedType = pat.getAnnotatedType();
	Class type = annotatedType.getJavaClass();
	
	// verify if it has Controller in its name
	if(type.getSimpleName().endsWith("Controller")) {
		pat.setAnnotatedType(new AnnotatedTypeControllerWrapper(annotatedType));
		System.out.println("[CDI Extension] Controller found: " + type.getSimpleName());
	}
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
public <X> void processAnnotatedTypes(@Observes ProcessAnnotatedType<X> pat) {
    AnnotatedType<X> type = pat.getAnnotatedType();
    final Class<X> javaClass = type.getJavaClass();
    if (javaClass.isAnnotationPresent(ActivatableTestImplementation.class)) {
        new ActivatableAlternativeBuilder<X>(pat).invoke();
    } else if (ReflectionsUtils.isTestClass(javaClass)) {
        AnnotationUtils.addClassAnnotation(pat, new AnnotationLiteral<TestSuiteScoped>() {
        });
    } else if (ReflectionsUtils.shouldProxyCdiType(javaClass)) {
        AnnotationUtils.addClassAnnotation(pat, new AnnotationLiteral<Replaceable>() {
        });
    }
    updateDecoratedTypes(pat);
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
public static HandlerInfo eventHandler(final BeanManager bm, final AnnotatedType<?> annotated) {
	return new HandlerInfo(annotated.getJavaClass(), CdiUtils.qualifiers(bm, annotated), true);
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
public static HandlerInfo commandHandler(final BeanManager bm, final AnnotatedType<?> annotated) {
	return new HandlerInfo(annotated.getJavaClass(), CdiUtils.qualifiers(bm, annotated), false);
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
public static SagaInfo of(final BeanManager bm, AnnotatedType<?> annotated) {
	Map<QualifierType, Set<Annotation>> qualifiers = extractQualifiers(bm, annotated);
	return new SagaInfo(annotated.getJavaClass(), qualifiers);
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
public static AggregateRootInfo of(final BeanManager bm, final AnnotatedType<?> annotated) {
	Map<QualifierType, Set<Annotation>> qualifiers = extractQualifiers(bm, annotated);
	return new AggregateRootInfo(annotated.getJavaClass(), qualifiers);
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
private <X> boolean isVetoed(AnnotatedType<X> annotated)
{
    Class<X> javaClass = annotated.getJavaClass();
    return javaClass.equals(AbstractEntityRepository.class) ||
           javaClass.equals(AbstractFullEntityRepository.class);
}
 

import javax.enterprise.inject.spi.AnnotatedType; //导入方法依赖的package包/类
private String createDefaultBeanName(AnnotatedType<T> type)
{
    Class<T> javaClass = type.getJavaClass();
    return Introspector.decapitalize(javaClass.getSimpleName());
}