Example #1
0
 private void validateBean(Bean<?> bean, BeanManagerImpl beanManager) {
   for (InjectionPoint ij : bean.getInjectionPoints()) {
     validateInjectionPoint(ij, beanManager);
   }
   boolean normalScoped =
       beanManager
           .getServices()
           .get(MetaAnnotationStore.class)
           .getScopeModel(bean.getScope())
           .isNormal();
   if (normalScoped && !Beans.isBeanProxyable(bean)) {
     throw Proxies.getUnproxyableTypesException(bean);
   }
   if (!normalScoped) {
     validatePseudoScopedBean(bean, beanManager);
   }
 }
  /**
   * Constructor
   *
   * <p>Also builds the meta-annotation map. Throws a NullPointerException if trying to register a
   * null map
   *
   * @param annotationMap A map of annotation to register
   */
  public AbstractWeldAnnotated(
      Map<Class<? extends Annotation>, Annotation> annotationMap,
      Map<Class<? extends Annotation>, Annotation> declaredAnnotationMap,
      ClassTransformer classTransformer,
      Class<T> rawType,
      Type type,
      Set<Type> typeClosure) {
    if (annotationMap == null) {
      throw new WeldException(ANNOTATION_MAP_NULL);
    }
    this.annotationMap = annotationMap;
    this.metaAnnotationMap = new ArraySetMultimap<Class<? extends Annotation>, Annotation>();
    for (Annotation annotation : annotationMap.values()) {
      addMetaAnnotations(
          metaAnnotationMap, annotation, annotation.annotationType().getAnnotations(), false);
      addMetaAnnotations(
          metaAnnotationMap,
          annotation,
          classTransformer.getTypeStore().get(annotation.annotationType()),
          false);
    }
    metaAnnotationMap.trimToSize();

    if (declaredAnnotationMap == null) {
      throw new WeldException(DECLARED_ANNOTATION_MAP_NULL);
    }
    this.rawType = rawType;
    this.type = type;
    if (type instanceof ParameterizedType) {
      this.actualTypeArguments = ((ParameterizedType) type).getActualTypeArguments();
    } else {
      this.actualTypeArguments = new Type[0];
    }
    this.typeClosure = Collections.unmodifiableSet(new ArraySet<Type>(typeClosure));
    this.proxyable = Proxies.isTypesProxyable(typeClosure);
  }
Example #3
0
 /**
  * Variation of the validateInjectionPoint method which allows the bean to be defined explicitly
  * (used for disposer method validation)
  */
 public void validateInjectionPoint(InjectionPoint ij, Bean<?> bean, BeanManagerImpl beanManager) {
   if (ij.getAnnotated().getAnnotation(New.class) != null && ij.getQualifiers().size() > 1) {
     throw new DefinitionException(NEW_WITH_QUALIFIERS, ij);
   }
   if (ij.getType().equals(InjectionPoint.class) && bean == null) {
     throw new DefinitionException(INJECTION_INTO_NON_BEAN, ij);
   }
   if (ij.getType().equals(InjectionPoint.class) && !Dependent.class.equals(bean.getScope())) {
     throw new DefinitionException(INJECTION_INTO_NON_DEPENDENT_BEAN, ij);
   }
   if (ij.getType() instanceof TypeVariable<?>) {
     throw new DefinitionException(INJECTION_POINT_WITH_TYPE_VARIABLE, ij);
   }
   if (!(ij.getMember() instanceof Field)
       && ij.getAnnotated().isAnnotationPresent(Named.class)
       && ij.getAnnotated().getAnnotation(Named.class).value().equals("")) {
     throw new DefinitionException(NON_FIELD_INJECTION_POINT_CANNOT_USE_NAMED, ij);
   }
   boolean newBean = (bean instanceof NewManagedBean<?>) || (bean instanceof NewSessionBean<?>);
   if (!newBean) {
     checkScopeAnnotations(ij, beanManager.getServices().get(MetaAnnotationStore.class));
   }
   checkFacadeInjectionPoint(ij, Instance.class);
   checkFacadeInjectionPoint(ij, Event.class);
   Annotation[] bindings = ij.getQualifiers().toArray(new Annotation[0]);
   Set<?> resolvedBeans = beanManager.getBeanResolver().resolve(beanManager.getBeans(ij));
   if (!isInjectionPointSatisfied(ij, resolvedBeans, beanManager)) {
     throw new DeploymentException(
         INJECTION_POINT_HAS_UNSATISFIED_DEPENDENCIES,
         ij,
         Formats.formatAnnotations(bindings),
         Formats.formatType(ij.getType()));
   }
   if (resolvedBeans.size() > 1 && !ij.isDelegate()) {
     throw new DeploymentException(
         INJECTION_POINT_HAS_AMBIGUOUS_DEPENDENCIES,
         ij,
         Formats.formatAnnotations(bindings),
         Formats.formatType(ij.getType()),
         resolvedBeans);
   }
   // Account for the case this is disabled decorator
   if (!resolvedBeans.isEmpty()) {
     Bean<?> resolvedBean = (Bean<?>) resolvedBeans.iterator().next();
     if (beanManager
         .getServices()
         .get(MetaAnnotationStore.class)
         .getScopeModel(resolvedBean.getScope())
         .isNormal()) {
       UnproxyableResolutionException ue = Proxies.getUnproxyableTypeException(ij.getType());
       if (ue != null) {
         UnproxyableResolutionException exception =
             new UnproxyableResolutionException(
                 INJECTION_POINT_HAS_NON_PROXYABLE_DEPENDENCIES, ij);
         exception.initCause(ue);
         throw exception;
       }
     }
     if (Reflections.isPrimitive(ij.getType()) && resolvedBean.isNullable()) {
       throw new NullableDependencyException(INJECTION_POINT_HAS_NULLABLE_DEPENDENCIES, ij);
     }
     if (bean != null
         && Beans.isPassivatingScope(bean, beanManager)
         && (!ij.isTransient())
         && !Beans.isPassivationCapableBean(resolvedBean)) {
       validateInjectionPointPassivationCapable(ij, resolvedBean, beanManager);
     }
   }
 }
Example #4
0
 public static <T> T createProxy(MethodHandler methodHandler, TypeInfo typeInfo)
     throws IllegalAccessException, InstantiationException {
   return Proxies.<T>createProxyClass(methodHandler, typeInfo).newInstance();
 }