Пример #1
0
 static Class<?> getDeclaringRawType(InjectionPoint injectionPoint) {
   if (injectionPoint.getBean() != null) {
     return getRawType(injectionPoint.getBean().getBeanClass());
   } else {
     return getRawType(injectionPoint.getMember().getDeclaringClass());
   }
 }
Пример #2
0
 private void validateInjectionPoints(Set<InjectionPoint> injectionPoints) {
   assertEquals(2, injectionPoints.size());
   for (InjectionPoint ip : injectionPoints) {
     AnnotatedParameter<Factory> parameter =
         this.<AnnotatedParameter<Factory>>cast(ip.getAnnotated());
     if (parameter.getPosition() == 0) {
       // BeanManager
       assertEquals(BeanManager.class, parameter.getBaseType());
     } else if (parameter.getPosition() == 1) {
       // SpaceSuit<Toy>
       Type baseType = parameter.getBaseType();
       if (baseType instanceof ParameterizedType
           && ((ParameterizedType) baseType).getRawType() instanceof Class<?>) {
         assertEquals(((ParameterizedType) baseType).getRawType(), SpaceSuit.class);
       } else {
         fail();
       }
     } else {
       fail("Unexpected injection point " + ip);
     }
     assertFalse(ip.isDelegate());
     assertFalse(ip.isTransient());
     assertNull(ip.getBean());
   }
 }
Пример #3
0
 private void validateDecorators(BeanManagerImpl beanManager, AbstractClassBean<?> classBean) {
   if (classBean.getDecorators().size() > 0) {
     boolean passivationCapabilityCheckRequired =
         isPassivationCapabilityCheckRequired(beanManager, classBean);
     for (Decorator<?> decorator : classBean.getDecorators()) {
       if (passivationCapabilityCheckRequired) {
         boolean isSerializable =
             (decorator instanceof WeldDecorator<?>)
                 ? (((WeldDecorator<?>) decorator).getWeldAnnotated().isSerializable())
                 : (decorator instanceof PassivationCapable);
         if (!isSerializable) {
           throw new UnserializableDependencyException(
               PASSIVATING_BEAN_WITH_NONSERIALIZABLE_DECORATOR, classBean, decorator);
         }
       }
       for (InjectionPoint ij : decorator.getInjectionPoints()) {
         if (!ij.isDelegate()) {
           Bean<?> resolvedBean = beanManager.resolve(beanManager.getBeans(ij));
           validateInjectionPoint(ij, beanManager);
           if (passivationCapabilityCheckRequired) {
             validateInjectionPointPassivationCapable(ij, resolvedBean, beanManager);
           }
         }
       }
     }
   }
 }
Пример #4
0
 @Produces
 @RequestParam
 public String produce(InjectionPoint ip) {
   RequestParam requestParam = ip.getAnnotated().getAnnotation(RequestParam.class);
   String paramName =
       requestParam.value().equals("") ? ip.getMember().getName() : requestParam.value();
   return req.getParameter(paramName);
 }
Пример #5
0
  public static Object[] generateProxyDelegate(
      InjectManager manager,
      List<Decorator<?>> beans,
      Object delegateProxy,
      CreationalContextImpl<?> parentEnv) {
    Object[] instances = new Object[beans.size()];

    DependentCreationalContext<Object> proxyEnv =
        new DependentCreationalContext<Object>(DelegateProxyBean.BEAN, parentEnv, null);

    proxyEnv.push(delegateProxy);

    for (int i = 0; i < beans.size(); i++) {
      Decorator<?> bean = beans.get(i);

      CreationalContextImpl<?> env = new DependentCreationalContext(bean, proxyEnv, null);

      Object instance = manager.getReference(bean, bean.getBeanClass(), env);

      // XXX:
      InjectionPoint ip = getDelegate(bean);

      if (ip.getMember() instanceof Field) {
        Field field = (Field) ip.getMember();
        field.setAccessible(true);

        try {
          field.set(instance, delegateProxy);
        } catch (Exception e) {
          throw new InjectionException(e);
        }
      } else if (ip.getMember() instanceof Method) {
        Method method = (Method) ip.getMember();
        method.setAccessible(true);

        try {
          method.invoke(instance, delegateProxy);
        } catch (Exception e) {
          throw new InjectionException(e);
        }
      }

      /*
      DecoratorBean<?> decoratorBean = (DecoratorBean<?>) bean;
      decoratorBean.setDelegate(instance, proxy);
      */

      instances[beans.size() - i - 1] = instance;

      if (parentEnv instanceof CreationalContextImpl<?>) {
        // InjectionPoint ip = decoratorBean.getDelegateInjectionPoint();

        ((CreationalContextImpl<?>) parentEnv).setInjectionPoint(ip);
      }
    }

    return instances;
  }
