/** * 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); }
@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); } }
final InjectionTarget<CdiExternalRequestScope> interceptorTarget = beanManager.createInjectionTarget(requestScopeType);
final InjectionTarget<ValidationInterceptor> interceptorTarget = beanManager.createInjectionTarget(interceptorType);
this.injectionTarget = beanManager.createInjectionTarget( annotatedType ); this.creationalContext = beanManager.createCreationalContext( null );
/** * 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 ); }
public Unmanaged(BeanManager beanManager, java.lang.Class<T> clazz) { this.beanManager = beanManager; AnnotatedType<T> annotatedType = beanManager.createAnnotatedType(clazz); injectionTarget = beanManager.createInjectionTarget(annotatedType); }
public Unmanaged(BeanManager beanManager, java.lang.Class<T> clazz) { this.beanManager = beanManager; AnnotatedType<T> annotatedType = beanManager.createAnnotatedType(clazz); injectionTarget = beanManager.createInjectionTarget(annotatedType); }
public Unmanaged(BeanManager beanManager, java.lang.Class<T> clazz) { this.beanManager = beanManager; AnnotatedType<T> annotatedType = beanManager.createAnnotatedType(clazz); injectionTarget = beanManager.createInjectionTarget(annotatedType); }
@SuppressWarnings("unchecked") private NonContextual(BeanManager manager, Class<? extends T> clazz) { this.manager = manager; AnnotatedType<? extends T> type = manager.createAnnotatedType(clazz); this.it = (InjectionTarget<T>)manager.createInjectionTarget(type); }
public RequestDispatcherMetaData(final BeanManager bm, final RequestDispatcher delegate) { //use this to read annotations of the class final AnnotatedType at = bm.createAnnotatedType(delegate.getClass()); //use this to create the class and inject dependencies this.it = bm.createInjectionTarget(at); // invocation target this.delegate = delegate; }
@Override public void postConstruct(Object instance, Object creationMetaData) throws InjectionProviderException { AnnotatedType annoType = beanManager.createAnnotatedType(instance.getClass()); InjectionTarget target = beanManager.createInjectionTarget(annoType); target.postConstruct(instance); }
@Override void register(BeanManager manager) { super.register(manager); // this.at = manager.createAnnotatedType(instance.getClass()); this.it = manager.createInjectionTarget(at); }
@SuppressWarnings("unchecked") private NonContextual(Class<? extends T> clazz) { BeanManager manager = BeanManagerLookup.lookup(); AnnotatedType<? extends T> type = manager.createAnnotatedType(clazz); this.it = (InjectionTarget<T>)manager.createInjectionTarget(type); }
private <T> void inject(final BeanManager beanManager, Class<T> type, T constraintValidatorFactory) { AnnotatedType<T> annotatedType = beanManager.createAnnotatedType(type); InjectionTarget<T> it = beanManager.createInjectionTarget(annotatedType); CreationalContext<T> cvfCtx = beanManager.createCreationalContext(null); it.inject(constraintValidatorFactory, cvfCtx); it.postConstruct(constraintValidatorFactory); }
private static CreationalContext<Object> doInject(final Object instance) { final BeanManager bm = CDI.current().getBeanManager(); final AnnotatedType<?> annotatedType = bm.createAnnotatedType(instance.getClass()); final InjectionTarget injectionTarget = bm.createInjectionTarget(annotatedType); final CreationalContext<Object> creationalContext = bm.createCreationalContext(null); injectionTarget.inject(instance, creationalContext); return creationalContext; }
@Test(expectedExceptions = IllegalArgumentException.class) @SpecAssertion(section = BM_OBTAIN_INJECTIONTARGET, id = "ab") public void testObtainingInjectionTargetWithDefinitionError() { AnnotatedType<?> annotatedType = getCurrentManager().createAnnotatedType(Snake.class); getCurrentManager().createInjectionTarget(annotatedType); }
@PostConstruct public void init() throws ServletException { BeanManager manager = CDI.current().getBeanManager(); AnnotatedType<VRaptor> type = manager.createAnnotatedType(VRaptor.class); InjectionTarget<VRaptor> target = manager.createInjectionTarget(type); CreationalContext<VRaptor> ctx = manager.createCreationalContext(null); target.inject(filter, ctx); MockFilterConfig cfg = new MockFilterConfig(context); filter.init(cfg); }