How to use

addAnnotatedType

method

in

javax.enterprise.inject.spi.BeforeBeanDiscovery

/**
 * Initializes the extension prior to bean discovery.
 *
 * @param discovery bean discovery event
 */
public void before(@Observes BeforeBeanDiscovery discovery) {
  // Register beans manually
  discovery.addAnnotatedType(JsonWebTokenProducer.class, "TokenProducer");
}

/**
 * Register our external request scope.
 *
 * @param beforeBeanDiscoveryEvent CDI bootstrap event.
 * @param beanManager current bean manager.
 */
private void beforeBeanDiscovery(@Observes BeforeBeanDiscovery beforeBeanDiscoveryEvent, final BeanManager beanManager) {
  requestScopeType = beanManager.createAnnotatedType(CdiExternalRequestScope.class);
  beforeBeanDiscoveryEvent.addAnnotatedType(requestScopeType);
}

  @SuppressWarnings("unused")
  private void beforeBeanDiscovery(@Observes final BeforeBeanDiscovery beforeBeanDiscovery, final javax.enterprise.inject.spi
      .BeanManager beanManager) {
    beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(WebAppExceptionHolder.class));
    beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(WebAppExceptionInterceptor.class));
    beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(TransactionalExceptionMapper.class));
  }
}

@SuppressWarnings("unused")
private void beforeBeanDiscovery(@Observes final BeforeBeanDiscovery beforeBeanDiscovery,
    final javax.enterprise.inject.spi.BeanManager beanManager) {
  beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(JaxRsParamProducer.class));
}

/**
 * Register our validation interceptor wrapper.
 *
 * @param beforeBeanDiscoveryEvent CDI bootstrap event.
 * @param beanManager current bean manager.
 */
private void beforeBeanDiscovery(@Observes BeforeBeanDiscovery beforeBeanDiscoveryEvent, final BeanManager beanManager) {
  beforeBeanDiscoveryEvent.addAnnotatedType(beanManager.createAnnotatedType(CdiInterceptorWrapper.class));
  interceptorAnnotatedType = beanManager.createAnnotatedType(ValidationInterceptor.class);
  beforeBeanDiscoveryEvent.addAnnotatedType(interceptorAnnotatedType);
}

/**
 * Initializes the extension prior to bean discovery.
 *
 * @param discovery bean discovery event
 */
public void before(@Observes BeforeBeanDiscovery discovery) {
  LOGGER.log(Level.FINE, () -> "### Before bean discovery " + discovery);
  // Initialize our implementation
  MetricsSupport.create();
  RegistryProducer.clearApplicationRegistry();
  // Register beans manually
  discovery.addAnnotatedType(RegistryProducer.class, "RegistryProducer");
  discovery.addAnnotatedType(MetricProducer.class, "MetricProducer");
  discovery.addAnnotatedType(InterceptorCounted.class, "InterceptorCounted");
  discovery.addAnnotatedType(InterceptorMetered.class, "InterceptorMetered");
  discovery.addAnnotatedType(InterceptorTimed.class, "InterceptorTimed");
}

/**
 * This method registers the (annotated) class that enables the interceptor and sets its priority
 * 
 */
public void register(@Observes BeforeBeanDiscovery beforeBean, BeanManager beanManager) {
  beforeBean.addAnnotatedType(
      beanManager.createAnnotatedType(HelloInterceptorEnabler.class), 
      "CdiExtension" + HelloInterceptorEnabler.class);
}

/**
 * Adds interceptor bindings and annotated types.
 *
 * @param discovery Event information.
 * @param bm Bean manager instance.
 */
void registerInterceptorBindings(@Observes BeforeBeanDiscovery discovery, BeanManager bm) {
  // Check if fault tolerance and its metrics are enabled
  final Config config = ConfigProvider.getConfig();
  isFaultToleranceEnabled = config.getOptionalValue(MP_FT_NON_FALLBACK_ENABLED, Boolean.class)
      .orElse(true);      // default is enabled
  isFaultToleranceMetricsEnabled = config.getOptionalValue(MP_FT_METRICS_ENABLED, Boolean.class)
      .orElse(true);      // default is enabled
  discovery.addInterceptorBinding(new InterceptorBindingAnnotatedType<>(bm.createAnnotatedType(Retry.class)));
  discovery.addInterceptorBinding(new InterceptorBindingAnnotatedType<>(bm.createAnnotatedType(CircuitBreaker.class)));
  discovery.addInterceptorBinding(new InterceptorBindingAnnotatedType<>(bm.createAnnotatedType(Timeout.class)));
  discovery.addInterceptorBinding(new InterceptorBindingAnnotatedType<>(bm.createAnnotatedType(Asynchronous.class)));
  discovery.addInterceptorBinding(new InterceptorBindingAnnotatedType<>(bm.createAnnotatedType(Bulkhead.class)));
  discovery.addInterceptorBinding(new InterceptorBindingAnnotatedType<>(bm.createAnnotatedType(Fallback.class)));
  discovery.addAnnotatedType(bm.createAnnotatedType(CommandInterceptor.class), CommandInterceptor.class.getName());
}

/**
 * Used to register the method validation interceptor binding annotation.
 *
 * @param beforeBeanDiscoveryEvent event fired before the bean discovery process starts
 * @param beanManager the bean manager.
 */
