예제 #1
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;
  }
예제 #2
0
 // needs to be resolved once extension beans are deployed
 private void installFastProcessAnnotatedTypeResolver(ServiceRegistry services) {
   ClassFileServices classFileServices = services.get(ClassFileServices.class);
   if (classFileServices != null) {
     final GlobalObserverNotifierService observers =
         services.get(GlobalObserverNotifierService.class);
     try {
       final FastProcessAnnotatedTypeResolver resolver =
           new FastProcessAnnotatedTypeResolver(observers.getAllObserverMethods());
       services.add(FastProcessAnnotatedTypeResolver.class, resolver);
     } catch (UnsupportedObserverMethodException e) {
       BootstrapLogger.LOG.notUsingFastResolver(e.getObserver());
       return;
     }
   }
 }
예제 #3
0
  private void addImplementationServices(ServiceRegistry services) {
    final WeldModules modules = new WeldModules();
    services.add(WeldModules.class, modules);

    final WeldConfiguration configuration = services.get(WeldConfiguration.class);
    services.add(SlimAnnotatedTypeStore.class, new SlimAnnotatedTypeStoreImpl());
    if (services.get(ClassTransformer.class) == null) {
      throw new IllegalStateException(ClassTransformer.class.getSimpleName() + " not installed.");
    }
    services.add(
        MemberTransformer.class, new MemberTransformer(services.get(ClassTransformer.class)));
    services.add(
        MetaAnnotationStore.class, new MetaAnnotationStore(services.get(ClassTransformer.class)));

    BeanIdentifierIndex beanIdentifierIndex = null;
    if (configuration.getBooleanProperty(ConfigurationKey.BEAN_IDENTIFIER_INDEX_OPTIMIZATION)) {
      beanIdentifierIndex = new BeanIdentifierIndex();
      services.add(BeanIdentifierIndex.class, beanIdentifierIndex);
    }

    services.add(ContextualStore.class, new ContextualStoreImpl(contextId, beanIdentifierIndex));
    services.add(CurrentInjectionPoint.class, new CurrentInjectionPoint());
    services.add(CurrentEventMetadata.class, new CurrentEventMetadata());
    services.add(
        SpecializationAndEnablementRegistry.class, new SpecializationAndEnablementRegistry());
    services.add(MissingDependenciesRegistry.class, new MissingDependenciesRegistry());

    /*
     * Setup ExecutorServices
     */
    ExecutorServices executor = services.get(ExecutorServices.class);
    if (executor == null) {
      executor = ExecutorServicesFactory.create(DefaultResourceLoader.INSTANCE, configuration);
      if (executor != null) {
        services.add(ExecutorServices.class, executor);
      }
    }

    services.add(
        RequiredAnnotationDiscovery.class,
        new RequiredAnnotationDiscovery(services.get(ReflectionCache.class)));

    services.add(GlobalEnablementBuilder.class, new GlobalEnablementBuilder());
    if (!services.contains(HttpContextActivationFilter.class)) {
      services.add(
          HttpContextActivationFilter.class, AcceptingHttpContextActivationFilter.INSTANCE);
    }
    services.add(ProtectionDomainCache.class, new ProtectionDomainCache());

    services.add(ProxyInstantiator.class, ProxyInstantiator.Factory.create(configuration));

    services.add(ObserverNotifierFactory.class, DefaultObserverNotifierFactory.INSTANCE);

    services.add(ResourceInjectionFactory.class, new ResourceInjectionFactory());

    modules.postServiceRegistration(contextId, services);

    /*
     * Setup Validator
     */
    if (configuration.getBooleanProperty(ConfigurationKey.CONCURRENT_DEPLOYMENT)
        && services.contains(ExecutorServices.class)) {
      services.add(
          Validator.class, new ConcurrentValidator(modules.getPluggableValidators(), executor));
    } else {
      services.add(Validator.class, new Validator(modules.getPluggableValidators()));
    }

    GlobalObserverNotifierService observerNotificationService =
        new GlobalObserverNotifierService(services, contextId);
    services.add(GlobalObserverNotifierService.class, observerNotificationService);

    /*
     * Preloader for container lifecycle events
     */
    ContainerLifecycleEventPreloader preloader = null;
    int preloaderThreadPoolSize =
        configuration.getIntegerProperty(ConfigurationKey.PRELOADER_THREAD_POOL_SIZE);
    if (preloaderThreadPoolSize > 0 && Permissions.hasPermission(Permissions.MODIFY_THREAD_GROUP)) {
      preloader =
          new ContainerLifecycleEventPreloader(
              preloaderThreadPoolSize,
              observerNotificationService.getGlobalLenientObserverNotifier());
    }
    services.add(
        ContainerLifecycleEvents.class,
        new ContainerLifecycleEvents(preloader, services.get(RequiredAnnotationDiscovery.class)));
    if (isEEModulesAwareEnvironment()) {
      services.add(BeanDeploymentModules.class, new BeanDeploymentModules(contextId, services));
    }
  }
