@SuppressWarnings("unchecked")
  <T, X> void registerBeans(@Observes AfterBeanDiscovery event, final BeanManager beanManager) {

    if (beanManager.getBeans(RemoteCacheManager.class).isEmpty()) {
      LOGGER.addDefaultRemoteCacheManager();
      event.addBean(createDefaultRemoteCacheManagerBean(beanManager));
    }

    for (Map.Entry<Type, Set<Annotation>> entry : remoteCacheInjectionPoints.entrySet()) {

      event.addBean(
          new BeanBuilder(beanManager)
              .readFromType(beanManager.createAnnotatedType(Reflections.getRawType(entry.getKey())))
              .addType(entry.getKey())
              .addQualifiers(entry.getValue())
              .beanLifecycle(
                  new ContextualLifecycle<RemoteCache<?, ?>>() {
                    @Override
                    public RemoteCache<?, ?> create(
                        Bean<RemoteCache<?, ?>> bean, CreationalContext<RemoteCache<?, ?>> ctx) {
                      return remoteCacheProducer.produce(ctx);
                    }

                    @Override
                    public void destroy(
                        Bean<RemoteCache<?, ?>> bean,
                        RemoteCache<?, ?> instance,
                        CreationalContext<RemoteCache<?, ?>> ctx) {
                      remoteCacheProducer.dispose(instance);
                    }
                  })
              .create());
    }
  }
예제 #2
0
  @Override
  @SuppressWarnings("unchecked")
  public JCDIInjectionContext createManagedObject(
      Class managedClass, BundleDescriptor bundle, boolean invokePostConstruct) {
    JCDIInjectionContext context = null;

    Object managedObject = null;

    try {
      managedObject =
          createEEManagedObject(bundle.getManagedBeanByBeanClass(managedClass.getName()));
    } catch (Exception e) {
      e.printStackTrace();
    }

    WeldContainer wc = getWeldContainer();
    if (wc != null) {
      BeanManager beanManager = wc.getBeanManager();

      AnnotatedType annotatedType = beanManager.createAnnotatedType(managedClass);
      InjectionTarget target = beanManager.createInjectionTarget(annotatedType);

      CreationalContext cc = beanManager.createCreationalContext(null);

      target.inject(managedObject, cc);

      if (invokePostConstruct) {
        target.postConstruct(managedObject);
      }

      context = new JCDIInjectionContextImpl(target, cc, managedObject);
    }

    return context;
  }
예제 #3
0
 private RequestMappingInfo findMethodRequestMapping(FacesContext context, Bean<?> bean) {
   RequestMappingInfo result = null;
   Class clazz = bean.getBeanClass();
   AnnotatedType annotatedType = beanManager.createAnnotatedType(clazz);
   Set<AnnotatedMethod> annotatedMethodSet = annotatedType.getMethods();
   for (AnnotatedMethod method : annotatedMethodSet) {
     if (method.isAnnotationPresent(RequestMapping.class)) {
       RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
       String[] mappings = requestMapping.value();
       String mapping = null;
       for (String current : mappings) {
         String pathInfo = context.getExternalContext().getRequestPathInfo();
         if (pathInfo.equals(current)) {
           result = new RequestMappingInfo();
           result.setBean(bean);
           result.setMethod(method.getJavaMember());
           result.setRequestMapping(mapping);
           result.setMappingType(RequestMappingInfo.MappingType.EXACT);
           break;
         } else if (current.endsWith("*")) {
           current = current.substring(0, current.length() - 1);
           if (pathInfo.startsWith(current)) {
             if (result == null) {
               result = new RequestMappingInfo();
               result.setBean(bean);
               result.setMethod(method.getJavaMember());
               result.setRequestMapping(current);
               result.setMappingType(RequestMappingInfo.MappingType.PREFIX);
             } else if (current.length() > result.getLength()) {
               result.setBean(bean);
               result.setMethod(method.getJavaMember());
               result.setRequestMapping(current);
               result.setMappingType(RequestMappingInfo.MappingType.PREFIX);
             }
           }
         } else if (current.startsWith("*")) {
           current = current.substring(1);
           if (pathInfo.endsWith(current)) {
             result = new RequestMappingInfo();
             result.setBean(bean);
             result.setMethod(method.getJavaMember());
             result.setRequestMapping(current);
             result.setMappingType(RequestMappingInfo.MappingType.EXTENSION);
             break;
           }
         }
       }
     }
     if (result != null
         && (result.getMappingType().equals(RequestMappingInfo.MappingType.EXACT)
             || (result.getMappingType().equals(RequestMappingInfo.MappingType.EXTENSION)))) {
       break;
     }
   }
   return result;
 }
  /**
   * Used to register the method validation interceptor binding annotation.
   *
   * @param beforeBeanDiscoveryEvent event fired before the bean discovery process starts
   * @param beanManager the bean manager.
   */
  public void beforeBeanDiscovery(
      @Observes BeforeBeanDiscovery beforeBeanDiscoveryEvent, final BeanManager beanManager) {
    Contracts.assertNotNull(
        beforeBeanDiscoveryEvent, "The BeforeBeanDiscovery event cannot be null");
    Contracts.assertNotNull(beanManager, "The BeanManager cannot be null");

    // Register the interceptor explicitly. This way, no beans.xml is needed
    AnnotatedType<ValidationInterceptor> annotatedType =
        beanManager.createAnnotatedType(ValidationInterceptor.class);
    beforeBeanDiscoveryEvent.addAnnotatedType(annotatedType);
  }
