@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); }
@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)); } }
/** * 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); }
/** * Creates a new Jersey-specific {@link javax.enterprise.inject.spi.Bean} instance. */ public RequestScopeBean(BeanManager beanManager) { AnnotatedType<CdiRequestScope> annotatedType = beanManager.createAnnotatedType(CdiRequestScope.class); this.injectionTarget = beanManager.createInjectionTarget(annotatedType); }
/** * 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); }
@Override @SuppressWarnings("unchecked") public void inject(Object instance) { if (beanManager != null) { AnnotatedType annotatedType = beanManager.createAnnotatedType((Class) instance.getClass()); InjectionTarget injectionTarget = beanManager.createInjectionTarget(annotatedType); CreationalContext context = beanManager.createCreationalContext(null); injectionTarget.inject(instance, context); } }
/** * Create an injector for the given class * @param manager the {@link BeanManager} * @param clazz class of the unmanaged instances */ public Unmanaged(BeanManager manager, Class<T> clazz) { this.beanManager = manager; AnnotatedType<T> type = manager.createAnnotatedType(clazz); this.injectionTarget = manager.getInjectionTargetFactory(type).createInjectionTarget(null); }
final AnnotatedType<T> annotatedType = beanManager.createAnnotatedType(clazz); final InjectionTargetFactory<T> injectionTargetFactory = beanManager.getInjectionTargetFactory(annotatedType); final InjectionTarget<T> injectionTarget = injectionTargetFactory.createInjectionTarget(null);
/** * 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()); }
annotatedType = beanManager.createAnnotatedType( beanType );
/** * Registers a class as {@link JerseyBean} into {@link BeanManager}. * * @param binding object containing {@link javax.enterprise.inject.spi.BeanAttributes} information. * @param abd {@link AfterBeanDiscovery} event. * @param resolvers all registered injection resolvers. * @param beanManager currently used bean manager. * @param <T> type of the class which is registered. */ public static <T> void registerBean(ClassBinding<T> binding, AfterBeanDiscovery abd, Collection<InjectionResolver> resolvers, BeanManager beanManager) { AnnotatedType<T> annotatedType = beanManager.createAnnotatedType(binding.getService()); InjectionTarget<T> injectionTarget = beanManager.createInjectionTarget(annotatedType); ClassBean<T> bean = new ClassBean<>(binding); bean.setInjectionTarget(getJerseyInjectionTarget(binding.getService(), injectionTarget, bean, resolvers)); abd.addBean(bean); }
/** * Registers a class supplier and its provided value as {@link JerseyBean}s into {@link BeanManager}. * * @param binding object containing {@link javax.enterprise.inject.spi.BeanAttributes} information. * @param abd {@link AfterBeanDiscovery} event. * @param resolvers all registered injection resolvers. * @param beanManager currently used bean manager. * @param <T> type of the class which is registered. */ @SuppressWarnings("unchecked") public static <T> void registerSupplier(SupplierClassBinding<T> binding, AfterBeanDiscovery abd, Collection<InjectionResolver> resolvers, BeanManager beanManager) { Class<Supplier<T>> supplierClass = (Class<Supplier<T>>) binding.getSupplierClass(); AnnotatedType<Supplier<T>> annotatedType = beanManager.createAnnotatedType(supplierClass); InjectionTarget<Supplier<T>> injectionTarget = beanManager.createInjectionTarget(annotatedType); SupplierClassBean<T> supplierBean = new SupplierClassBean<>(binding); InjectionTarget<Supplier<T>> jit = getJerseyInjectionTarget(supplierClass, injectionTarget, supplierBean, resolvers); supplierBean.setInjectionTarget(jit); abd.addBean(supplierBean); abd.addBean(new SupplierBeanBridge(binding, beanManager)); }
private InjectionTarget<T> createInjectionTarget(BeanManager beanManager, Class<T> type) { AnnotatedType<T> annotatedType = beanManager.createAnnotatedType( type ); return beanManager.createInjectionTarget( annotatedType ); }
/** * 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 final BeforeBeanDiscovery event, BeanManager beanManager) { AnnotatedType beanHolder = beanManager.createAnnotatedType(FacesConfigBeanHolder.class); event.addAnnotatedType(beanHolder, beanHolder.getJavaClass().getName()); }
void beforeBeanDiscovery( @Observes final BeforeBeanDiscovery event, BeanManager beanManager) { event.addScope(FlowScoped.class, true, true); // Register FlowBuilderFactoryBean as a bean with CDI annotations, so the system // can take it into account, and use it later when necessary. AnnotatedType bean = beanManager.createAnnotatedType(FlowScopeBeanHolder.class); event.addAnnotatedType(bean, bean.getJavaClass().getName()); }
void beforeBeanDiscovery( @Observes final BeforeBeanDiscovery event, BeanManager beanManager) { event.addScope(ViewScoped.class, true, true); // Register ViewScopeBeanHolder as a bean with CDI annotations, so the system // can take it into account, and use it later when necessary. AnnotatedType bean = beanManager.createAnnotatedType(ViewScopeBeanHolder.class); event.addAnnotatedType(bean, bean.getJavaClass().getName()); }
@Override public void postConstruct(Object instance, Object creationMetaData) throws InjectionProviderException { AnnotatedType annoType = beanManager.createAnnotatedType(instance.getClass()); InjectionTarget target = beanManager.createInjectionTarget(annoType); target.postConstruct(instance); }
/** * Create an injector for the given class * @param manager the {@link BeanManager} * @param clazz class of the unmanaged instances */ public Unmanaged(BeanManager manager, Class<T> clazz) { this.beanManager = manager; AnnotatedType<T> type = manager.createAnnotatedType(clazz); this.injectionTarget = manager.getInjectionTargetFactory(type).createInjectionTarget(null); }