예제 #4
0
  public WeldRuntime startContainer(
      String contextId, Environment environment, Deployment deployment) {
    if (deployment == null) {
      throw BootstrapLogger.LOG.deploymentRequired();
    }

    checkApiVersion();

    final ServiceRegistry registry = deployment.getServices();

    // initiate part of registry in order to allow access to WeldConfiguration
    new AdditionalServiceLoader(deployment).loadAdditionalServices(registry);

    // Resource Loader has to be loaded prior to WeldConfiguration
    if (!registry.contains(ResourceLoader.class)) {
      registry.add(ResourceLoader.class, DefaultResourceLoader.INSTANCE);
    }

    WeldConfiguration configuration = new WeldConfiguration(registry, deployment);
    registry.add(WeldConfiguration.class, configuration);

    String finalContextId =
        BeanDeployments.getFinalId(
            contextId,
            registry.get(WeldConfiguration.class).getStringProperty(ROLLING_UPGRADES_ID_DELIMITER));
    this.contextId = finalContextId;
    this.deployment = deployment;
    this.environment = environment;

    if (this.extensions == null) {
      setExtensions(deployment.getExtensions());
    }
    // Add extension to register built-in components
    this.extensions.add(MetadataImpl.from(new WeldExtension()));

    // Add Weld extensions
    String vetoTypeRegex =
        configuration.getStringProperty(
            ConfigurationKey.VETO_TYPES_WITHOUT_BEAN_DEFINING_ANNOTATION);
    if (!vetoTypeRegex.isEmpty()) {
      this.extensions.add(MetadataImpl.from(new WeldVetoExtension(vetoTypeRegex)));
    }

    // Finish the rest of registry init, setupInitialServices() requires already changed
    // finalContextId
    setupInitialServices();
    registry.addAll(initialServices.entrySet());

    if (!registry.contains(ProxyServices.class)) {
      registry.add(ProxyServices.class, new SimpleProxyServices());
    }
    if (!registry.contains(SecurityServices.class)) {
      registry.add(SecurityServices.class, NoopSecurityServices.INSTANCE);
    }

    addImplementationServices(registry);

    verifyServices(registry, environment.getRequiredDeploymentServices(), contextId);
    if (!registry.contains(TransactionServices.class)) {
      BootstrapLogger.LOG.jtaUnavailable();
    }

    this.deploymentManager = BeanManagerImpl.newRootManager(finalContextId, "deployment", registry);

    Container.initialize(
        finalContextId,
        deploymentManager,
        ServiceRegistries.unmodifiableServiceRegistry(deployment.getServices()));
    getContainer().setState(ContainerState.STARTING);

    this.contexts = createContexts(registry);

    this.bdaMapping = new BeanDeploymentArchiveMapping();
    this.deploymentVisitor =
        new DeploymentVisitor(deploymentManager, environment, deployment, contexts, bdaMapping);

    if (deployment instanceof CDI11Deployment) {
      registry.add(
          BeanManagerLookupService.class,
          new BeanManagerLookupService(
              (CDI11Deployment) deployment, bdaMapping.getBdaToBeanManagerMap()));
    } else {
      BootstrapLogger.LOG.legacyDeploymentMetadataProvided();
    }

    // Read the deployment structure, bdaMapping will be the physical structure
    // as caused by the presence of beans.xml
    deploymentVisitor.visit();

    return new WeldRuntime(finalContextId, deploymentManager, bdaMapping.getBdaToBeanManagerMap());
  }