private static ClassTransformer getClassTransformer() { TypeStore store = new TypeStore(); SharedObjectCache cache = new SharedObjectCache(); ReflectionCache reflectionCache = ReflectionCacheFactory.newInstance(store); ClassTransformer classTransformer = new ClassTransformer(store, cache, reflectionCache, "STATIC_INSTANCE"); return classTransformer; }
public static <T> EnhancedAnnotatedType<T> createEnhancedAnnotatedType(BasicInjectionTarget<T> it) { return EnhancedAnnotatedTypeImpl.of( (SlimAnnotatedType<T>) it.getAnnotatedType(), ClassTransformer.instance(it.getBeanManager())); }
private static EnhancedAnnotatedType<?> createAnnotatedTypeForExistingBeanClass(String bdaId, Bean<?> bean) { ClassTransformer classTransformer = getClassTransformer(); SlimAnnotatedType<?> annotatedType = classTransformer.getBackedAnnotatedType(bean.getBeanClass(), bdaId); return EnhancedAnnotatedTypeImpl.of(annotatedType, classTransformer); }
public MemberTransformer(ClassTransformer transformer) { ComputingCacheBuilder cacheBuilder = ComputingCacheBuilder.newBuilder(); this.transformer = transformer; this.unbackedAnnotatedMembersById = cacheBuilder.build(new UnbackedMemberById()); this.enhancedFieldLoader = new EnhancedFieldLoader(); this.enhancedMethodLoader = new EnhancedMethodLoader(); this.enhancedConstructorLoader = new EnhancedConstructorLoader(); this.enhancedMemberCache = cacheBuilder.build(new EnhancedMemberLoaderFunction()); }
private InterceptorBindings getInterceptorBindings(final String ejbName, final BeanManagerImpl manager) { InterceptorBindings retVal = null; if (ejbName != null) { retVal = interceptorSupport.getInterceptorBindings(ejbName, manager); } else { // This is a managed bean SlimAnnotatedType<?> type = (SlimAnnotatedType<?>) manager.createAnnotatedType(componentClass); if (!manager.getInterceptorModelRegistry().containsKey(type)) { EnhancedAnnotatedType<?> enhancedType = manager.getServices().get(ClassTransformer.class).getEnhancedAnnotatedType(type); InterceptionModelInitializer.of(manager, enhancedType, null).init(); } InterceptionModel model = manager.getInterceptorModelRegistry().get(type); if (model != null) { retVal = new InterceptorBindingsAdapter(manager.getInterceptorModelRegistry().get(type)); } } return retVal != null ? retVal : NullInterceptorBindings.INSTANCE; }
public ClassTransformer(TypeStore typeStore, SharedObjectCache cache, ReflectionCache reflectionCache, String contextId) { this.contextId = contextId; this.backedAnnotatedTypes = ComputingCacheBuilder.newBuilder().setWeakValues().build(new TransformClassToBackedAnnotatedType()); this.enhancedAnnotatedTypes = ComputingCacheBuilder.newBuilder().build(new TransformSlimAnnotatedTypeToEnhancedAnnotatedType()); this.annotations = ComputingCacheBuilder.newBuilder().build(new TransformClassToWeldAnnotation()); this.typeStore = typeStore; this.cache = cache; this.reflectionCache = reflectionCache; this.slimAnnotatedTypesById = new ConcurrentHashMap<AnnotatedTypeIdentifier, SlimAnnotatedType<?>>(); }
public DefaultReflectionCache(TypeStore store) { this.store = store; ComputingCacheBuilder cacheBuilder = ComputingCacheBuilder.newBuilder(); this.annotations = cacheBuilder.build(ANNOTATIONS_FUNCTION); this.declaredAnnotations = cacheBuilder.build(DECLARED_ANNOTATIONS_FUNCTION); this.backedAnnotatedTypeAnnotations = cacheBuilder.build(new BackedAnnotatedTypeAnnotationsFunction()); this.annotationClasses = cacheBuilder.build(new AnnotationClassFunction()); }
@Override public void cleanup() { cleanupAfterBoot(); } }
@Override public Annotations apply(AnnotatedElement input) { return new Annotations(internalGetAnnotations(input)); } });
@Override public Annotations apply(AnnotatedElement input) { return new Annotations(internalGetDeclaredAnnotations(input)); } });
public MemberTransformer(ClassTransformer transformer) { ComputingCacheBuilder cacheBuilder = ComputingCacheBuilder.newBuilder(); this.transformer = transformer; this.unbackedAnnotatedMembersById = cacheBuilder.build(new UnbackedMemberById()); this.enhancedFieldLoader = new EnhancedFieldLoader(); this.enhancedMethodLoader = new EnhancedMethodLoader(); this.enhancedConstructorLoader = new EnhancedConstructorLoader(); this.enhancedMemberCache = cacheBuilder.build(new EnhancedMemberLoaderFunction()); }
@SuppressWarnings("unchecked") final Class<T> clazz = (Class<T>) componentClass; EnhancedAnnotatedType<T> type = transformer.getEnhancedAnnotatedType(clazz, beanManager.getId()); type = transformer.getEnhancedAnnotatedType(clazz, bdaId);
@SuppressWarnings({ "rawtypes", "unchecked" }) private static void doDefineNewManagedBean(BeanManagerImpl beanManager, String bdaId, Class<?> beanClass) { try { ClassTransformer classTransformer = getClassTransformer(); SlimAnnotatedType<?> annotatedType = classTransformer.getBackedAnnotatedType(beanClass, bdaId); boolean managedBeanOrDecorator = Beans.isTypeManagedBeanOrDecoratorOrInterceptor(annotatedType); if (managedBeanOrDecorator) { EnhancedAnnotatedType eat = EnhancedAnnotatedTypeImpl.of(annotatedType, classTransformer); BeanAttributes attributes = BeanAttributesFactory.forBean(eat, beanManager); ManagedBean<?> bean = ManagedBean.of(attributes, eat, beanManager); ReflectionHelper.set(beanManager, beanManager.getClass(), "beanSet", Collections.synchronizedSet(new HashSet<Bean<?>>())); beanManager.addBean(bean); beanManager.getBeanResolver().clear(); bean.initializeAfterBeanDiscovery(); LOGGER.debug("Bean defined '{}'", beanClass.getName()); } else { // TODO : define session bean LOGGER.warning("Bean NOT? defined '{}', session bean?", beanClass.getName()); } } catch (Exception e) { LOGGER.debug("Bean definition failed.", e); } }
@Override public void cleanup() { cleanupAfterBoot(); } }
public MemberTransformer(ClassTransformer transformer) { ComputingCacheBuilder cacheBuilder = ComputingCacheBuilder.newBuilder(); this.transformer = transformer; this.unbackedAnnotatedMembersById = cacheBuilder.build(new UnbackedMemberById()); this.enhancedFieldLoader = new EnhancedFieldLoader(); this.enhancedMethodLoader = new EnhancedMethodLoader(); this.enhancedConstructorLoader = new EnhancedConstructorLoader(); this.enhancedMemberCache = cacheBuilder.build(new EnhancedMemberLoaderFunction()); }
private void checkDecoratedMethods(EnhancedAnnotatedType<T> type, List<Decorator<?>> decorators) { if (type.isFinal()) { throw BeanLogger.LOG.finalBeanClassWithDecoratorsNotAllowed(this); } checkNoArgsConstructor(type); for (Decorator<?> decorator : decorators) { EnhancedAnnotatedType<?> decoratorClass; if (decorator instanceof DecoratorImpl<?>) { DecoratorImpl<?> decoratorBean = (DecoratorImpl<?>) decorator; decoratorClass = decoratorBean.getBeanManager().getServices().get(ClassTransformer.class) .getEnhancedAnnotatedType(decoratorBean.getAnnotated()); } else if (decorator instanceof CustomDecoratorWrapper<?>) { decoratorClass = ((CustomDecoratorWrapper<?>) decorator).getEnhancedAnnotated(); } else { throw BeanLogger.LOG.nonContainerDecorator(decorator); } for (EnhancedAnnotatedMethod<?, ?> decoratorMethod : decoratorClass.getEnhancedMethods()) { EnhancedAnnotatedMethod<?, ?> method = type.getEnhancedMethod(decoratorMethod.getSignature()); if (method != null && !method.isStatic() && !method.isPrivate() && method.isFinal()) { throw BeanLogger.LOG.finalBeanClassWithInterceptorsNotAllowed(this); } } } }
@Override public void cleanup() { cleanupAfterBoot(); } }
public MemberTransformer(ClassTransformer transformer) { ComputingCacheBuilder cacheBuilder = ComputingCacheBuilder.newBuilder(); this.transformer = transformer; this.unbackedAnnotatedMembersById = cacheBuilder.build(new UnbackedMemberById()); this.enhancedFieldLoader = new EnhancedFieldLoader(); this.enhancedMethodLoader = new EnhancedMethodLoader(); this.enhancedConstructorLoader = new EnhancedConstructorLoader(); this.enhancedMemberCache = cacheBuilder.build(new EnhancedMemberLoaderFunction()); }
public MemberTransformer(ClassTransformer transformer) { ComputingCacheBuilder cacheBuilder = ComputingCacheBuilder.newBuilder(); this.transformer = transformer; this.unbackedAnnotatedMembersById = cacheBuilder.build(new UnbackedMemberById()); this.enhancedFieldLoader = new EnhancedFieldLoader(); this.enhancedMethodLoader = new EnhancedMethodLoader(); this.enhancedConstructorLoader = new EnhancedConstructorLoader(); this.enhancedMemberCache = cacheBuilder.build(new EnhancedMemberLoaderFunction()); }
public MemberTransformer(ClassTransformer transformer) { ComputingCacheBuilder cacheBuilder = ComputingCacheBuilder.newBuilder(); this.transformer = transformer; this.unbackedAnnotatedMembersById = cacheBuilder.build(new UnbackedMemberById()); this.enhancedFieldLoader = new EnhancedFieldLoader(); this.enhancedMethodLoader = new EnhancedMethodLoader(); this.enhancedConstructorLoader = new EnhancedConstructorLoader(); this.enhancedMemberCache = cacheBuilder.build(new EnhancedMemberLoaderFunction()); }