protected <T> void processBeanRegistration(
      BeanRegistration registration, GlobalEnablementBuilder globalEnablementBuilder) {
    Bean<?> bean = registration.getBean();
    BeanManagerImpl beanManager = registration.getBeanManager();
    if (beanManager == null) {
      // Get the bean manager for beans added via ABD#addBean()
      beanManager = getOrCreateBeanDeployment(bean.getBeanClass()).getBeanManager();
    } else {
      // Also validate the bean produced by a builder
      ExternalBeanAttributesFactory.validateBeanAttributes(bean, getBeanManager());
      validateBean(bean);
    }

    // Custom beans (alternatives, interceptors, decorators) may also implement
    // javax.enterprise.inject.spi.Prioritized
    Integer priority = (bean instanceof Prioritized) ? ((Prioritized) bean).getPriority() : null;

    if (bean instanceof Interceptor<?>) {
      beanManager.addInterceptor((Interceptor<?>) bean);
      if (priority != null) {
        globalEnablementBuilder.addInterceptor(bean.getBeanClass(), priority);
      }
    } else if (bean instanceof Decorator<?>) {
      beanManager.addDecorator(CustomDecoratorWrapper.of((Decorator<?>) bean, beanManager));
      if (priority != null) {
        globalEnablementBuilder.addDecorator(bean.getBeanClass(), priority);
      }
    } else {
      beanManager.addBean(bean);
      if (priority != null && bean.isAlternative()) {
        globalEnablementBuilder.addAlternative(bean.getBeanClass(), priority);
      }
    }
    containerLifecycleEvents.fireProcessBean(beanManager, bean, registration.getExtension());
  }
Пример #2
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);
           }
         }
       }
     }
   }
 }
 public T createFor(InterceptorReference<Object> interceptorReference) {
   if (interceptorReference.getInterceptor() instanceof ClassMetadata<?>) {
     try {
       // this is not a managed instance - assume no-argument constructor exists
       Class<T> clazz = cast(interceptorReference.getClassMetadata().getJavaClass());
       Constructor<T> constructor = SecureReflections.getDeclaredConstructor(clazz);
       T interceptorInstance = SecureReflections.ensureAccessible(constructor).newInstance();
       // inject
       AnnotatedType<T> type = manager.createAnnotatedType(clazz);
       InjectionTarget<T> target = manager.createInjectionTarget(type);
       target.inject(interceptorInstance, creationalContext);
       return interceptorInstance;
     } catch (Exception e) {
       throw new DeploymentException(e);
     }
   }
   if (interceptorReference.getInterceptor() instanceof SerializableContextual) {
     try {
       // this is not a managed instance - assume no-argument constructor exists
       SerializableContextual<Interceptor<T>, T> serializableContextual =
           cast(interceptorReference.getInterceptor());
       return Reflections.<T>cast(
           manager.getReference(serializableContextual.get(), creationalContext, false));
     } catch (Exception e) {
       throw new DeploymentException(e);
     }
   }
   throw new IllegalStateException();
 }
Пример #4
0
 protected BeanDeployerEnvironment(
     Set<SlimAnnotatedTypeContext<?>> annotatedTypes,
     Set<Class<?>> vetoedClasses,
     SetMultimap<Class<?>, AbstractClassBean<?>> classBeanMap,
     Set<ProducerField<?, ?>> producerFields,
     SetMultimap<WeldMethodKey, ProducerMethod<?, ?>> producerMethodBeanMap,
     Set<RIBean<?>> beans,
     Set<ObserverInitializationContext<?, ?>> observers,
     Set<DisposalMethod<?, ?>> allDisposalBeans,
     Set<DisposalMethod<?, ?>> resolvedDisposalBeans,
     Set<DecoratorImpl<?>> decorators,
     Set<InterceptorImpl<?>> interceptors,
     Set<Type> newBeanTypes,
     BeanManagerImpl manager) {
   this.annotatedTypes = annotatedTypes;
   this.vetoedClasses = vetoedClasses;
   this.classBeanMap = classBeanMap;
   this.producerFields = producerFields;
   this.producerMethodBeanMap = producerMethodBeanMap;
   this.beans = beans;
   this.observers = observers;
   this.allDisposalBeans = allDisposalBeans;
   this.resolvedDisposalBeans = resolvedDisposalBeans;
   this.decorators = decorators;
   this.interceptors = interceptors;
   this.disposalMethodResolver =
       new TypeSafeDisposerResolver(
           allDisposalBeans, manager.getServices().get(WeldConfiguration.class));
   this.classTransformer = manager.getServices().get(ClassTransformer.class);
   this.newBeanTypes = newBeanTypes;
   this.manager = manager;
 }
