javax.enterprise.inject.spi.BeforeBeanDiscovery Java Examples

@SuppressWarnings("UnusedDeclaration")
protected void init(@Observes BeforeBeanDiscovery beforeBeanDiscovery, BeanManager beanManager)
{
    if (!ClassDeactivationUtils.isActivated(getClass()))
    {
        return;
    }

    enabled = CoreBaseConfig.InterDynCustomization.INTERDYN_ENABLED.getValue();

    if (enabled)
    {
        logger.info("Starting with deltaspike.interdyn instrumentation");
        init();
    }
}
 

/**
 * javax.faces.bean.ViewScoped is no CDI Scope.
 * We need to add it programmatically to CDI.
 */
public void addViewScoped(@Observes BeforeBeanDiscovery beforeBeanDiscovery)
{
    isActivated = ClassDeactivationUtils.isActivated(getClass());

    if (isActivated)
    {
        //this extension is only needed if the cdi-based view-scope handling isn't delegated to jsf 2.2+
        isActivated = !JsfUtils.isViewScopeDelegationEnabled();
    }

    if (!isActivated)
    {
        return;
    }

    beforeBeanDiscovery.addScope(ViewScoped.class, true, true);
}
 

void beforeBeanDiscovery(@Observes BeforeBeanDiscovery event, BeanManager beanManager) {
    CDILogging.log.beforeBeanDiscovery(beanManager);

    // TODO: Do not add CDI beans unless @LoginConfig (or other trigger) is configured
    addAnnotatedType(event, beanManager, ClaimValueProducer.class);
    addAnnotatedType(event, beanManager, CommonJwtProducer.class);
    addAnnotatedType(event, beanManager, DefaultJWTParser.class);
    addAnnotatedType(event, beanManager, JsonValueProducer.class);
    addAnnotatedType(event, beanManager, JWTAuthContextInfoProvider.class);
    addAnnotatedType(event, beanManager, JWTAuthenticationFilter.class);
    addAnnotatedType(event, beanManager, PrincipalProducer.class);
    addAnnotatedType(event, beanManager, RawClaimTypeProducer.class);
    if (registerOptionalClaimTypeProducer()) {
        addAnnotatedType(event, beanManager, OptionalClaimTypeProducer.class);
    }

    if (isEESecurityAvailable()) {
        addAnnotatedType(event, beanManager, JWTHttpAuthenticationMechanism.class);
        CDILogging.log.jwtHttpAuthenticationMechanismRegistered();
    } else {
        // EE Security is not available, register the JAX-RS authentication filter.
        CDILogging.log.jwtHttpAuthenticationMechanismNotRegistered();
    }
}
 

private void addInterceptorBindings(@Observes BeforeBeanDiscovery bbd, BeanManager manager) {
    SmallRyeMetricsLogging.log.logSmallRyeMetricsVersion(getImplementationVersion().orElse("unknown"));

    String extensionName = MetricCdiInjectionExtension.class.getName();

    // It seems that fraction deployment module cannot be picked up as a CDI bean archive - see also SWARM-1725
    for (Class clazz : new Class[] {
            MetricProducer.class,
            MetricNameFactory.class,
            GaugeRegistrationInterceptor.class,
            MetricRegistries.class,

            MeteredInterceptor.class,
            CountedInterceptor.class,
            ConcurrentGaugeInterceptor.class,
            TimedInterceptor.class,
            SimplyTimedInterceptor.class,
            MetricsRequestHandler.class
    }) {
        bbd.addAnnotatedType(manager.createAnnotatedType(clazz), extensionName + "_" + clazz.getName());
    }
}
 

void registerInterceptorBindings(@Observes BeforeBeanDiscovery bbd, BeanManager bm) {
    LOGGER.info("MicroProfile: Fault Tolerance activated");
    bbd.addInterceptorBinding(new FTInterceptorBindingAnnotatedType<>(bm.createAnnotatedType(CircuitBreaker.class)));
    bbd.addInterceptorBinding(new FTInterceptorBindingAnnotatedType<>(bm.createAnnotatedType(Retry.class)));
    bbd.addInterceptorBinding(new FTInterceptorBindingAnnotatedType<>(bm.createAnnotatedType(Timeout.class)));
    bbd.addInterceptorBinding(new FTInterceptorBindingAnnotatedType<>(bm.createAnnotatedType(Asynchronous.class)));
    bbd.addInterceptorBinding(new FTInterceptorBindingAnnotatedType<>(bm.createAnnotatedType(Fallback.class)));
    bbd.addInterceptorBinding(new FTInterceptorBindingAnnotatedType<>(bm.createAnnotatedType(Bulkhead.class)));

    // It seems that fraction deployment module cannot be picked up as a CDI bean archive - see also SWARM-1725
    bbd.addAnnotatedType(bm.createAnnotatedType(FaultToleranceInterceptor.class),
            FaultToleranceInterceptor.class.getName());
    bbd.addAnnotatedType(bm.createAnnotatedType(DefaultFallbackHandlerProvider.class),
            DefaultFallbackHandlerProvider.class.getName());
    bbd.addAnnotatedType(bm.createAnnotatedType(ExecutorProvider.class),
            ExecutorProvider.class.getName());
    bbd.addAnnotatedType(bm.createAnnotatedType(DefaultFaultToleranceOperationProvider.class),
            DefaultFaultToleranceOperationProvider.class.getName());
    bbd.addAnnotatedType(bm.createAnnotatedType(MetricsCollectorFactory.class), MetricsCollectorFactory.class.getName());
    bbd.addAnnotatedType(bm.createAnnotatedType(StrategyCache.class), StrategyCache.class.getName());
}
 