Пример #6
0
 private static Annotation[] getFacadeEventQualifiers(InjectionPoint injectionPoint) {
   if (!injectionPoint.getAnnotated().isAnnotationPresent(Default.class)) {
     Set<Annotation> qualifers = new HashSet<Annotation>(injectionPoint.getQualifiers());
     qualifers.remove(DefaultLiteral.INSTANCE);
     return qualifers.toArray(EMPTY_ANNOTATIONS);
   } else {
     return injectionPoint.getQualifiers().toArray(EMPTY_ANNOTATIONS);
   }
 }
Пример #7
0
  private static InjectionPoint getDelegate(Decorator<?> bean) {
    if (bean instanceof DecoratorBean) return ((DecoratorBean) bean).getDelegateInjectionPoint();

    for (InjectionPoint ip : bean.getInjectionPoints()) {
      if (ip.isDelegate()) return ip;
    }

    throw new IllegalStateException(String.valueOf(bean));
  }
Пример #8
0
 public void validateInjectionPointPassivationCapable(
     InjectionPoint ij, Bean<?> resolvedBean, BeanManagerImpl beanManager) {
   if (!ij.isTransient() && !Beans.isPassivationCapableDependency(resolvedBean)) {
     if (resolvedBean.getScope().equals(Dependent.class)
         && resolvedBean instanceof AbstractProducerBean<?, ?, ?>) {
       throw new IllegalProductException(
           NON_SERIALIZABLE_BEAN_INJECTED_INTO_PASSIVATING_BEAN, ij.getBean(), resolvedBean);
     }
     throw new UnserializableDependencyException(
         INJECTION_POINT_HAS_NON_SERIALIZABLE_DEPENDENCY, ij.getBean(), resolvedBean);
   }
 }
Пример #9
0
 private static boolean isInjectionPointSatisfied(
     InjectionPoint ij, Set<?> resolvedBeans, BeanManagerImpl beanManager) {
   if (ij.getBean() instanceof Decorator<?>) {
     if (beanManager.getEnabled().getDecorator(ij.getBean().getBeanClass()) != null) {
       return resolvedBeans.size() > 0;
     } else {
       return true;
     }
   } else {
     return resolvedBeans.size() > 0;
   }
 }
Пример #10
0
  @Produces
  public Logger produceLogger(InjectionPoint injectionPoint) {
    Bean<?> bean = injectionPoint.getBean();
    Class<?> clazz;

    if (bean == null) {
      clazz = injectionPoint.getMember().getDeclaringClass();
    } else {
      clazz = bean.getBeanClass();
    }

    return produceLogger(clazz);
  }
Пример #11
0
 public void validateProducer(Producer<?> producer) {
   if (container.getState().equals(ContainerState.VALIDATED)
       || container.getState().equals(ContainerState.INITIALIZED)) {
     // We are past the bootstrap and therefore we can validate the producer immediately
     validator.validateProducer(producer, beanManager);
   } else {
     // Validate injection points for definition errors now
     for (InjectionPoint ip : producer.getInjectionPoints()) {
       validator.validateInjectionPointForDefinitionErrors(ip, ip.getBean(), beanManager);
       validator.validateEventMetadataInjectionPoint(ip);
     }
     // Schedule validation for deployment problems to be done later
     producersToValidate.add(producer);
   }
 }