Пример #5
0
 /*
  * It may in theory happen that an app calls BeanManager.createAnnotatedType() for a previously unknown class on node1 and then
  * stores this annotated type in session. On node2, this annotated type is not know. We'll try to load it.
  */
 private SlimAnnotatedType<?> tryToLoadUnknownBackedAnnotatedType() {
   if (identifier.getSuffix() != null || identifier.isModified()) {
     return null; // this is not a backed annotated type
   }
   // first, obtain the BeanManager for a given BDA
   final BeanManagerImpl manager =
       Container.instance(identifier).getBeanManager(identifier.getBdaId());
   if (manager == null) {
     return null;
   }
   // second, try to load the class
   final ResourceLoader resourceLoader = manager.getServices().get(ResourceLoader.class);
   Class<?> clazz = null;
   try {
     clazz = resourceLoader.classForName(identifier.getClassName());
   } catch (ResourceLoadingException e) {
     MetadataLogger.LOG.catchingDebug(e);
     return null;
   }
   // finally, try to load the annotated type
   try {
     return manager
         .getServices()
         .get(ClassTransformer.class)
         .getBackedAnnotatedType(clazz, identifier.getBdaId());
   } catch (ResourceLoadingException e) {
     MetadataLogger.LOG.catchingDebug(e);
     return null;
   }
 }
Пример #6
0
 /** finds pseudo beans and adds them to the list of beans to be validated */
 private static void validatePseudoScopedInjectionPoint(
     InjectionPoint ij,
     BeanManagerImpl beanManager,
     Set<Bean<?>> dependencyPath,
     Set<Bean<?>> validatedBeans) {
   Set<Bean<?>> resolved = beanManager.getBeans(ij);
   try {
     Bean<? extends Object> bean = beanManager.resolve(resolved);
     if (bean != null) {
       if (!(bean instanceof AbstractBuiltInBean<?>)) {
         boolean normalScoped =
             beanManager
                 .getServices()
                 .get(MetaAnnotationStore.class)
                 .getScopeModel(bean.getScope())
                 .isNormal();
         if (!normalScoped) {
           reallyValidatePseudoScopedBean(bean, beanManager, dependencyPath, validatedBeans);
         }
       }
     }
   } catch (AmbiguousResolutionException e) {
     // this is handled by another validator
   }
 }
 @Test(expected = InjectionException.class)
 @Category(Broken.class)
 public void testSameBeanTypeInChildAsParentInjection() {
   BeanManagerImpl childActivity = beanManager.createActivity();
   Bean<?> anotherMyBean = createDummyBean(childActivity);
   childActivity.addBean(anotherMyBean);
 }
Пример #8
0
  @Test(
      description =
          "A simple test to check session replication, doesn't carefully check if a bean ids are correct")
  public void testSimpleSessionReplication() throws Exception {

    TestContainer container1 = bootstrapContainer(1, Collections.singletonList(Foo.class));
    BeanManagerImpl beanManager1 = getBeanManager(container1);
    Bean<?> fooBean1 = beanManager1.resolve(beanManager1.getBeans(Foo.class));

    TestContainer container2 = bootstrapContainer(2, Collections.singletonList(Foo.class));
    BeanManagerImpl beanManager2 = getBeanManager(container2);
    Bean<?> fooBean2 = beanManager2.resolve(beanManager2.getBeans(Foo.class));

    use(1);
    // Set a value into Foo1
    Foo foo1 =
        (Foo)
            beanManager1.getReference(
                fooBean1, Foo.class, beanManager1.createCreationalContext(fooBean1));
    foo1.setName("container 1");

    replicateSession(1, container1, 2, container2);

    use(2);
    Foo foo2 =
        (Foo)
            beanManager2.getReference(
                fooBean2, Foo.class, beanManager2.createCreationalContext(fooBean2));
    assert foo2.getName().equals("container 1");
    use(2);
    container2.stopContainer();
    use(1);
    container1.stopContainer();
  }
