@Inject public CdiInterceptorWrapper(BeanManager beanManager) { // get the original interceptor from the bean manager directly // to avoid CDI bootstrap issues caused by wrong extension ordering final Set<Bean<?>> interceptorBeans = beanManager.getBeans(ValidationInterceptor.class); final Bean<?> interceptorBean = beanManager.resolve(interceptorBeans); this.interceptor = (ValidationInterceptor) beanManager.getReference( interceptorBean, ValidationInterceptor.class, beanManager.createCreationalContext(interceptorBean)); }
@Override @SuppressWarnings("unchecked") public <T> List<T> getAllInstances(Type contractOrImpl) { List<T> result = new ArrayList<>(); for (Bean<?> bean : beanManager.getBeans(contractOrImpl)) { CreationalContext<?> ctx = beanManager.createCreationalContext(bean); Object reference = beanManager.getReference(bean, contractOrImpl, ctx); result.add((T) reference); } return result; }
@Test @OperateOnDeployment("mainDeployment") public void testNoWaitState() { // this test makes sure the delegate invoked by the called process can be resolved (context switch necessary). // we cannot load the class try { new CalledProcessDelegate(); Assert.fail("exception expected"); }catch (NoClassDefFoundError e) { // expected } // our bean manager does not know this bean Set<Bean< ? >> beans = beanManager.getBeans("calledProcessDelegate"); Assert.assertEquals(0, beans.size()); // but when we execute the process, we perform the context switch to the corresponding deployment // and there the class can be resolved and the bean is known. Map<String, Object> processVariables = new HashMap<String, Object>(); processVariables.put("calledElement", "calledProcessSyncNoWait"); ProcessInstance pi = runtimeService.startProcessInstanceByKey("mainProcessSyncNoWait", processVariables); Assert.assertNull(runtimeService.createProcessInstanceQuery().processDefinitionId(pi.getId()).singleResult()); }
@Test public void testAnnotatedBeanDiscoveryAlternative(Plant representative) { BeanManager bm = representative.getBeanManager(); Set<Bean<?>> treeBeans = bm.getBeans(Tree.class); assertEquals(2, treeBeans.size()); assertEquals(AlternativeTree.class, bm.resolve(treeBeans).getBeanClass()); Set<Bean<?>> stoneBeans = bm.getBeans(Stone.class); assertEquals(0, stoneBeans.size()); }
@Override @SuppressWarnings("unchecked") public ForeignDescriptor createForeignDescriptor(Binding binding) { Class<?> clazz; if (ClassBinding.class.isAssignableFrom(binding.getClass())) { clazz = ((ClassBinding<?>) binding).getService(); } else if (InstanceBinding.class.isAssignableFrom(binding.getClass())) { clazz = ((InstanceBinding<?>) binding).getService().getClass(); } else { throw new RuntimeException( org.glassfish.jersey.internal.LocalizationMessages .UNKNOWN_DESCRIPTOR_TYPE(binding.getClass().getSimpleName())); } Set<Bean<?>> beans = beanManager.getBeans(clazz); if (beans.isEmpty()) { return null; } Bean bean = beans.iterator().next(); CreationalContext ctx = beanManager.createCreationalContext(bean); return ForeignDescriptor.wrap(bean, instance -> bean.destroy(instance, ctx)); }
@Override public <T> T getBean(String name, Class<T> type) { Set<Bean<?>> beans = delegate.getBeans(name); if (beans.isEmpty()) { throw new UnsatisfiedResolutionException("no qualifying beans named '" + name + "'"); } Bean<?> bean = delegate.resolve(hasAlternative(beans) ? alternatives(beans) : beans); return getReference(bean, type); }
this.creationalContext = beanManager.createCreationalContext( null ); Set<Bean<?>> beans = beanManager.getBeans( beanType, new NamedBeanQualifier( beanName ) ); this.bean = (Bean<B>) beanManager.resolve( beans ); this.beanInstance = bean.create( creationalContext );
private static Bean<?> getBean(final String ref, final BeanManager beanManager) { if (beanManager == null) { return null; } BatchLogger.LOGGER.tracef("Looking up bean reference for '%s'", ref); final Set<Bean<?>> beans = beanManager.getBeans(ref); final Bean<?> bean = beanManager.resolve(beans); if (bean != null) { BatchLogger.LOGGER.tracef("Found bean '%s' for reference '%s'", bean, ref); } else { BatchLogger.LOGGER.tracef("No bean found for reference '%s;'", ref); } return bean; }
@SuppressWarnings("unchecked") private <T> T getInstanceInternal(Type contractOrImpl, Annotation... qualifiers) { Set<Bean<?>> beans = beanManager.getBeans(contractOrImpl, qualifiers); if (beans.isEmpty()) { return null; } Bean<?> bean = beans.iterator().next(); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, contractOrImpl, ctx); }
/** * Get me scope of a bean corresponding to given class. * * @param beanClass bean class in question. * @param beanManager actual bean manager. * @return actual bean scope or null, if the scope could not be determined. */ public static Class<? extends Annotation> getBeanScope(final Class<?> beanClass, final BeanManager beanManager) { final Set<Bean<?>> beans = beanManager.getBeans(beanClass); if (beans.isEmpty()) { return null; } for (Bean b : beans) { return b.getScope(); } return null; } }
@Test @SpecAssertion(section = BM_RESOLVE_AMBIGUOUS_DEP, id = "a") public void testAmbiguousDependencyResolved() { Set<Bean<?>> beans = getCurrentManager().getBeans(Food.class); assertEquals(beans.size(), 2); Bean<?> bean = getCurrentManager().resolve(beans); assertNotNull(bean); assertTrue(bean.isAlternative()); assertTrue(typeSetMatches(bean.getTypes(), Food.class, Soy.class, Object.class)); }
private <T> T getReference(Class<T> clazz, BeanManager beanManager) { Set<Bean<?>> beans = beanManager.getBeans(clazz, new AnnotationLiteral<Default>() {}); Iterator<Bean<?>> i = beans.iterator(); if (!i.hasNext()) { return null; } Bean<?> bean = i.next(); CreationalContext<?> context = beanManager.createCreationalContext(bean); return (T) beanManager.getReference(bean, clazz, context); }
private static Supplier<?> getSupplier(BeanManager beanManager, ParameterizedType supplierType) { Set<Bean<?>> beans = beanManager.getBeans(supplierType); if (beans.isEmpty()) { return null; } Bean<?> bean = beans.iterator().next(); CreationalContext<?> ctx = beanManager.createCreationalContext(bean); return (Supplier<?>) beanManager.getReference(bean, supplierType, ctx); }
public CdiPropertyInjector(final PropertyInjector delegate, final Class<?> clazz, final Map<Class<?>, Type> sessionBeanInterface, final BeanManager manager) { this.delegate = delegate; this.clazz = clazz; if (sessionBeanInterface.containsKey(clazz)) { injectorEnabled = false; } if (!manager.getBeans(clazz).isEmpty() && Utils.isJaxrsComponent(clazz)) { injectorEnabled = false; } }
@Test @SpecAssertion(section = DECLARING_SELECTED_ALTERNATIVES_BEAN_ARCHIVE, id = "ca") @SpecAssertion(section = DECLARING_SELECTED_ALTERNATIVES_BEAN_ARCHIVE, id = "cb") @SpecAssertion(section = DECLARING_ALTERNATIVE, id = "ab") @SpecAssertion(section = DECLARING_ALTERNATIVE, id = "ac") public void testProducerAlternativesOnMethodAndField() throws Exception { assertEquals(getBeans(Cat.class, WILD_LITERAL).size(), 2); assertEquals(getBeans(Cat.class, TAME_LITERAL).size(), 0); Set<Bean<?>> snakeBeans = getCurrentManager().getBeans(Snake.class, WILD_LITERAL); assertNotNull(getCurrentManager().resolve(snakeBeans)); }