Пример #12
0
 @Produces
 Logger produceLog(InjectionPoint injectionPoint) {
   Annotated annotated = injectionPoint.getAnnotated();
   if (annotated.isAnnotationPresent(Category.class)) {
     if (annotated.isAnnotationPresent(Suffix.class)) {
       return getLogger(
           annotated.getAnnotation(Category.class).value(),
           annotated.getAnnotation(Suffix.class).value());
     } else {
       return getLogger(annotated.getAnnotation(Category.class).value());
     }
   } else if (annotated.isAnnotationPresent(TypedCategory.class)) {
     if (annotated.isAnnotationPresent(Suffix.class)) {
       return getLogger(
           annotated.getAnnotation(TypedCategory.class).value(),
           annotated.getAnnotation(Suffix.class).value());
     } else {
       return getLogger(annotated.getAnnotation(TypedCategory.class).value());
     }
   } else {
     if (annotated.isAnnotationPresent(Suffix.class)) {
       return getLogger(
           getDeclaringRawType(injectionPoint), annotated.getAnnotation(Suffix.class).value());
     } else {
       return getLogger(getDeclaringRawType(injectionPoint));
     }
   }
 }
  @Produces
  protected OAuthSession resolveSession(
      InjectionPoint ip, @Current UserSessionRepository repository) {
    if (ip == null) return repository.getCurrent();
    Set<Annotation> quals = ip.getQualifiers();
    OAuthSession res;

    Annotation service = null;
    boolean iscurrent = false;
    for (Annotation qual : quals) {
      if (qual.annotationType().isAnnotationPresent(ProviderRelated.class)) {
        if (service != null)
          throw new AgoravaException(
              "There's more thant one provider related qualifier aon Injection Point" + ip);
        service = qual;
      }
      if (qual.annotationType().equals(Current.class)) iscurrent = true;
    }
    if (iscurrent) {
      if (service != null) {
        if (!service.equals(repository.getCurrent().getServiceQualifier())) {
          repository.setCurrent(
              new OAuthSession.Builder().qualifier(service).repo(repository).build());
        }
      }
      return repository.getCurrent();
    }
    throw new UnsupportedOperationException(
        "Cannot inject session whitout Current Qualifier in " + ip);
  }
Пример #14
0
  public static Annotated getResourceAnnotated(InjectionPoint injectionPoint) {

    if (injectionPoint instanceof ParameterInjectionPoint) {
      return ((ParameterInjectionPoint<?, ?>) injectionPoint).getAnnotated().getDeclaringCallable();
    }
    return injectionPoint.getAnnotated();
  }
Пример #15
0
 private void checkScopeAnnotations(InjectionPoint ij, MetaAnnotationStore metaAnnotationStore) {
   for (Annotation annotation : ij.getAnnotated().getAnnotations()) {
     if (hasScopeMetaAnnotation(annotation)) {
       log.warn(SCOPE_ANNOTATION_ON_INJECTION_POINT, annotation, ij);
     }
   }
 }
Пример #16
0
 @Inject
 public StateBuilder(InjectionPoint ip) {
   if (ip != null) {
     this.type = ip.getMember().getDeclaringClass();
     INSTANCE = this;
   }
 }
Пример #17
0
 private static void checkFacadeInjectionPoint(InjectionPoint injectionPoint, Class<?> type) {
   if (injectionPoint.getAnnotated().getBaseType().equals(type)) {
     if (injectionPoint.getType() instanceof ParameterizedType) {
       ParameterizedType parameterizedType = (ParameterizedType) injectionPoint.getType();
       if (parameterizedType.getActualTypeArguments()[0] instanceof TypeVariable<?>) {
         throw new DefinitionException(INJECTION_POINT_WITH_TYPE_VARIABLE, injectionPoint);
       }
       if (parameterizedType.getActualTypeArguments()[0] instanceof WildcardType) {
         throw new DefinitionException(INJECTION_POINT_HAS_WILDCARD, type, injectionPoint);
       }
     } else {
       throw new DefinitionException(
           INJECTION_POINT_MUST_HAVE_TYPE_PARAMETER, type, injectionPoint);
     }
   }
 }