Пример #9
0
  @Test(expectedExceptions = IllegalStateException.class)
  public void testVariableBeanDeploymentStructure() throws Exception {
    Collection<Class<?>> classes1 =
        Arrays.<Class<?>>asList(Stable.class, Horse.class, Fodder.class);
    Collection<Class<?>> classes2 =
        Arrays.<Class<?>>asList(Stable.class, Horse.class, Fodder.class, Foo.class);
    TestContainer container1 = bootstrapContainer(1, classes1);
    BeanManagerImpl beanManager1 = getBeanManager(container1);
    Bean<?> stableBean1 = beanManager1.resolve(beanManager1.getBeans(Stable.class));
    TestContainer container2 = bootstrapContainer(2, classes2);

    use(1);
    // Set a value into Foo1
    Stable stable1 =
        (Stable)
            beanManager1.getReference(
                stableBean1, Stable.class, beanManager1.createCreationalContext(stableBean1));
    stable1.getFodder().setAmount(10);
    stable1.getHorse().setName("George");

    try {
      replicateSession(1, container1, 2, container2);
    } finally {
      use(1);
      container1.stopContainer();
      use(2);
      container2.stopContainer();
    }
  }
Пример #10
0
  public void shutdown() {
    try {
      // First, the container must destroy all contexts.
      deploymentManager.instance().select(ApplicationContext.class).get().invalidate();
      deploymentManager.instance().select(SingletonContext.class).get().invalidate();

    } finally {
      try {
        // fire @Destroyed(ApplicationScoped.class) for non-web modules
        // web modules are handled by HttpContextLifecycle
        for (BeanDeploymentModule module :
            deploymentManager.getServices().get(BeanDeploymentModules.class)) {
          if (!module.isWebModule()) {
            module.fireEvent(
                Object.class, ContextEvent.APPLICATION_DESTROYED, DestroyedLiteral.APPLICATION);
          }
        }
      } catch (Exception ignored) {
      }
      try {
        // Finally, the container must fire an event of type BeforeShutdown.
        BeforeShutdownImpl.fire(deploymentManager);
      } finally {
        Container container = Container.instance(contextId);
        container.setState(ContainerState.SHUTDOWN);
        container.cleanup();
      }
    }
  }
Пример #11
0
 private Object readResolve() throws ObjectStreamException {
   InterceptionModel<ClassMetadata<?>> interceptionModel =
       manager.getInterceptorModelRegistry().get(targetClass);
   MetadataCachingReader reader = manager.getInterceptorMetadataReader();
   TargetClassInterceptorMetadata<?> targetClassInterceptorMetadata =
       reader.getTargetClassInterceptorMetadata(reader.getClassMetadata(targetClass));
   return new InterceptionContext(
       interceptorInstances, manager, targetClassInterceptorMetadata, interceptionModel);
 }
Пример #12
0
  protected Collection<ContextHolder<? extends Context>> createContexts(ServiceRegistry services) {
    List<ContextHolder<? extends Context>> contexts =
        new ArrayList<ContextHolder<? extends Context>>();

    BeanIdentifierIndex beanIdentifierIndex = services.get(BeanIdentifierIndex.class);

    /*
     * Register a full set of bound and unbound contexts. Although we may not use all of
     * these (e.g. if we are running in a servlet environment) they may be
     * useful for an application.
     */
    contexts.add(
        new ContextHolder<ApplicationContext>(
            new ApplicationContextImpl(contextId),
            ApplicationContext.class,
            UnboundLiteral.INSTANCE));
    contexts.add(
        new ContextHolder<SingletonContext>(
            new SingletonContextImpl(contextId), SingletonContext.class, UnboundLiteral.INSTANCE));
    contexts.add(
        new ContextHolder<BoundSessionContext>(
            new BoundSessionContextImpl(contextId, beanIdentifierIndex),
            BoundSessionContext.class,
            BoundLiteral.INSTANCE));
    contexts.add(
        new ContextHolder<BoundConversationContext>(
            new BoundConversationContextImpl(contextId, services),
            BoundConversationContext.class,
            BoundLiteral.INSTANCE));
    contexts.add(
        new ContextHolder<BoundRequestContext>(
            new BoundRequestContextImpl(contextId),
            BoundRequestContext.class,
            BoundLiteral.INSTANCE));
    contexts.add(
        new ContextHolder<RequestContext>(
            new RequestContextImpl(contextId), RequestContext.class, UnboundLiteral.INSTANCE));
    contexts.add(
        new ContextHolder<DependentContext>(
            new DependentContextImpl(services.get(ContextualStore.class)),
            DependentContext.class,
            UnboundLiteral.INSTANCE));

    services.get(WeldModules.class).postContextRegistration(contextId, services, contexts);

    /*
     * Register the contexts with the bean manager and add the beans to the
     * deployment manager so that they are easily accessible (contexts are app
     * scoped)
     */
    for (ContextHolder<? extends Context> context : contexts) {
      deploymentManager.addContext(context.getContext());
      deploymentManager.addBean(ContextBean.of(context, deploymentManager));
    }

    return contexts;
  }
