private void buildInterceptionModel(EnhancedAnnotatedType<T> annotatedType, AbstractInstantiator<T> instantiator) { new InterceptionModelInitializer<>(beanManager, annotatedType, annotatedType.getDeclaredEnhancedConstructor( instantiator.getConstructorInjectionPoint().getSignature()), getBean()).init(); }
@Override public Constructor<T> getConstructor() { return injectionPoint.getAnnotated().getJavaMember(); }
@Override public String toString() { return "JerseyInstantiator [constructor=" + injectionPoint.getMember() + "]"; }
protected SubclassedComponentInstantiator(EnhancedAnnotatedType<T> type, Bean<T> bean, ConstructorInjectionPoint<T> originalConstructor, BeanManagerImpl manager) { EnhancedAnnotatedConstructor<T> constructorForEnhancedSubclass = initEnhancedSubclass(manager, type, bean, originalConstructor); this.proxyClassConstructorInjectionPoint = new ProxyClassConstructorInjectionPointWrapper<T>(bean, type.getJavaClass(), constructorForEnhancedSubclass, originalConstructor, manager); this.componentClassConstructor = originalConstructor.getAnnotated().getJavaMember(); }
protected EnhancedAnnotatedConstructor<T> initEnhancedSubclass(BeanManagerImpl manager, EnhancedAnnotatedType<T> type, Bean<?> bean, ConstructorInjectionPoint<T> originalConstructorInjectionPoint) { ClassTransformer transformer = manager.getServices().get(ClassTransformer.class); EnhancedAnnotatedType<T> enhancedSubclass = transformer.getEnhancedAnnotatedType(createEnhancedSubclass(type, bean, manager), type.slim().getIdentifier().getBdaId()); return findMatchingConstructor(originalConstructorInjectionPoint.getSignature(), enhancedSubclass); }
public T newInstance(BeanManagerImpl manager, CreationalContext<?> ctx) { CreationalContext<?> transientReferenceContext = null; if (hasTransientReferenceParameter) { transientReferenceContext = manager.createCreationalContext(null); } try { Object[] parameterValues = getParameterValues(manager, ctx, transientReferenceContext); if (ctx instanceof CreationalContextImpl<?>) { CreationalContextImpl<T> weldCtx = Reflections.cast(ctx); return invokeAroundConstructCallbacks(parameterValues, weldCtx); } else { return newInstance(parameterValues); } } finally { if (hasTransientReferenceParameter) { transientReferenceContext.release(); } } }
protected void buildInterceptionModel(EnhancedAnnotatedType<T> annotatedType, AbstractInstantiator<T> instantiator) { new InterceptionModelInitializer<T>(beanManager, annotatedType, instantiator.getConstructorInjectionPoint().getAnnotated(), getBean()).init(); }
private T invokeAroundConstructCallbacks(Object[] parameters, CreationalContextImpl<T> ctx) { final List<AroundConstructCallback<T>> callbacks = ctx.getAroundConstructCallbacks(); if (callbacks.isEmpty()) { return newInstance(parameters); } final Iterator<AroundConstructCallback<T>> iterator = callbacks.iterator(); return invokeAroundConstructCallback(iterator.next(), new ConstructionHandle<T>() { @Override public T proceed(Object[] parameters, Map<String, Object> data) { if (iterator.hasNext()) { return invokeAroundConstructCallback(iterator.next(), this, getComponentConstructor(), parameters, data); } else { return newInstance(parameters); } } }, getComponentConstructor(), parameters, new HashMap<String, Object>()); }
/** * Helper method for getting the current parameter values from a list of annotated parameters. * * @param parameters The list of annotated parameter to look up * @param manager The Bean manager * @return The object array of looked up values */ public Object[] getParameterValues(BeanManagerImpl manager, CreationalContext<?> ctx, CreationalContext<?> transientReference) { if (getInjectionPoints().isEmpty()) { return Arrays2.EMPTY_ARRAY; } Object[] parameterValues = new Object[getParameterInjectionPoints().size()]; List<ParameterInjectionPoint<?, T>> parameters = getParameterInjectionPoints(); for (int i = 0; i < parameterValues.length; i++) { ParameterInjectionPoint<?, ?> param = parameters.get(i); if (hasTransientReferenceParameter && param.getAnnotated().isAnnotationPresent(TransientReference.class)) { parameterValues[i] = param.getValueToInject(manager, transientReference); } else { parameterValues[i] = param.getValueToInject(manager, ctx); } } return parameterValues; }
@Override protected Instantiator<T> initInstantiator(EnhancedAnnotatedType<T> type, Bean<T> bean, BeanManagerImpl beanManager, Set<InjectionPoint> injectionPoints) { if (type.isAbstract()) { ConstructorInjectionPoint<T> originalConstructor = InjectionPointFactory.instance().createConstructorInjectionPoint(bean, type, beanManager); injectionPoints.addAll(originalConstructor.getParameterInjectionPoints()); final WeldInjectionPointAttributes<?, ?> delegateInjectionPoint = Decorators.findDelegateInjectionPoint(type, injectionPoints); return new SubclassedComponentInstantiator<T>(type, bean, originalConstructor, beanManager) { @Override protected Class<T> createEnhancedSubclass(EnhancedAnnotatedType<T> type, Bean<?> bean, BeanManagerImpl manager) { return new DecoratorProxyFactory<T>(manager.getContextId(), type.getJavaClass(), delegateInjectionPoint, bean).getProxyClass(); } }; } else { DefaultInstantiator<T> instantiator = new DefaultInstantiator<T>(type, bean, beanManager); injectionPoints.addAll(instantiator.getConstructorInjectionPoint().getParameterInjectionPoints()); return instantiator; } }
@Override public T proceed(Object[] parameters, Map<String, Object> data) { if (iterator.hasNext()) { return invokeAroundConstructCallback(iterator.next(), this, getComponentConstructor(), parameters, data); } else { return newInstance(parameters); } } }, getComponentConstructor(), parameters, new HashMap<String, Object>());
@Override protected Instantiator<T> initInstantiator(EnhancedAnnotatedType<T> type, Bean<T> bean, BeanManagerImpl beanManager, Set<InjectionPoint> injectionPoints) { if (bean instanceof SessionBean<?>) { EnhancedAnnotatedType<T> implementationClass = Beans.getEjbImplementationClass((SessionBean<T>) bean); AbstractInstantiator<T> instantiator = null; if (type.equals(implementationClass)) { instantiator = new DefaultInstantiator<T>(type, bean, beanManager); } else { // Session bean subclassed by the EJB container instantiator = SubclassedComponentInstantiator.forSubclassedEjb(type, implementationClass, bean, beanManager); } injectionPoints.addAll(instantiator.getConstructorInjectionPoint().getParameterInjectionPoints()); return instantiator; } else { throw new IllegalArgumentException("Cannot create SessionBeanInjectionTarget for " + bean); } }
@Override public List<ParameterInjectionPoint<?, T>> getParameterInjectionPoints() { return originalConstructorInjectionPoint.getParameterInjectionPoints(); }
@Override public AnnotatedConstructor<T> getComponentConstructor() { return originalConstructorInjectionPoint.getAnnotated(); }
@Override public String toString() { return "SubclassedComponentInstantiator for " + proxyClassConstructorInjectionPoint.getType(); }
public <T> ConstructorInjectionPoint<T> createConstructorInjectionPoint(Bean<T> declaringBean, Class<?> declaringComponentClass, EnhancedAnnotatedConstructor<T> constructor, BeanManagerImpl manager) { return new ConstructorInjectionPoint<T>(constructor, declaringBean, declaringComponentClass, this, manager); }
@Override public boolean equals(Object obj) { if (this == obj) { return true; } if (!super.equals(obj)) { return false; } if (getClass() != obj.getClass()) { return false; } ProxyClassConstructorInjectionPointWrapper<?> other = (ProxyClassConstructorInjectionPointWrapper<?>) obj; if (originalConstructorInjectionPoint == null) { if (other.originalConstructorInjectionPoint != null) { return false; } } else if (!originalConstructorInjectionPoint.equals(other.originalConstructorInjectionPoint)) { return false; } return true; }
protected SubclassedComponentInstantiator(EnhancedAnnotatedType<T> type, Bean<T> bean, ConstructorInjectionPoint<T> originalConstructor, BeanManagerImpl manager) { EnhancedAnnotatedConstructor<T> constructorForEnhancedSubclass = initEnhancedSubclass(manager, type, bean, originalConstructor); this.proxyClassConstructorInjectionPoint = new ProxyClassConstructorInjectionPointWrapper<T>(bean, type.getJavaClass(), constructorForEnhancedSubclass, originalConstructor, manager); this.componentClassConstructor = originalConstructor.getAnnotated().getJavaMember(); }
protected EnhancedAnnotatedConstructor<T> initEnhancedSubclass(BeanManagerImpl manager, EnhancedAnnotatedType<T> type, Bean<?> bean, ConstructorInjectionPoint<T> originalConstructorInjectionPoint) { ClassTransformer transformer = manager.getServices().get(ClassTransformer.class); EnhancedAnnotatedType<T> enhancedSubclass = transformer.getEnhancedAnnotatedType(createEnhancedSubclass(type, bean, manager), type.slim().getIdentifier().getBdaId()); return findMatchingConstructor(originalConstructorInjectionPoint.getSignature(), enhancedSubclass); }
public T newInstance(BeanManagerImpl manager, CreationalContext<?> ctx) { CreationalContext<?> transientReferenceContext = null; if (hasTransientReferenceParameter) { transientReferenceContext = manager.createCreationalContext(null); } try { Object[] parameterValues = getParameterValues(manager, ctx, transientReferenceContext); if (ctx instanceof CreationalContextImpl<?>) { CreationalContextImpl<T> weldCtx = Reflections.cast(ctx); return invokeAroundConstructCallbacks(parameterValues, weldCtx); } else { return newInstance(parameterValues); } } finally { if (hasTransientReferenceParameter) { transientReferenceContext.release(); } } }