Пример #18
0
 protected static Type getFacadeType(InjectionPoint injectionPoint) {
   Type genericType = injectionPoint.getType();
   if (genericType instanceof ParameterizedType) {
     return ((ParameterizedType) genericType).getActualTypeArguments()[0];
   } else {
     throw new IllegalStateException(BeanLogger.LOG.typeParameterMustBeConcrete(injectionPoint));
   }
 }
Пример #19
0
 protected static Type getFacadeType(InjectionPoint injectionPoint) {
   Type genericType = injectionPoint.getType();
   if (genericType instanceof ParameterizedType) {
     return ((ParameterizedType) genericType).getActualTypeArguments()[0];
   } else {
     throw new IllegalStateException(TYPE_PARAMETER_MUST_BE_CONCRETE, injectionPoint);
   }
 }
Пример #20
0
  /**
   * Returns the qualifier annotation of the given qualifier class from the given injection point.
   */
  public static <A extends Annotation> A getQualifier(
      InjectionPoint injectionPoint, Class<A> qualifierClass) {
    for (Annotation annotation : injectionPoint.getQualifiers()) {
      if (qualifierClass.isAssignableFrom(annotation.getClass())) {
        return qualifierClass.cast(annotation);
      }
    }

    return null;
  }
Пример #21
0
  @Produces
  @Log
  public Logger createLogger(InjectionPoint injectionPoint) {

    Logger logger = null;
    Class<?> aClass = injectionPoint.getMember().getDeclaringClass();
    logger = LogManager.getLogger(aClass.getName());

    return logger;
  }
Пример #22
0
  /**
   * @param bean
   * @param probe
   * @return the set of dependents
   */
  static Set<Dependency> getDependents(Bean<?> bean, Probe probe) {
    Set<Dependency> dependents = new HashSet<Dependency>();
    for (Bean<?> candidate : probe.getBeans()) {
      if (candidate.equals(bean)) {
        continue;
      }
      BeanManager beanManager = probe.getBeanManager(candidate);
      if (beanManager == null) {
        // Don't process built-in beans
        continue;
      }
      Set<InjectionPoint> injectionPoints = candidate.getInjectionPoints();
      if (injectionPoints != null && !injectionPoints.isEmpty()) {
        for (InjectionPoint injectionPoint : injectionPoints) {

          // At this point unsatisfied or ambiguous dependency should not exits
          Bean<?> candidateDependency =
              beanManager.resolve(
                  beanManager.getBeans(
                      injectionPoint.getType(),
                      injectionPoint
                          .getQualifiers()
                          .toArray(new Annotation[injectionPoint.getQualifiers().size()])));
          boolean satisfies = false;

          if (isBuiltinBeanButNotExtension(candidateDependency)) {
            satisfies =
                bean.equals(
                    probe.getBean(
                        Components.getBuiltinBeanId((AbstractBuiltInBean<?>) candidateDependency)));
          } else {
            satisfies = bean.equals(candidateDependency);
          }
          if (satisfies) {
            dependents.add(new Dependency(candidate, injectionPoint));
          }
        }
      }
    }
    return dependents;
  }