Пример #13
0
 /**
  * @param id
  * @param manager
  * @param bootstrap
  */
 private WeldContainer(String id, WeldManager manager, Bootstrap bootstrap) {
   super();
   this.id = id;
   this.manager = manager;
   this.bootstrap = bootstrap;
   this.creationalContext = manager.createCreationalContext(null);
   BeanManagerImpl beanManagerImpl = ((BeanManagerImpl) manager.unwrap());
   this.instance = beanManagerImpl.getInstance(creationalContext);
   this.event = beanManagerImpl.event();
 }
 private void processAdditionalObserver(ObserverMethod<?> observer) {
   validateObserverMethod(observer, getBeanManager(), null);
   BeanManagerImpl manager = getOrCreateBeanDeployment(observer.getBeanClass()).getBeanManager();
   if (Observers.isObserverMethodEnabled(observer, manager)) {
     ObserverMethod<?> processedObserver =
         containerLifecycleEvents.fireProcessObserverMethod(manager, observer);
     if (processedObserver != null) {
       manager.addObserver(processedObserver);
     }
   }
 }
Пример #15
0
 protected AfterTypeDiscoveryImpl(
     BeanManagerImpl beanManager,
     BeanDeploymentArchiveMapping bdaMapping,
     Deployment deployment,
     Collection<ContextHolder<? extends Context>> contexts) {
   super(beanManager, AfterTypeDiscovery.class, bdaMapping, deployment, contexts);
   this.builder = beanManager.getServices().get(GlobalEnablementBuilder.class);
   this.events = beanManager.getServices().get(ContainerLifecycleEvents.class);
   this.transformer = beanManager.getServices().get(ClassTransformer.class);
   this.store = beanManager.getServices().get(SlimAnnotatedTypeStore.class);
 }
Пример #16
0
 public void validateBeans() {
   BootstrapLogger.LOG.validatingBeans();
   for (BeanDeployment beanDeployment : getBeanDeployments()) {
     BeanManagerImpl beanManager = beanDeployment.getBeanManager();
     beanManager.getBeanResolver().clear();
     deployment.getServices().get(Validator.class).validateDeployment(beanManager, beanDeployment);
     beanManager.getServices().get(InjectionTargetService.class).validate();
   }
   getContainer().setState(ContainerState.VALIDATED);
   AfterDeploymentValidationImpl.fire(deploymentManager);
 }
Пример #17
0
 public void validateDeployment(BeanManagerImpl manager, BeanDeployerEnvironment environment) {
   validateDecorators(manager.getDecorators(), new ArrayList<RIBean<?>>(), manager);
   validateInterceptors(manager.getInterceptors());
   validateBeans(manager.getBeans(), new ArrayList<RIBean<?>>(), manager);
   validateEnabledDecoratorClasses(manager);
   validateEnabledInterceptorClasses(manager);
   validateEnabledAlternatives(manager);
   validateDisposalMethods(environment);
   validateObserverMethods(environment.getObservers(), manager);
   validateBeanNames(manager);
 }
Пример #18
0
 public static WeldClass<?> getWeldClassOfDecoratedType(BeanManagerImpl beanManager, Type type) {
   if (type instanceof Class<?>) {
     return (WeldClass<?>) beanManager.createAnnotatedType((Class<?>) type);
   }
   if (type instanceof ParameterizedType
       && (((ParameterizedType) type).getRawType() instanceof Class)) {
     return (WeldClass<?>)
         beanManager.createAnnotatedType((Class<?>) ((ParameterizedType) type).getRawType());
   }
   throw new IllegalStateException(UNABLE_TO_PROCESS, type);
 }