예제 #5
0
 private SyntheticBean<?> camelContextBean(BeanManager manager, Annotation... qualifiers) {
   SyntheticAnnotated annotated =
       new SyntheticAnnotated(
           DefaultCamelContext.class,
           manager.createAnnotatedType(DefaultCamelContext.class).getTypeClosure(),
           qualifiers);
   return new SyntheticBean<>(
       manager,
       annotated,
       DefaultCamelContext.class,
       environment.camelContextInjectionTarget(
           new SyntheticInjectionTarget<>(DefaultCamelContext::new), annotated, manager, this),
       bean -> "Default Camel context bean with qualifiers " + bean.getQualifiers());
 }
 public Object createEntityListenerAndInjectDependancies(Class entityListenerClass)
     throws NamingException {
   AnnotatedType<Object> aType = beanManager.createAnnotatedType(entityListenerClass);
   InjectionTarget<Object> injectionTarget = beanManager.<Object>createInjectionTarget(aType);
   Object entityListener =
       injectionTarget.produce(beanManager.<Object>createCreationalContext(null));
   synchronized (injectionTargets) {
     injectionTargets.put(entityListener, injectionTarget);
   }
   injectionTarget.postConstruct(entityListener);
   creationalContext = beanManager.<Object>createCreationalContext(null);
   injectionTarget.inject(entityListener, creationalContext);
   return entityListener;
 }
예제 #7
0
  public void afterBeanDiscovery(@Observes AfterBeanDiscovery event, BeanManager manager) {
    final AnnotatedType annotationType = manager.createAnnotatedType(CDITransactionContext.class);
    final InjectionTarget injectionTarget = manager.createInjectionTarget(annotationType);
    final CreationalContext creationalContext = manager.createCreationalContext(null);
    final CDITransactionContext context = new CDITransactionContext();
    injectionTarget.inject(context, creationalContext);
    injectionTarget.postConstruct(CDITransactionContext.class);

    if (logger.isDebugEnabled()) {
      logger.debug("afterBeanDiscovery -> context " + context);
    }

    context.setBeanManager(manager);
    event.addContext(context);
  }
예제 #8
0
  @Override
  @SuppressWarnings("unchecked")
  public void injectManagedObject(Object managedObject, BundleDescriptor bundle) {
    WeldContainer wc = getWeldContainer();

    if (wc != null) {
      BeanManager beanManager = wc.getBeanManager();

      AnnotatedType annotatedType = beanManager.createAnnotatedType(managedObject.getClass());
      InjectionTarget target = beanManager.createInjectionTarget(annotatedType);

      CreationalContext cc = beanManager.createCreationalContext(null);

      target.inject(managedObject, cc);
    }
  }
예제 #9
0
  @Override
  public <T> T createInterceptorInstance(Class<T> interceptorClass, BundleDescriptor bundle) {

    T interceptorInstance = null;

    WeldContainer wc = getWeldContainer();
    if (wc != null) {
      BeanManager beanManager = wc.getBeanManager();

      AnnotatedType annotatedType = beanManager.createAnnotatedType(interceptorClass);
      InjectionTarget target =
          ((WeldManager) beanManager)
              .getInjectionTargetFactory(annotatedType)
              .createInterceptorInjectionTarget();

      CreationalContext cc = beanManager.createCreationalContext(null);

      interceptorInstance = (T) target.produce(cc);
      target.inject(interceptorInstance, cc);
    }

    return interceptorInstance;
  }
 public void addStageConfig(@Observes BeforeBeanDiscovery bbd, BeanManager beanManager) {
   bbd.addAnnotatedType(beanManager.createAnnotatedType(ConfigurationValueProducer.class));
 }
예제 #11
0
  /**
   * Register all admin CDI beans.
   *
   * @param bbd the bbd event
   * @param bm the bean manager
   */
  public void register(@Observes BeforeBeanDiscovery bbd, BeanManager bm) {

    // Current API
    bbd.addAnnotatedType(bm.createAnnotatedType(CompensationManagerImpl.class));
    bbd.addAnnotatedType(bm.createAnnotatedType(CompensationInterceptorMandatory.class));
    bbd.addAnnotatedType(bm.createAnnotatedType(CompensationInterceptorNever.class));
    bbd.addAnnotatedType(bm.createAnnotatedType(CompensationInterceptorNotSupported.class));
    bbd.addAnnotatedType(bm.createAnnotatedType(CompensationInterceptorRequired.class));
    bbd.addAnnotatedType(bm.createAnnotatedType(CompensationInterceptorRequiresNew.class));
    bbd.addAnnotatedType(bm.createAnnotatedType(CompensationInterceptorSupports.class));
    bbd.addAnnotatedType(bm.createAnnotatedType(TxCompensateInterceptor.class));
    bbd.addAnnotatedType(bm.createAnnotatedType(TxConfirmInterceptor.class));
    bbd.addAnnotatedType(bm.createAnnotatedType(TxLoggedInterceptor.class));
    bbd.addAnnotatedType(bm.createAnnotatedType(CancelOnFailureInterceptor.class));
    bbd.addAnnotatedType(bm.createAnnotatedType(CompensatableActionProducer.class));
    bbd.addAnnotatedType(bm.createAnnotatedType(DeserializersContainerProducer.class));
  }
예제 #12
0
 void registerApple(@Observes BeforeBeanDiscovery event, BeanManager manager) {
   event.addAnnotatedType(
       new AnnotatedTypeWrapper<Pear>(
           manager.createAnnotatedType(Pear.class), false, Juicy.Literal.INSTANCE));
 }