Java ProcessAnnotatedType.veto方法代碼示例

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
@SuppressWarnings("unused")
// will be called automatically by the CDI container for all annotated types
private void skipUnusedStepsFromBeanDiscovery(@Observes ProcessAnnotatedType<?> event, BeanManager beanManager)
    throws MojoExecutionException, MojoFailureException {
  // https://github.com/shillner/maven-cdi-plugin-utils/issues/14
  Class<?> type = event.getAnnotatedType().getJavaClass();
  ProcessingStep annotation = type.getAnnotation(ProcessingStep.class);
  if (annotation != null) {
    // adding the step to the list of all available processing steps
    String id = annotation.id();
    Preconditions.checkState(!this.allAvailableProcessingSteps.containsKey(id),
        "The processing step id '" + id + "' is not unique!");
    this.allAvailableProcessingSteps.put(id, annotation);

    // vetoing the bean discovery of a step that is not part of the current workflow
    // this prevents the issue that data shall be injected that isn't produced anywhere!
    ProcessingWorkflow workflow = getWorkflow();
    if (!workflow.containsStep(annotation.id())) {
      event.veto();
    }
  }
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
private void processAnnotatedType(@Observes ProcessAnnotatedType<?> pat) {
    if (pat.getAnnotatedType().isAnnotationPresent(Vetoed.class)) {
        pat.veto();
    }
    if (hasAnnotation(pat.getAnnotatedType(), Converter.class)) {
        converters.add(pat.getAnnotatedType().getJavaClass());
    }
    if (hasAnnotation(pat.getAnnotatedType(), BeanInject.class, Consume.class, EndpointInject.class, Produce.class, PropertyInject.class)) {
        camelBeans.add(pat.getAnnotatedType());
    }
    if (hasAnnotation(pat.getAnnotatedType(), Consume.class)) {
        eagerBeans.add(pat.getAnnotatedType());
    }
    if (hasAnnotation(pat.getAnnotatedType(), ImportResource.class)) {
        resources.add(pat.getAnnotatedType().getAnnotation(ImportResource.class));
    }
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
<X> void processAggregateRootAnnotatedType(
		@Observes final ProcessAnnotatedType<X> pat, final BeanManager beanManager) {
	AnnotatedType<X> at = pat.getAnnotatedType();
	boolean isAggregateRoot = AxonUtils.isAnnotatedAggregateRoot(at.getJavaClass());
	if (isAggregateRoot) {
		configuration.add(AggregateRootInfo.of(beanManager, at));
		pat.veto();
	}

}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
/**
 * CDI observer method, listens to the {@link ProcessAnnotatedType} event to apply a veto to all JPA entities.
 * @param pat Payload of the bootstrap event.
 */
public void vetoEnties(@Observes ProcessAnnotatedType pat) {
    // Look to see if the AnnotatedType also contains the JPA Entity annotation
    if (pat.getAnnotatedType().getAnnotation(Entity.class) != null) {
        // Veto the JPA entity to avoid developers injecting entities without allowing JPA to
        // manage the entity lifecycle.
        pat.veto();
        log.info("Vetoed class " + pat.getAnnotatedType().getJavaClass());
    }
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
public <T> void processStandaloneController(@WithAnnotations({StandaloneController.class}) @Observes ProcessAnnotatedType<T> event) {
    LOGGER.info("Processing standalone controller class: {}", event.getAnnotatedType().getJavaClass());
    StandaloneController a = event.getAnnotatedType().getJavaClass().getAnnotation(StandaloneController.class);
    if (a != null && ControllerUtils.useEmbeddedController()) {
        LOGGER.info("Removing standalone controller class {} from CDI context", event.getAnnotatedType().getJavaClass());
        event.veto();
    }
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
public <T> void processEmbeddedController(@WithAnnotations({EmbeddedController.class}) @Observes ProcessAnnotatedType<T> event) {
    LOGGER.info("Processing embedded controller class: {}", event.getAnnotatedType().getJavaClass());
    EmbeddedController a = event.getAnnotatedType().getJavaClass().getAnnotation(EmbeddedController.class);
    if (a != null && ControllerUtils.useEmbeddedController() == false) {
        LOGGER.info("Removing embedded controller class {} from CDI context", event.getAnnotatedType().getJavaClass());
        event.veto();
    }
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
@SuppressWarnings("unchecked")
<X> void processAnnotatedType(@Observes ProcessAnnotatedType<X> event)
{
    if (!isActivated)
    {
        return;
    }

    if (isVetoed(event.getAnnotatedType()))
    {
        event.veto();
    }
    else if (isRepository(event.getAnnotatedType()))
    {
        Class<X> repositoryClass = event.getAnnotatedType().getJavaClass();

        LOG.log(Level.FINER, "getHandlerClass: Repository annotation detected on {0}",
                event.getAnnotatedType());
        if (Deactivatable.class.isAssignableFrom(repositoryClass)
                && !ClassDeactivationUtils.isActivated((Class<? extends Deactivatable>) repositoryClass))
        {
            LOG.log(Level.FINER, "Class {0} is Deactivated", repositoryClass);
            return;
        }

        repositoryClasses.add(repositoryClass);
        REPOSITORY_CLASSES.add(repositoryClass);
    }
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
public <X> void findScheduledJobs(@Observes ProcessAnnotatedType<X> pat, BeanManager beanManager)
{
    if (!this.isActivated)
    {
        return;
    }

    Class<X> beanClass = pat.getAnnotatedType().getJavaClass();

    //see SchedulerProducer
    if (Scheduler.class.isAssignableFrom(beanClass) || isInternalUnmanagedClass(beanClass))
    {
        pat.veto();
        return;
    }

    if (!jobClass.isAssignableFrom(beanClass) && !Runnable.class.isAssignableFrom(beanClass))
    {
        return;
    }

    Scheduled scheduled = pat.getAnnotatedType().getAnnotation(Scheduled.class);
    if (scheduled != null && scheduled.onStartup())
    {
        this.foundManagedJobClasses.add(beanClass);
    }
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
protected void vetoCustomProjectStageBeans(ProcessAnnotatedType processAnnotatedType)
{
    //currently there is a veto for all project-stage implementations,
    //but we still need @Typed() for the provided implementations in case of the deactivation of this behaviour
    if (ProjectStage.class.isAssignableFrom(processAnnotatedType.getAnnotatedType().getJavaClass()))
    {
        processAnnotatedType.veto();
    }
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
public void vetoFurnaceProducer(@Observes ProcessAnnotatedType<FurnaceProducer> furnaceProducer) {
    furnaceProducer.veto();
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
public void vetoFurnaceServiceProducer(@Observes ProcessAnnotatedType<FurnaceServiceProducer> furnaceServiceProducer) {
    furnaceServiceProducer.veto();
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
public void vetoProbeHandlers(@Observes ProcessAnnotatedType<? extends Handler<RoutingContext>> event) {
    if (event.getAnnotatedType().getJavaClass().getName().startsWith(PROBE_PACKAGE)) {
        event.veto();
    }
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
public void vetoFurnaceProducer(@Observes ProcessAnnotatedType<FurnaceProducer> furnaceProducer)
{
   furnaceProducer.veto();
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
public void vetoFurnaceServiceProducer(@Observes ProcessAnnotatedType<FurnaceServiceProducer> furnaceServiceProducer)
{
   furnaceServiceProducer.veto();
}
 

import javax.enterprise.inject.spi.ProcessAnnotatedType; //導入方法依賴的package包/類
void interceptProcessAnnotatedTypes(@Observes ProcessAnnotatedType processAnnotatedType) {
    if ("org.apache.camel.cdi.CdiCamelContext".equals(processAnnotatedType.getAnnotatedType().getJavaClass().getName())) {
        processAnnotatedType.veto();
    }
}