/** * 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); }
/** * 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); }
private static boolean hasAnnotation(final Annotated element, final Set<Class<? extends Annotation>> annotations) { for (final Class<? extends Annotation> a : annotations) { if (element.isAnnotationPresent(a)) { return true; } } return false; }
@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); } }
@Override public T getInstance(final Class<T> clazz) { final CreationalContext<T> creationalContext = beanManager.createCreationalContext(null); final T instance = injectionTarget.produce(creationalContext); injectionTarget.inject(instance, creationalContext); if (injectionManager != null) { injectionManager.inject(instance, CdiComponentProvider.CDI_CLASS_ANALYZER); } injectionTarget.postConstruct(instance); return instance; }
@Override public Supplier<T> create(CreationalContext<Supplier<T>> context) { Supplier<T> instance = injectionTarget.produce(context); injectionTarget.inject(instance, context); injectionTarget.postConstruct(instance); return instance; }
@Override @SuppressWarnings("unchecked") public Object getInstance(ForeignDescriptor foreignDescriptor) { Bean bean = (Bean) foreignDescriptor.get(); CreationalContext ctx = beanManager.createCreationalContext(bean); return bean.create(ctx); }
@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)); } }
@Override public void preDestroy(final T instance) { injectionTarget.preDestroy(instance); } };
@Override public boolean isAnnotationPresent(final Class<? extends Annotation> annotationType) { return annotatedType.isAnnotationPresent(annotationType); } });
/** * Calls the observer method, passing the given event context. * <p> * The container should always call this method, but the default implementation delegates to {@link #notify(Object)}. * <p> * The implementation of this method for a custom observer method is responsible for deciding whether to call the method if * the {@link #getReception()} returns {@link Reception#IF_EXISTS}. * * @param eventContext {@link EventContext} used to notify observers */ public default void notify(EventContext<T> eventContext) { notify(eventContext.getEvent()); }
@Override public boolean isAnnotationPresent(final Class<? extends Annotation> annotationType) { return ctor.isAnnotationPresent(annotationType); } };
@Override public AnnotatedType getDeclaringType() { return ctor.getDeclaringType(); }
@Override @SuppressWarnings("unchecked") public CdiRequestScope create(CreationalContext<CdiRequestScope> context) { CdiRequestScope instance = injectionTarget.produce(context); injectionTarget.inject(instance, context); injectionTarget.postConstruct(instance); return instance; }
/** * 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); }
@Override public CdiExternalRequestScope create(CreationalContext<CdiExternalRequestScope> ctx) { final CdiExternalRequestScope result = interceptorTarget.produce(ctx); interceptorTarget.inject(result, ctx); interceptorTarget.postConstruct(result); return result; }
/** * 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); }
@Override @SuppressWarnings("unchecked") public T create(CreationalContext<T> context) { T instance = injectionTarget.produce(context); injectionTarget.inject(instance, context); injectionTarget.postConstruct(instance); return instance; }
@SuppressWarnings("unused") private void beforeBeanDiscovery(@Observes final BeforeBeanDiscovery beforeBeanDiscovery, final javax.enterprise.inject.spi.BeanManager beanManager) { beforeBeanDiscovery.addAnnotatedType(beanManager.createAnnotatedType(JaxRsParamProducer.class)); }
@Override public ValidationInterceptor create(CreationalContext<ValidationInterceptor> ctx) { final ValidationInterceptor result = interceptorTarget.produce(ctx); interceptorTarget.inject(result, ctx); interceptorTarget.postConstruct(result); return result; }