public void beforeBeanDiscovery(@Observes BeforeBeanDiscovery beforeBeanDiscoveryEvent,
    final BeanManager beanManager) {
  Contracts.assertNotNull( beforeBeanDiscoveryEvent, "The BeforeBeanDiscovery event cannot be null" );
  Contracts.assertNotNull( beanManager, "The BeanManager cannot be null" );
  // Register the interceptor explicitly. This way, no beans.xml is needed
  AnnotatedType<ValidationInterceptor> annotatedType = beanManager.createAnnotatedType( ValidationInterceptor.class );
  beforeBeanDiscoveryEvent.addAnnotatedType( annotatedType, ValidationInterceptor.class.getName() );
}

void beforeBeanDiscovery(@Observes BeforeBeanDiscovery event, BeanManager beanManager) {
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(ActivateRequestContextInterceptor.class, beanManager),
      ActivateRequestContextInterceptor.class.getName());
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(CdiRequestContextActivatorInterceptor.class, beanManager),
      CdiRequestContextActivatorInterceptor.class.getName());
}

/**
 * @param beforeBean The BeforeBeanDiscovery.
 * @param bm         The BeanManager.
 * @param types      annotated types to register
 */
public static void addAnnotatedTypes(BeforeBeanDiscovery beforeBean, BeanManager bm, Class<?>... types) {
  for (Class<?> type : types) {
    beforeBean.addAnnotatedType(bm.createAnnotatedType(type), type.getName());
  }
}

void beforeBeanDiscovery(
  @Observes final BeforeBeanDiscovery event, BeanManager beanManager)
{
  // Register FlowBuilderFactoryBean as a bean with CDI annotations, so the system
  // can take it into account, and use it later when necessary.
  AnnotatedType<FlowBuilderFactoryBean> flowDiscoveryHelper =
          beanManager.createAnnotatedType(FlowBuilderFactoryBean.class);
  event.addAnnotatedType(flowDiscoveryHelper, flowDiscoveryHelper.getJavaClass().getName());
}

  public void registerWeldSEBeans(@Observes BeforeBeanDiscovery event, BeanManager manager)
  {
   // TODO Re-enable Cross Container Events
   // event.addAnnotatedType(manager.createAnnotatedType(CrossContainerObserverMethod.class));
   event.addAnnotatedType(manager.createAnnotatedType(AddonProducer.class));
   event.addAnnotatedType(manager.createAnnotatedType(AddonRegistryProducer.class));
   event.addAnnotatedType(manager.createAnnotatedType(AddonRepositoryProducer.class));
   event.addAnnotatedType(manager.createAnnotatedType(CrossContainerObserverMethod.class));
   event.addAnnotatedType(manager.createAnnotatedType(ForgeProducer.class));
   event.addAnnotatedType(manager.createAnnotatedType(ServiceRegistryProducer.class));
  }
}

 public void observeBeforeBeanDiscovery(@Observes BeforeBeanDiscovery bbd, BeanManager manager) {
  logger.info("Registering Tracer CDI producer");
  String extensionName = OpenTracingCDIExtension.class.getName();
  for (Class<?> clazz : new Class<?>[] {
      TracerProducer.class,
  }) {
   bbd.addAnnotatedType(manager.createAnnotatedType(clazz), extensionName + "_" + clazz.getName());
  }
 }
}

public void observeBeforeBeanDiscovery(@Observes BeforeBeanDiscovery bbd, BeanManager manager) {
  String extensionName = TracingCDIExtension.class.getName();
  bbd.addAnnotatedType(manager.createAnnotatedType(TracerProducer.class), extensionName + "-" + TracerProducer.class.getName());
  bbd.addAnnotatedType(manager.createAnnotatedType(SmallRyeTracingCDIInterceptor.class), extensionName + "-" + SmallRyeTracingCDIInterceptor.class.getName());
}

public void registerWeldSEBeans(@Observes BeforeBeanDiscovery event, BeanManager manager) {
  if (ignoreEvent(event)) {
    return;
  }
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(ParametersFactory.class, manager), ParametersFactory.class.getName());
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(RunnableDecorator.class, manager), RunnableDecorator.class.getName());
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(ActivateThreadScopeInterceptor.class, manager),
      ActivateThreadScopeInterceptor.class.getName());
}

public void registerWeldSEBeans(@Observes BeforeBeanDiscovery event, BeanManager manager) {
  if (ignoreEvent(event)) {
    return;
  }
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(ParametersFactory.class, manager), ParametersFactory.class.getName());
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(RunnableDecorator.class, manager), RunnableDecorator.class.getName());
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(ActivateThreadScopeInterceptor.class, manager),
      ActivateThreadScopeInterceptor.class.getName());
}

public void registerWeldSEBeans(@Observes BeforeBeanDiscovery event, BeanManager manager) {
  if (ignoreEvent(event)) {
    return;
  }
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(ParametersFactory.class, manager), ParametersFactory.class.getName());
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(RunnableDecorator.class, manager), RunnableDecorator.class.getName());
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(ActivateThreadScopeInterceptor.class, manager),
      ActivateThreadScopeInterceptor.class.getName());
}

public void registerWeldSEBeans(@Observes BeforeBeanDiscovery event, BeanManager manager) {
  if (ignoreEvent(event)) {
    return;
  }
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(ParametersFactory.class, manager));
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(RunnableDecorator.class, manager));
  event.addAnnotatedType(VetoedSuppressedAnnotatedType.from(ActivateThreadScopeInterceptor.class, manager));
}

public void addType(@Observes BeforeBeanDiscovery event, BeanManager beanManager)
{
 WeldFromMcRegistry.getInstance().initializeTypes(beanManager);
 for (AnnotatedTypeWrapper typeWrapper : WeldFromMcRegistry.getInstance().getTypes())
 {   
   event.addAnnotatedType(typeWrapper.getAnnotatedType());
 }
}