public void observeBeforeBeanDiscovery(@Observes final BeforeBeanDiscovery bbd, final BeanManager beanManager) {
    bbd.addAnnotatedType(beanManager.createAnnotatedType(JWTAuthConfigurationProperties.class));
    bbd.addAnnotatedType(beanManager.createAnnotatedType(JsonbProducer.class));
    bbd.addAnnotatedType(beanManager.createAnnotatedType(MPJWTFilter.class));
    bbd.addAnnotatedType(beanManager.createAnnotatedType(MPJWTInitializer.class));
    bbd.addAnnotatedType(beanManager.createAnnotatedType(org.apache.tomee.microprofile.jwt.bval.BValInterceptor.class));
}
 

static <T extends Annotation> void declareAsInterceptorBinding(Class<T> annotation, BeanManager manager, BeforeBeanDiscovery bbd) {
    AnnotatedType<T> annotated = manager.createAnnotatedType(annotation);
    Set<AnnotatedMethod<? super T>> methods = new HashSet<>();
    for (AnnotatedMethod<? super T> method : annotated.getMethods())
        methods.add(new AnnotatedMethodDecorator<>(method, NON_BINDING));

    bbd.addInterceptorBinding(new AnnotatedTypeDecorator<>(annotated, INTERCEPTOR_BINDING, methods));
}
 

void addBeansFromJava(@Observes final BeforeBeanDiscovery bbd, final BeanManager bm) {
    if (Cxfs.IS_PRESENT) {
        bbd.addInterceptorBinding(JAXRSFieldInjectionInterceptor.Binding.class);

        Stream.of(MeecrowaveBus.class, JAXRSFieldInjectionInterceptor.class)
              .forEach(type -> bbd.addAnnotatedType(bm.createAnnotatedType(type)));
    }
}
 

void register(@Observes final BeforeBeanDiscovery beforeBeanDiscovery, final BeanManager beanManager) {
    Stream.of(
            MandatoryInterceptor.class, NeverInterceptor.class,
            NotSupportedInterceptor.class, RequiredInterceptor.class,
            RequiredNewInterceptor.class, SupportsInterceptor.class)
            .forEach(c -> beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(c)));
}
 

void beforeBeanDiscovery(@Observes BeforeBeanDiscovery before)
{
    isActivated = ClassDeactivationUtils.isActivated(getClass());

    if (!isActivated)
    {
        return;
    }

    PersistenceUnitDescriptorProvider.getInstance().init();
}
 

void observeBeforeBeanDiscovery(@Observes final BeforeBeanDiscovery beforeBeanDiscovery,
                                final BeanManager beanManager) {
    beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(DefaultAuthenticationMechanism.class));
    beforeBeanDiscovery.addAnnotatedType(
            beanManager.createAnnotatedType(TomEESecurityServletAuthenticationMechanismMapper.class));
    beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(TomEEDefaultIdentityStore.class));
    beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(TomEEIdentityStoreHandler.class));

    beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(AutoApplySessionInterceptor.class));
    beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(RememberMeInterceptor.class));
    beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(LoginToContinueInterceptor.class));

    beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(TomEESecurityContext.class));
}
 

void init(@Observes final BeforeBeanDiscovery beforeBeanDiscovery) {
    config = GeronimoOpenAPIConfig.create();
    processor = new AnnotationProcessor(config, loadNamingStrategy(config), null);
    skipScan = Boolean.parseBoolean(config.read(OASConfig.SCAN_DISABLE, "false"));
    classes = getConfigCollection(OASConfig.SCAN_CLASSES);
    packages = getConfigCollection(OASConfig.SCAN_PACKAGES);
    excludePackages = getConfigCollection(OASConfig.SCAN_EXCLUDE_PACKAGES);
    excludeClasses = getConfigCollection(OASConfig.SCAN_EXCLUDE_CLASSES);
    try {
        Yaml.getObjectMapper();
        jacksonIsPresent = true;
    } catch (final Error | RuntimeException e) {
        // no-op
    }
}
 

/**
 * Register the MPJWTProducer JsonWebToken producer bean
 *
 * @param bbd         before discovery event
 * @param beanManager cdi bean manager
 */