Пример #19
0
 private void validateEnabledInterceptorClasses(BeanManagerImpl beanManager) {
   Set<Class<?>> interceptorBeanClasses = new HashSet<Class<?>>();
   for (Interceptor<?> interceptor : beanManager.getAccessibleInterceptors()) {
     interceptorBeanClasses.add(interceptor.getBeanClass());
   }
   for (Metadata<Class<?>> enabledInterceptorClass : beanManager.getEnabled().getInterceptors()) {
     if (!interceptorBeanClasses.contains(enabledInterceptorClass.getValue())) {
       throw new DeploymentException(
           INTERCEPTOR_NOT_ANNOTATED_OR_REGISTERED, enabledInterceptorClass);
     }
   }
 }
 private AfterBeanDiscoveryImpl(
     BeanManagerImpl beanManager,
     Deployment deployment,
     BeanDeploymentArchiveMapping bdaMapping,
     Collection<ContextHolder<? extends Context>> contexts) {
   super(beanManager, WeldAfterBeanDiscovery.class, bdaMapping, deployment, contexts);
   this.slimAnnotatedTypeStore = beanManager.getServices().get(SlimAnnotatedTypeStore.class);
   this.containerLifecycleEvents = beanManager.getServices().get(ContainerLifecycleEvents.class);
   this.additionalBeans = new LinkedList<BeanRegistration>();
   this.additionalObservers = new LinkedList<ObserverMethod<?>>();
   this.additionalObserverConfigurators = new LinkedList<ObserverMethodConfigurator<?>>();
 }
 @Override
 public ManagedReference getReference() {
   final BeanManagerImpl beanManager = this.beanManager.getValue();
   final CreationalContext<?> ctx;
   if (bean == null) {
     ctx = beanManager.createCreationalContext(null);
   } else {
     ctx = beanManager.createCreationalContext(bean);
   }
   final Object instance = injectionTarget.produce(ctx);
   return new WeldManagedReference(ctx, instance, injectionTarget, interceptorInjections);
 }
Пример #22
0
 private void validateEnabledDecoratorClasses(BeanManagerImpl beanManager) {
   // TODO Move building this list to the boot or sth
   Set<Class<?>> decoratorBeanClasses = new HashSet<Class<?>>();
   for (Decorator<?> bean : beanManager.getAccessibleDecorators()) {
     decoratorBeanClasses.add(bean.getBeanClass());
   }
   for (Metadata<Class<?>> clazz : beanManager.getEnabled().getDecorators()) {
     if (!decoratorBeanClasses.contains(clazz.getValue())) {
       throw new DeploymentException(
           DECORATOR_CLASS_NOT_BEAN_CLASS_OF_DECORATOR, clazz, decoratorBeanClasses);
     }
   }
 }
Пример #23
0
  @Test
  public void testMultipleDependentObjectsSessionReplication() throws Exception {
    Collection<Class<?>> classes = Arrays.<Class<?>>asList(Stable.class, Horse.class, Fodder.class);
    TestContainer container1 = bootstrapContainer(1, classes);
    BeanManagerImpl beanManager1 = getBeanManager(container1);
    Bean<?> stableBean1 = beanManager1.resolve(beanManager1.getBeans(Stable.class));

    TestContainer container2 = bootstrapContainer(2, classes);
    BeanManagerImpl beanManager2 = getBeanManager(container2);
    Bean<?> stableBean2 = beanManager2.resolve(beanManager2.getBeans(Stable.class));

    use(1);
    // Set a value into Foo1
    Stable stable1 =
        (Stable)
            beanManager1.getReference(
                stableBean1, Stable.class, beanManager1.createCreationalContext(stableBean1));
    stable1.getFodder().setAmount(10);
    stable1.getHorse().setName("George");

    replicateSession(1, container1, 2, container2);

    use(2);

    Stable stable2 =
        (Stable)
            beanManager2.getReference(
                stableBean2, Stable.class, beanManager2.createCreationalContext(stableBean2));
    assert stable2.getFodder().getAmount() == stable1.getFodder().getAmount();
    assert stable2.getHorse().getName() == null;

    use(1);
    assert stable1.getFodder().getAmount() == 10;
    assert stable1.getHorse().getName().equals("George");

    use(2);

    stable2.getFodder().setAmount(11);

    replicateSession(2, container2, 1, container1);

    use(1);

    int i = stable1.getFodder().getAmount();

    assert stable1.getFodder().getAmount() == 11;
    use(1);
    container1.stopContainer();
    use(2);
    container2.stopContainer();
  }
 private HttpConversationContext httpConversationContext() {
   if (httpConversationContextCache == null) {
     this.httpConversationContextCache =
         beanManager.instance().select(HttpConversationContext.class).get();
   }
   return httpConversationContextCache;
 }
  protected void activateConversationContext(HttpServletRequest request) {
    HttpConversationContext conversationContext = httpConversationContext();
    String cid = getConversationId(request, httpConversationContext());
    log.debug(RESUMING_CONVERSATION, cid);

    /*
     * Don't try to reactivate the ConversationContext if we have already activated it for this request WELD-877
     */
    if (!isContextActivatedInRequest(request)) {
      setContextActivatedInRequest(request);
      conversationContext.activate(cid);
      if (cid == null) { // transient conversation
        beanManager
            .getAccessibleLenientObserverNotifier()
            .fireEvent(request, InitializedLiteral.CONVERSATION);
      }
    } else {
      /*
       * We may have previously been associated with a ConversationContext, but the reference to that context may have
       * been lost during a Servlet forward WELD-877
       */
      conversationContext.dissociate(request);
      conversationContext.associate(request);
      conversationContext.activate(cid);
    }
  }
