Refine search
public void afterBeanDiscovery(@Observes AfterBeanDiscovery event, BeanManager manager) { event.addContext(new BusinessProcessContext(manager)); }
public void observeAfterBeanDiscovery(@Observes AfterBeanDiscovery event, BeanManager beanManager) { AnnotatedType<DeltaDecorator> type = beanManager.createAnnotatedType(DeltaDecorator.class); deltaDecorator = new DeltaDecoratorBean(type.getFields().iterator().next(), beanManager); event.addBean(deltaAlternative); event.addBean(deltaInterceptor); event.addBean(deltaDecorator); }
void afterBeanDiscovery(@Observes AfterBeanDiscovery afterBean) { for (Bean<?> b : beans) { afterBean.addBean(b); } for (Throwable e : problems) { afterBean.addDefinitionError(e); } }
public void registerObservers(@Observes AfterBeanDiscovery event) { event.addObserverMethod(anyGiraffeObserver); event.addObserverMethod(fiveMeterTallGiraffeObserver); event.addObserverMethod(sixMeterTallAngryGiraffeObserver); event.addObserverMethod(angryNubianGiraffeObserver); }
public void afterBeanDiscovery(@Observes AfterBeanDiscovery abd, BeanManager bm) { Set<Bean<?>> configuration = bm.getBeans(JmsForwarding.class); if(configuration == null || configuration.isEmpty()) { log.info("No {} registered. Event forwarding disabled.", JmsForwarding.class.getSimpleName()); } else { for(Bean<?> c : configuration) { log.info("Creating {} for configuration {}", BridgedObserver.class.getSimpleName(), c); CreationalContext<?> context = bm.createCreationalContext(c); // TODO Verify configuration for correctness (e.g. getQualifiers() must contain only @Qualifier annotations) JmsForwarding config = JmsForwarding.class.cast(bm.getReference(c, JmsForwarding.class, context)); BridgedObserver b = new BridgedObserver(bm, config); abd.addObserverMethod(b); } } }
public void addABean(@Observes AfterBeanDiscovery event) { event.addBean(new CowBean()); event.addContext(new DummyContext()); afterBeanDiscoveryObserved = true; }
public void addMetricsBean(@Observes AfterBeanDiscovery afterBeanDiscovery, BeanManager beanManager) { if(!foundMetricCollectorBean) { try{ Class.forName("com.codahale.metrics.MetricRegistry"); final AnnotatedType<StandardMetricsCollector> annotatedType = beanManager.createAnnotatedType(StandardMetricsCollector.class); afterBeanDiscovery.addBean(new StandardMetricsCollectorBean(beanManager.createInjectionTarget(annotatedType), beanManager)); } catch (Exception e) { final AnnotatedType<NoOpMetricsCollector> annotatedType = beanManager.createAnnotatedType(NoOpMetricsCollector.class); afterBeanDiscovery.addBean(new NoOpMetricCollectorBean(beanManager.createInjectionTarget(annotatedType))); } } } }
public void processAfterBeanDeployment(@Observes AfterBeanDiscovery event) { for (Exception t : errors) { event.addDefinitionError(t); } }
public void afterBeanDiscovery(@Observes AfterBeanDiscovery event, BeanManager manager) { final AnnotatedType annotationType = manager.createAnnotatedType(CDITransactionContext.class); final InjectionTarget injectionTarget = manager.createInjectionTarget(annotationType); final CreationalContext creationalContext = manager.createCreationalContext(null); final CDITransactionContext context = new CDITransactionContext(); injectionTarget.inject(context, creationalContext); injectionTarget.postConstruct(CDITransactionContext.class); if (logger.isDebugEnabled()) { logger.debug("afterBeanDiscovery -> context " + context); } context.setBeanManager(manager); event.addContext(context); }
private void afterBeanDiscovery(@Observes AfterBeanDiscovery afterBeanDiscovery, BeanManager beanManager) { final InjectionTarget<ValidationInterceptor> interceptorTarget = beanManager.createInjectionTarget(interceptorType); afterBeanDiscovery.addBean(new Bean<ValidationInterceptor>() {
public void registerBicycle(@Observes AfterBeanDiscovery event, BeanManager manager) { bicycleAttributesBeforeRegistering = manager.createBeanAttributes(manager.createAnnotatedType(Bicycle.class)); event.addBean(new BicycleBean(bicycleAttributesBeforeRegistering)); }
void initializeEntityViewSystem(@Observes AfterBeanDiscovery abd, BeanManager bm) { bm.fireEvent(configuration); CriteriaBuilderFactory criteriaBuilderFactory = configuration.createCriteriaBuilderFactory(); Class<?> beanClass = CriteriaBuilderFactory.class; Class<?>[] types = new Class[] { CriteriaBuilderFactory.class, Object.class }; Annotation[] qualifiers = new Annotation[] { new DefaultLiteral()}; Class<? extends Annotation> scope = Singleton.class; CriteriaBuilderFactory instance = criteriaBuilderFactory; Bean<CriteriaBuilderFactory> bean = new CustomBean<CriteriaBuilderFactory>(beanClass, types, qualifiers, scope, instance); abd.addBean(bean); } }
void addBeans(@Observes final AfterBeanDiscovery abd) { for (final Bean<?> bean : beans) { abd.addBean(bean); } if (mergeContainer(abd)) { abd.addObserverMethod(new ChildWebAppBusPropagaterObserverBean(SystemInstance.get().getComponent(Container.class))); } }
void observeABD(@Observes AfterBeanDiscovery abd, BeanManager beanManager) { abd.addBean() .addType(Account.class) .addQualifier(Custom.CustomLiteral.INSTANCE) .<Account>createWith((cc) -> { InterceptionFactory<Account> factory = beanManager.createInterceptionFactory(cc, Account.class); factory.configure().add(FeeBinding.FeeLiteral.INSTANCE); return factory.createInterceptedInstance(new Account()); }); } }
/** * 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)); }
public static void registerVertxBeanIfNeeded(AfterBeanDiscovery discovery, BeanManager beanManager) { Optional<Bean<?>> optional = beanManager.getBeans(Vertx.class).stream().findFirst(); if (!optional.isPresent()) { LOGGER.debug("Declaring a Vert.x bean"); discovery.addBean() .types(Vertx.class) .beanClass(Vertx.class) .scope(Singleton.class) .produceWith(i -> Vertx.vertx()) .disposeWith((vertx, i) -> vertx.close()); } } }
private void register(AfterBeanDiscovery afterBeanDiscovery, Set<Annotation> qualifiers, Bean<?> bean) { LOGGER.info(String.format("Registering bean '%s' with qualifiers %s.", bean.getBeanClass().getName(), qualifiers)); afterBeanDiscovery.addBean(bean); } }
void execute() { event.addContext(beanManager.getContext(SessionScoped.class)); } }.run();