Пример #23
0
  public static void validatePassivating(Class<?> cl, Bean<?> bean, String typeName) {
    Class<?> beanClass = bean.getBeanClass();

    if (!Serializable.class.isAssignableFrom(beanClass) && false) {
      ConfigException exn =
          new ConfigException(
              L.l(
                  "{0}: {1} is an invalid {2} because it is not serializable.",
                  cl.getName(), bean, typeName));

      throw exn;
      // InjectManager.create().addDefinitionError(exn);
    }

    for (InjectionPoint ip : bean.getInjectionPoints()) {
      if (ip.isTransient() || ip.isDelegate()) continue;

      Class<?> type = getRawClass(ip.getType());

      if (type.isInterface()) continue;

      if (!Serializable.class.isAssignableFrom(type)) {
        ConfigException exn =
            new ConfigException(
                L.l(
                    "{0}: {1} is an invalid {4} because its injection point '{2}' of type {3} is not serializable.",
                    cl.getName(), bean, ip.getMember().getName(), ip.getType(), typeName));

        throw exn;
      }
    }
  }
Пример #24
0
 /**
  * @param bean
  * @param beanManager
  * @param probe
  * @return the set of dependencies
  */
 static Set<Dependency> getDependencies(Bean<?> bean, BeanManager beanManager, Probe probe) {
   Set<Dependency> dependencies = new HashSet<Dependency>();
   Set<InjectionPoint> injectionPoints = bean.getInjectionPoints();
   if (injectionPoints != null && !injectionPoints.isEmpty()) {
     for (InjectionPoint injectionPoint : injectionPoints) {
       // At this point unsatisfied or ambiguous dependency should not exits
       Bean<?> dependency =
           beanManager.resolve(
               beanManager.getBeans(
                   injectionPoint.getType(),
                   injectionPoint
                       .getQualifiers()
                       .toArray(new Annotation[injectionPoint.getQualifiers().size()])));
       if (isBuiltinBeanButNotExtension(dependency)) {
         dependency =
             probe.getBean(Components.getBuiltinBeanId((AbstractBuiltInBean<?>) dependency));
       }
       dependencies.add(new Dependency(dependency, injectionPoint));
     }
   }
   return dependencies;
 }
  <T> void saveRemoteInjectionPoints(
      @Observes ProcessInjectionTarget<T> event, BeanManager beanManager) {
    final InjectionTarget<T> injectionTarget = event.getInjectionTarget();

    for (InjectionPoint injectionPoint : injectionTarget.getInjectionPoints()) {
      final Annotated annotated = injectionPoint.getAnnotated();
      final Type type = annotated.getBaseType();
      final Class<?> rawType = Reflections.getRawType(annotated.getBaseType());
      final Set<Annotation> qualifiers =
          Reflections.getQualifiers(beanManager, annotated.getAnnotations());

      if (rawType.equals(RemoteCache.class) && qualifiers.isEmpty()) {
        qualifiers.add(new AnnotationLiteral<Default>() {});
        addRemoteCacheInjectionPoint(type, qualifiers);

      } else if (!annotated.isAnnotationPresent(Remote.class)
          && Reflections.getMetaAnnotation(annotated, Remote.class) != null
          && rawType.isAssignableFrom(RemoteCache.class)) {

        addRemoteCacheInjectionPoint(type, qualifiers);
      }
    }
  }
