private boolean isNormalScope(final Set<Annotation> annotations, final BeanManager bm) { for (Annotation annotation : annotations) { if (bm.isNormalScope(annotation.annotationType())) { return true; } } return false; }
private boolean isNormalScope(final Set<Annotation> annotations, final BeanManager bm) { for (Annotation annotation : annotations) { if (bm.isNormalScope(annotation.annotationType())) { return true; } } return false; }
@Override public boolean isNormalScope(Class<? extends Annotation> annotationType) { return delegate().isNormalScope(annotationType); }
private void starts(final BeanManager beanManager, final Class<?> clazz) { final Bean<?> bean = beanManager.resolve(beanManager.getBeans(clazz)); if (!beanManager.isNormalScope(bean.getScope())) { throw new IllegalStateException("Only normal scoped beans can use @Startup - likely @ApplicationScoped"); } final CreationalContext<Object> creationalContext = beanManager.createCreationalContext(null); beanManager.getReference(bean, clazz, creationalContext).toString(); // don't release now, will be done by the context - why we restrict it to normal scoped beans }
@Override public boolean isNormalScope(Class<? extends Annotation> annotationType) { return delegate().isNormalScope(annotationType); }
private <T> T lookupByName(final String name, final Class<T> type) { final Set<Bean<?>> tfb = beanManager.getBeans(name); final Bean<?> bean = beanManager.resolve(tfb); final CreationalContext<?> ctx = beanManager.createCreationalContext(null); if (!beanManager.isNormalScope(bean.getScope())) { contexts.add(ctx); } return type.cast(beanManager.getReference(bean, type, ctx)); } }
private Object getInstance(final Class<?> javaClass, final BeanManager beanManager, final Bean<?> bean) { final CreationalContext<Object> creationalContext = beanManager.createCreationalContext(null); final Object reference = beanManager.getReference(bean, javaClass, creationalContext); if (!beanManager.isNormalScope(bean.getScope())) { creationalContexts.add(creationalContext); } return reference; }
protected <X> boolean hasNormalScopeAnnotation(Bean<X> bean, BeanManager beanManager) { Class<? extends Annotation> scopeAnnotationClass = bean.getScope(); return scopeAnnotationClass != null && beanManager.isNormalScope(scopeAnnotationClass); }
private synchronized void init(BeanManager beanManager) { if (queryInOutMapperIsNormalScope != null) { return; } if (beanManager != null) { final Set<Bean<?>> beans = beanManager.getBeans(mapper); final Class<? extends Annotation> scope = beanManager.resolve(beans).getScope(); queryInOutMapperIsNormalScope = beanManager.isNormalScope(scope); } else { queryInOutMapperIsNormalScope = false; } }
@Override public boolean isNormalScope(Class<? extends Annotation> annotationType) { return delegate().isNormalScope(annotationType); }
private synchronized void init(BeanManager beanManager) { if (queryInOutMapperIsNormalScope != null) { return; } if (beanManager != null) { final Set<Bean<?>> beans = beanManager.getBeans(mapper); final Class<? extends Annotation> scope = beanManager.resolve(beans).getScope(); queryInOutMapperIsNormalScope = beanManager.isNormalScope(scope); } else { queryInOutMapperIsNormalScope = false; } }
public <T> T getBean(final Class<T> type) { // ATM we recommand getting it once but if needed we can cache it in a concurrent map final BeanManager manager = getBeanManager(); final Bean<?> bean = manager.resolve(manager.getBeans(type)); if (!manager.isNormalScope(bean.getScope()) && !type.isAnnotationPresent(Singleton.class)) { throw new IllegalArgumentException("Only normal scoped instances or singleton EJB can use getBean()"); } return type.cast(manager.getReference(bean, type, null)); }
private synchronized void init(BeanManager beanManager, EntityViewManager evm) { if (entityManagerResolverIsNormalScope != null) { return; } initialize(evm); if (entityManagerResolver != null && beanManager != null) { final Set<Bean<?>> beans = beanManager.getBeans(entityManagerResolver); final Class<? extends Annotation> scope = beanManager.resolve(beans).getScope(); entityManagerResolverIsNormalScope = beanManager.isNormalScope(scope); } else { entityManagerResolverIsNormalScope = false; } }
private HealthCheck lookup(final Bean<?> bean, final BeanManager manager) { final Class<?> type = bean.getBeanClass() == null ? HealthCheck.class : bean.getBeanClass(); final Set<Bean<?>> beans = manager.getBeans(type, bean.getQualifiers().toArray(new Annotation[bean.getQualifiers().size()])); final Bean<?> resolvedBean = manager.resolve(beans); final CreationalContext<Object> creationalContext = manager.createCreationalContext(null); if (!manager.isNormalScope(resolvedBean.getScope())) { contexts.add(creationalContext); } return HealthCheck.class.cast(manager.getReference(resolvedBean, HealthCheck.class, creationalContext)); } }
@Test @SpecAssertion(section = BM_DETERMINING_ANNOTATION, id = "ag") public void testDetermineScopeType() { assertTrue(getCurrentManager().isNormalScope(RequestScoped.class)); assertFalse(getCurrentManager().isPassivatingScope(RequestScoped.class)); assertTrue(getCurrentManager().isNormalScope(SessionScoped.class)); assertTrue(getCurrentManager().isPassivatingScope(SessionScoped.class)); assertTrue(getCurrentManager().isNormalScope(DummyScoped.class)); assertFalse(getCurrentManager().isPassivatingScope(DummyScoped.class)); }
private void initQueryInOutMapperIsNormalScope(RepositoryMetadata repositoryMetadata, RepositoryMethodMetadata repositoryMethodMetadata, BeanManager beanManager) { if (repositoryMethodMetadata.getQueryInOutMapperClass() != null) { Set<Bean<?>> beans = beanManager.getBeans(repositoryMethodMetadata.getQueryInOutMapperClass()); Class<? extends Annotation> scope = beanManager.resolve(beans).getScope(); repositoryMethodMetadata.setQueryInOutMapperIsNormalScope(beanManager.isNormalScope(scope)); } }
private void initQueryInOutMapperIsNormalScope(RepositoryMethodMetadata repositoryMethodMetadata, BeanManager beanManager) { if (repositoryMethodMetadata.getQueryInOutMapperClass() != null) { Set<Bean<?>> beans = beanManager.getBeans(repositoryMethodMetadata.getQueryInOutMapperClass()); Class<? extends Annotation> scope = beanManager.resolve(beans).getScope(); repositoryMethodMetadata.setQueryInOutMapperIsNormalScope(beanManager.isNormalScope(scope)); } }
private void initQueryInOutMapperIsNormalScope(RepositoryMetadata repositoryMetadata, RepositoryMethodMetadata repositoryMethodMetadata, BeanManager beanManager) { if (repositoryMethodMetadata.getQueryInOutMapperClass() != null) { Set<Bean<?>> beans = beanManager.getBeans(repositoryMethodMetadata.getQueryInOutMapperClass()); Class<? extends Annotation> scope = beanManager.resolve(beans).getScope(); repositoryMethodMetadata.setQueryInOutMapperIsNormalScope(beanManager.isNormalScope(scope)); } }
/** * This method will properly destroy the @Dependent scoped instance. * It will have no effect if the bean is NormalScoped as those have their * own lifecycle which we must not disrupt. */ public void destroy() { if (!BeanManagerProvider.getInstance().getBeanManager().isNormalScope(bean.getScope())) { bean.destroy(instance, creationalContext); } }
/** * This method will properly destroy the @Dependent scoped instance. * It will have no effect if the bean is NormalScoped as those have their * own lifecycle which we must not disrupt. */ public void destroy() { if (!BeanManagerProvider.getInstance().getBeanManager().isNormalScope(bean.getScope())) { bean.destroy(instance, creationalContext); } }