Ejemplo n.º 1
0
  private void introspectInjectClass(
      AnnotatedType<X> type, ArrayList<ConfigProgram> injectProgramList) {
    InjectManager cdiManager = getBeanManager();

    for (Annotation ann : type.getAnnotations()) {
      Class<? extends Annotation> annType = ann.annotationType();

      InjectionPointHandler handler = cdiManager.getInjectionPointHandler(annType);

      if (handler != null) {
        injectProgramList.add(new ClassHandlerProgram(ann, handler));
      }
    }

    // ioc/123i
    for (Class<?> parentClass = type.getJavaClass().getSuperclass();
        parentClass != null;
        parentClass = parentClass.getSuperclass()) {
      for (Annotation ann : parentClass.getAnnotations()) {
        Class<? extends Annotation> annType = ann.annotationType();

        InjectionPointHandler handler = cdiManager.getInjectionPointHandler(annType);

        if (handler != null) {
          injectProgramList.add(new ClassHandlerProgram(ann, handler));
        }
      }
    }
  }
Ejemplo n.º 2
0
 /**
  * Generates a unique signature for an annotated type. Members without annotations are omitted to
  * reduce the length of the signature
  *
  * @param <X>
  * @param annotatedType
  * @return
  */
 public static <X> String createTypeId(AnnotatedType<X> annotatedType) {
   return createTypeId(
       annotatedType.getJavaClass(),
       annotatedType.getAnnotations(),
       annotatedType.getMethods(),
       annotatedType.getFields(),
       annotatedType.getConstructors());
 }
Ejemplo n.º 3
0
 /**
  * Read the {@link AnnotatedType}, creating a bean from the class and it's annotations.
  *
  * <p>
  *
  * <p>By default the bean lifecycle will wrap the result of calling {@link
  * BeanManager#createInjectionTarget(AnnotatedType)}.
  *
  * <p>
  *
  * <p>{@link BeanBuilder} does <em>not</em> support reading members of the class to create
  * producers or observer methods.
  *
  * @param type the type to read
  */
 public BeanBuilder<T> readFromType(AnnotatedType<T> type) {
   this.beanClass = type.getJavaClass();
   InjectionTarget<T> injectionTarget;
   if (!type.getJavaClass().isInterface()) {
     injectionTarget = beanManager.createInjectionTarget(type);
   } else {
     injectionTarget = new DummyInjectionTarget<T>();
   }
   this.beanLifecycle = new DelegatingContextualLifecycle<T>(injectionTarget);
   this.injectionPoints = injectionTarget.getInjectionPoints();
   this.qualifiers = new HashSet<Annotation>();
   this.stereotypes = new HashSet<Class<? extends Annotation>>();
   this.types = new HashSet<Type>();
   for (Annotation annotation : type.getAnnotations()) {
     if (beanManager.isQualifier(annotation.annotationType())) {
       this.qualifiers.add(annotation);
     } else if (beanManager.isScope(annotation.annotationType())) {
       this.scope = annotation.annotationType();
     } else if (beanManager.isStereotype(annotation.annotationType())) {
       this.stereotypes.add(annotation.annotationType());
     }
     if (annotation instanceof Named) {
       this.name = ((Named) annotation).value();
     }
     if (annotation instanceof Alternative) {
       this.alternative = true;
     }
   }
   if (this.scope == null) {
     this.scope = Dependent.class;
   }
   for (Class<?> c = type.getJavaClass(); c != Object.class && c != null; c = c.getSuperclass()) {
     this.types.add(c);
   }
   for (Class<?> i : type.getJavaClass().getInterfaces()) {
     this.types.add(i);
   }
   if (qualifiers.isEmpty()) {
     qualifiers.add(new DefaultLiteral());
   }
   qualifiers.add(new AnyLiteral());
   this.id = ImmutableBeanWrapper.class.getName() + ":" + Annotateds.createTypeId(type);
   return this;
 }
Ejemplo n.º 4
0
 private UnbackedAnnotatedType(
     AnnotatedType<X> source, AnnotatedTypeIdentifier identifier, SharedObjectCache cache) {
   super(source.getBaseType(), source.getTypeClosure(), source.getAnnotations());
   this.javaClass = source.getJavaClass();
   ImmutableSet.Builder<AnnotatedConstructor<X>> constructors = ImmutableSet.builder();
   for (AnnotatedConstructor<X> constructor : source.getConstructors()) {
     constructors.add(UnbackedAnnotatedConstructor.of(constructor, this, cache));
   }
   this.constructors = constructors.build();
   ImmutableSet.Builder<AnnotatedMethod<? super X>> methods = ImmutableSet.builder();
   for (AnnotatedMethod<? super X> originalMethod : source.getMethods()) {
     methods.add(UnbackedAnnotatedMethod.of(originalMethod, this, cache));
   }
   this.methods = methods.build();
   ImmutableSet.Builder<AnnotatedField<? super X>> fields = ImmutableSet.builder();
   for (AnnotatedField<? super X> originalField : source.getFields()) {
     fields.add(UnbackedAnnotatedField.of(originalField, this, cache));
   }
   this.fields = fields.build();
   this.identifier = identifier;
 }