public void observeBeforeBeanDiscovery(@Observes BeforeBeanDiscovery bbd, BeanManager beanManager) {
    log.debugf("MPJWTExtension(), adding producers");
    String extensionName = MPJWTExtension.class.getName();
    for (Class<?> clazz : new Class<?>[] {
            JWTAuthContextInfoProvider.class,
            CommonJwtProducer.class,
            PrincipalProducer.class,
            RawClaimTypeProducer.class,
            ClaimValueProducer.class,
            JsonValueProducer.class,
    }) {
        bbd.addAnnotatedType(beanManager.createAnnotatedType(clazz), extensionName + "_" + clazz.getName());
    }
}
 

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,
          OpenTracingInterceptor.class,
  }) {
    bbd.addAnnotatedType(manager.createAnnotatedType(clazz), extensionName + "_" + clazz.getName());
  }
}
 

@SuppressWarnings("UnusedDeclaration")
protected void init(@Observes BeforeBeanDiscovery beforeBeanDiscovery, BeanManager beanManager)
{
    if (!ClassDeactivationUtils.isActivated(getClass()))
    {
        return;
    }

    this.beanManager = beanManager;
    int priorityValue = CoreBaseConfig.InterceptorCustomization.PRIORITY;
    priorityAnnotationInstance = AnnotationInstanceUtils.getPriorityAnnotationInstance(priorityValue);
}
 

public void register(@Observes BeforeBeanDiscovery beforeBean, BeanManager beanManager) {
    if (!InMemoryIdentityStore.getCALLER_TO_CREDENTIALS().isEmpty()) {
        beforeBean.addAnnotatedType(
            beanManager.createAnnotatedType(InMemoryIdentityStore.class), 
            "Piranha " + InMemoryIdentityStore.class.getName());
    }
}
 

void discoverInterceptorBindings(@Observes BeforeBeanDiscovery beforeBeanDiscoveryEvent)
{
    beforeBeanDiscoveryEvent.addInterceptorBinding(SimpleCache.class);
}
 

private void addInterceptorBindings(@Observes BeforeBeanDiscovery bbd, BeanManager manager) {
    declareAsInterceptorBinding(Counted.class, manager, bbd);
    declareAsInterceptorBinding(ExceptionMetered.class, manager, bbd);
    declareAsInterceptorBinding(Metered.class, manager, bbd);
    declareAsInterceptorBinding(Timed.class, manager, bbd);
}
 

protected void init(@Observes BeforeBeanDiscovery beforeBeanDiscovery)
{
    isActivated = ClassDeactivationUtils.isActivated(getClass());
}
 

void beforeBeanDiscovery(@Observes BeforeBeanDiscovery before)
{
    isActivated = ClassDeactivationUtils.isActivated(getClass());
}
 

protected void init(@Observes BeforeBeanDiscovery beforeBeanDiscovery)
{
    isActivated = ClassDeactivationUtils.isActivated(getClass());
    mockFilters = ServiceUtils.loadServiceImplementations(MockFilter.class);
}
 

protected void init(@Observes BeforeBeanDiscovery beforeBeanDiscovery)
{
    this.isActivated = ClassDeactivationUtils.isActivated(getClass());
}
 

protected void init(@Observes BeforeBeanDiscovery beforeBeanDiscovery)
{
    isActivated = ClassDeactivationUtils.isActivated(getClass());
    securityMetaDataStorage = new SecurityMetaDataStorage();
    ParentExtensionStorage.addExtension(this);
}
 

protected void init(@Observes BeforeBeanDiscovery beforeBeanDiscovery)
{
    this.isActivated = ClassDeactivationUtils.isActivated(getClass());
}
 

@SuppressWarnings("UnusedDeclaration")
protected void init(@Observes BeforeBeanDiscovery beforeBeanDiscovery)
{
    this.isActivated = ClassDeactivationUtils.isActivated(getClass());
}
 

public void addMocks(@Observes final BeforeBeanDiscovery bbd) {
    // ensure it is init
    SystemInstance.get().getComponent(FallbackPropertyInjector.class);
}
 

protected void init(@Observes BeforeBeanDiscovery beforeBeanDiscovery)
{
    this.isActivated = ClassDeactivationUtils.isActivated(getClass());      
}
 

void discoverInterceptorBindings(@Observes BeforeBeanDiscovery beforeBeanDiscoveryEvent)
{
    beforeBeanDiscoveryEvent.addInterceptorBinding(SimpleCache.class);
}
 

@SuppressWarnings("UnusedDeclaration")
protected void init(@Observes BeforeBeanDiscovery beforeBeanDiscovery)
{
    isActivated = ClassDeactivationUtils.isActivated(getClass());
    ParentExtensionStorage.addExtension(this);
}
 

public void addResourceLoaders(final BeforeBeanDiscovery beforeBeanDiscovery, final BeanManager beanManager)
{
    beforeBeanDiscovery.addAnnotatedType(this.createAnnotatedType(ClasspathResourceProvider.class,beanManager));
    beforeBeanDiscovery.addAnnotatedType(this.createAnnotatedType(InjectableResourceProducer.class,beanManager));
    beforeBeanDiscovery.addAnnotatedType(this.createAnnotatedType(FileResourceProvider.class,beanManager));
}