Пример #26
0
 /**
  * Produces an instance of a slf4j logger for the given injection point.
  *
  * @param injectionPoint to use
  * @return a logger
  */
 @Produces
 public Logger getLogger(final InjectionPoint injectionPoint) {
   // The injection point is used to instantiate the correct logger for the
   // caller class.
   Bean<?> bean = injectionPoint.getBean();
   Logger l = null;
   if (bean != null) {
     Class<?> beanClass = bean.getBeanClass();
     l = LoggerFactory.getLogger(beanClass);
   } else {
     l = LoggerFactory.getLogger("Default logger");
   }
   return l;
 }
  /**
   * Discovery the custom REST beans.
   *
   * @param abd the after bean discovery.
   * @param bm the bean manager.
   */
  void afterBeanDiscovery(@Observes AfterBeanDiscovery abd, BeanManager bm) {

    Set<String> restClients = new HashSet<>();
    // create the rest clients
    Set<Bean<?>> allBeans =
        bm.getBeans(
            Object.class,
            new AnnotationLiteral<Any>() {
              private static final long serialVersionUID = 3109256773218160485L;
            });

    for (Bean<?> bean : allBeans) {
      Set<InjectionPoint> bb = bean.getInjectionPoints();
      if (bb != null) {
        for (InjectionPoint ip : bb) {
          RestClient rest = ip.getAnnotated().getAnnotation(RestClient.class);
          if (rest != null) {

            // create ID for the bean = class name + configuration id
            Class<?> clazz = (Class<?>) ip.getType();
            String value = rest.value();
            String id = clazz.getName() + value;

            if (!restClients.contains(id)) {

              restClients.add(id);
              RestClientServiceBean sbean =
                  new RestClientServiceBean(
                      clazz, value, CdiInterceptorBindingExtension.CDI_AUTOBINDING);
              abd.addBean(sbean);
            }
          }
        }
      }
    }
  }
  @Produces
  public Configuration getConfiguration(final InjectionPoint injectionPoint) {

    Context context;
    String defaultName;

    // try CDI bean name
    defaultName = injectionPoint.getBean() != null ? injectionPoint.getBean().getName() : null;

    // try field / method name
    if (StringHelper.isEmpty(defaultName)) {
      defaultName = injectionPoint.getMember().getName();
    }

    // context needed annotation
    context = injectionPoint.getAnnotated().getAnnotation(Context.class);

    // if no @Context annotation is present, create a default one with no name
    if (context == null) {
      context = ContextHelper.createContext(defaultName);
    }

    return provides(context, defaultName, Configuration.class);
  }
Пример #29
0
  private void validatePassivating(Bean<?> bean) {
    Type baseType = _annotatedType.getBaseType();

    Class<?> cl = getBeanManager().createTargetBaseType(baseType).getRawClass();
    boolean isStateful = _annotatedType.isAnnotationPresent(Stateful.class);

    if (!Serializable.class.isAssignableFrom(cl) && !isStateful) {
      throw new ConfigException(
          L.l(
              "'{0}' is an invalid @{1} bean because it's not serializable for {2}.",
              cl.getSimpleName(), bean.getScope().getSimpleName(), bean));
    }

    for (InjectionPoint ip : bean.getInjectionPoints()) {
      if (ip.isTransient()) continue;

      Type type = ip.getType();

      if (ip.getBean() instanceof CdiStatefulBean) continue;

      if (type instanceof Class<?>) {
        Class<?> ipClass = (Class<?>) type;

        if (!ipClass.isInterface()
            && !Serializable.class.isAssignableFrom(ipClass)
            && !getBeanManager().isNormalScope(ip.getBean().getScope())) {
          throw new ConfigException(
              L.l(
                  "'{0}' is an invalid @{1} bean because '{2}' value {3} is not serializable for {4}.",
                  cl.getSimpleName(),
                  bean.getScope().getSimpleName(),
                  ip.getType(),
                  ip.getMember().getName(),
                  bean));
        }
      }
    }
  }
Пример #30
0
 public static String getEjbBindLocation(InjectionPoint injectionPoint) {
   EJB ejb = getResourceAnnotated(injectionPoint).getAnnotation(EJB.class);
   String mappedName = ejb.mappedName();
   if (!mappedName.equals("")) {
     return mappedName;
   }
   String name = ejb.name();
   if (!name.equals("")) {
     return RESOURCE_LOOKUP_PREFIX + "/" + name;
   }
   String propertyName;
   if (injectionPoint.getMember() instanceof Field) {
     propertyName = injectionPoint.getMember().getName();
   } else if (injectionPoint.getMember() instanceof Method) {
     propertyName = getPropertyName((Method) injectionPoint.getMember());
     if (propertyName == null) {
       throw WeldMessages.MESSAGES.injectionPointNotAJavabean((Method) injectionPoint.getMember());
     }
   } else {
     throw WeldMessages.MESSAGES.cannotInject(injectionPoint);
   }
   String className = injectionPoint.getMember().getDeclaringClass().getName();
   return RESOURCE_LOOKUP_PREFIX + "/" + className + "/" + propertyName;
 }