Пример #26
0
 /**
  * Extracts the complete set of interception bindings from a given set of annotations.
  *
  * @param beanManager
  * @param annotations
  * @return
  */
 protected static Set<Annotation> flattenInterceptorBindings(
     BeanManagerImpl beanManager, Set<Annotation> annotations) {
   Set<Annotation> foundInterceptionBindingTypes = new HashSet<Annotation>();
   for (Annotation annotation : annotations) {
     if (beanManager.isInterceptorBinding(annotation.annotationType())) {
       foundInterceptionBindingTypes.add(annotation);
       foundInterceptionBindingTypes.addAll(
           beanManager
               .getServices()
               .get(MetaAnnotationStore.class)
               .getInterceptorBindingModel(annotation.annotationType())
               .getInheritedInterceptionBindingTypes());
     }
   }
   return foundInterceptionBindingTypes;
 }
 @Test
 public void testDestroyDoesntTryToRemoveSLSB() {
   Bean<BeanLocal> bean = Utils.getBean(beanManager, BeanLocal.class);
   Assert.assertNotNull("Expected a bean for stateless session bean BeanLocal", bean);
   CreationalContext<BeanLocal> creationalContext = beanManager.createCreationalContext(bean);
   BeanLocal instance = bean.create(creationalContext);
   bean.destroy(instance, creationalContext);
 }
Пример #28
0
  public void startInitialization() {
    if (deploymentManager == null) {
      throw BootstrapLogger.LOG.managerNotInitialized();
    }

    Set<BeanDeployment> physicalBeanDeploymentArchives =
        new HashSet<BeanDeployment>(getBeanDeployments());

    ExtensionBeanDeployer extensionBeanDeployer =
        new ExtensionBeanDeployer(deploymentManager, deployment, bdaMapping, contexts);
    extensionBeanDeployer.addExtensions(extensions);
    extensionBeanDeployer.deployBeans();

    installFastProcessAnnotatedTypeResolver(deploymentManager.getServices());

    // Add the Deployment BeanManager Bean to the Deployment BeanManager
    deploymentManager.addBean(new BeanManagerBean(deploymentManager));
    deploymentManager.addBean(new BeanManagerImplBean(deploymentManager));

    // Re-Read the deployment structure, bdaMapping will be the physical
    // structure, and will add in BDAs for any extensions outside a
    // physical BDA
    deploymentVisitor.visit();

    BeforeBeanDiscoveryImpl.fire(deploymentManager, deployment, bdaMapping, contexts);

    // for each physical BDA transform its classes into AnnotatedType instances
    for (BeanDeployment beanDeployment : physicalBeanDeploymentArchives) {
      beanDeployment.createClasses();
    }

    // Re-Read the deployment structure, bdaMapping will be the physical
    // structure, extensions and any classes added using addAnnotatedType
    // outside the physical BDA
    deploymentVisitor.visit();

    for (BeanDeployment beanDeployment : getBeanDeployments()) {
      beanDeployment.createTypes();
    }

    AfterTypeDiscoveryImpl.fire(deploymentManager, deployment, bdaMapping, contexts);

    for (BeanDeployment beanDeployment : getBeanDeployments()) {
      beanDeployment.createEnablement();
    }
  }
Пример #29
0
 public BeanManagerProxy(BeanManagerImpl manager) {
   this.manager = manager;
   this.nonPortableMode =
       manager
           .getServices()
           .get(WeldConfiguration.class)
           .getBooleanProperty(ConfigurationKey.NON_PORTABLE_MODE);
 }
Пример #30
0
 public InjectionTargetService(BeanManagerImpl beanManager) {
   this.validator = beanManager.getServices().get(Validator.class);
   this.producersToValidate = new ConcurrentLinkedQueue<Producer<?>>();
   this.injectionTargetsToInitialize =
       new ConcurrentLinkedQueue<InjectionTargetInitializationContext<?>>();
   this.container = Container.instance(beanManager);
   this.beanManager = beanManager;
 }