Package org.jboss.weld.environment.se

Class Weld

  • All Implemented Interfaces:
    ContainerInstanceFactory
    @Vetoed
public class Weld
extends Object
implements ContainerInstanceFactory

    This builder is a preferred method of booting Weld SE container.

    Typical usage looks like this: 

     WeldContainer container = new Weld().initialize();
 container.select(Foo.class).get();
 container.event().select(Bar.class).fire(new Bar());
 container.shutdown();

    The WeldContainer implements AutoCloseable: 

     try (WeldContainer container = new Weld().initialize()) {
     container.select(Foo.class).get();
 }

    By default, the discovery is enabled so that all beans from all discovered bean archives are considered. However, it's possible to define a "synthetic" bean archive, or the set of bean classes and enablement respectively: 

     WeldContainer container = new Weld().beanClasses(Foo.class, Bar.class).alternatives(Bar.class).initialize()) {

    Moreover, it's also possible to disable the discovery completely so that only the "synthetic" bean archive is considered: 

     WeldContainer container = new Weld().disableDiscovery().beanClasses(Foo.class, Bar.class).initialize()) {

    In the same manner, it is possible to explicitly declare interceptors, decorators, extensions and Weld-specific options (such as relaxed construction) using the builder. 

     Weld builder = new Weld()
    .disableDiscovery()
    .packages(Main.class, Utils.class)
    .interceptors(TransactionalInterceptor.class)
    .property("org.jboss.weld.construction.relaxed", true);
 WeldContainer container = builder.initialize();

    The builder is reusable which means that it's possible to initialize multiple Weld containers with one builder. However, note that containers must have a unique identifier assigned when running multiple Weld instances at the same time.

    Author:
    Peter Royle, Pete Muir, Ales Justin, Martin Kouba
    See Also:
    WeldContainer

    • Field Detail

      • ARCHIVE_ISOLATION_SYSTEM_PROPERTY

        public static final String ARCHIVE_ISOLATION_SYSTEM_PROPERTY
        By default, bean archive isolation is enabled. If set to false, Weld will use a "flat" deployment structure - all bean classes share the same bean archive and all beans.xml descriptors are automatically merged into one.

        This key can be also used through property(String, Object).

        See Also:
        Constant Field Values

      • DEV_MODE_SYSTEM_PROPERTY

        public static final String DEV_MODE_SYSTEM_PROPERTY
        By default, the development mode is disabled. If set to true, the development mode is activated

        This key can be also used through property(String, Object).

        See Also:
        Constant Field Values

      • SHUTDOWN_HOOK_SYSTEM_PROPERTY

        public static final String SHUTDOWN_HOOK_SYSTEM_PROPERTY
        By default, Weld automatically registers shutdown hook during initialization. If set to false, the registration of a shutdown hook is skipped.

        This key can be also used through property(String, Object).

        See Also:
        Constant Field Values

      • SCAN_CLASSPATH_ENTRIES_SYSTEM_PROPERTY

        public static final String SCAN_CLASSPATH_ENTRIES_SYSTEM_PROPERTY
        By default, Weld SE does not support implicit bean archives without beans.xml. If set to true, Weld scans the class path entries and implicit bean archives which don't contain a beans.xml file are also supported.

        This key can be also used through property(String, Object).

        See Also:
        Constant Field Values

    • Constructor Detail

      • Weld

        public Weld()

    • Method Detail

      • containerId

        public Weld containerId​(String containerId)
        Containers must have a unique identifier assigned when running multiple Weld instances at the same time.
        Parameters:
        containerId -
        Returns:
        self

      • beanClasses

        public Weld beanClasses​(Class<?>... classes)
        Define the set of bean classes for the synthetic bean archive.
        Parameters:
        classes -
        Returns:
        self

      • addBeanClass

        public Weld addBeanClass​(Class<?> beanClass)
        Add a bean class to the set of bean classes for the synthetic bean archive.
        Parameters:
        beanClass -
        Returns:
        self

      • packages

        public Weld packages​(Class<?>... packageClasses)
        All classes from the packages of the specified classes will be added to the set of bean classes for the synthetic bean archive.

        Note that the scanning possibilities are limited. Therefore, only directories and jar files from the filesystem are supported.

        Scanning may also have negative impact on bootstrap performance.

        Parameters:
        classes -
        Returns:
        self

      • addPackages

        public Weld addPackages​(boolean scanRecursively,
                        Class<?>... packageClasses)
        Packages of the specified classes will be scanned and found classes will be added to the set of bean classes for the synthetic bean archive.
        Parameters:
        scanRecursively -
        packageClasses -
        Returns:
        self

      • addPackage

        public Weld addPackage​(boolean scanRecursively,
                       Class<?> packageClass)
        A package of the specified class will be scanned and found classes will be added to the set of bean classes for the synthetic bean archive.
        Parameters:
        scanRecursively -
        packageClass -
        Returns:
        self

      • extensions

        public Weld extensions​(javax.enterprise.inject.spi.Extension... extensions)
        Define the set of extensions.
        Parameters:
        extensions -
        Returns:
        self

      • addExtension

        public Weld addExtension​(javax.enterprise.inject.spi.Extension extension)
        Add an extension to the set of extensions.
        Parameters:
        extension - an extension

      • interceptors

        public Weld interceptors​(Class<?>... interceptorClasses)
        Enable interceptors for a synthetic bean archive. Interceptor classes are automatically added to the set of bean classes.
        Parameters:
        interceptorClasses -
        Returns:
        self

      • addInterceptor

        public Weld addInterceptor​(Class<?> interceptorClass)
        Add an interceptor class to the list of enabled interceptors for a synthetic bean archive.
        Parameters:
        interceptorClass -
        Returns:
        self

      • decorators

        public Weld decorators​(Class<?>... decoratorClasses)
        Enable decorators for a synthetic bean archive. Decorator classes are automatically added to the set of bean classes for the synthetic bean archive.
        Parameters:
        decoratorClasses -
        Returns:
        self

      • addDecorator

        public Weld addDecorator​(Class<?> decoratorClass)
        Add a decorator class to the list of enabled decorators for a synthetic bean archive.
        Parameters:
        decoratorClass -
        Returns:
        self

      • alternatives

        public Weld alternatives​(Class<?>... alternativeClasses)
        Select alternatives for a synthetic bean archive.
        Parameters:
        alternativeClasses -
        Returns:
        self

      • addAlternative

        public Weld addAlternative​(Class<?> alternativeClass)
        Add an alternative class to the list of selected alternatives for a synthetic bean archive.
        Parameters:
        alternativeClass -
        Returns:
        self

      • alternativeStereotypes

        @SafeVarargs
public final Weld alternativeStereotypes​(Class<? extends Annotation>... alternativeStereotypeClasses)
        Select alternative stereotypes for a synthetic bean archive.
        Parameters:
        alternativeStereotypeClasses -
        Returns:
        self

      • addAlternativeStereotype

        public Weld addAlternativeStereotype​(Class<? extends Annotation> alternativeStereotypeClass)
        Add an alternative stereotype class to the list of selected alternative stereotypes for a synthetic bean archive.
        Parameters:
        alternativeStereotypeClass -
        Returns:
        self

      • reset

        public Weld reset()
        Reset the synthetic bean archive (bean classes and enablement) and explicitly added extensions.
        Returns:
        self

      • resetAll

        public Weld resetAll()
        Reset all the state, except for initialized containers.
        Returns:
        self
        See Also:
        reset()

      • disableDiscovery

        public Weld disableDiscovery()
        By default, the discovery is enabled. However, it's possible to disable the discovery completely so that only the "synthetic" bean archive is considered.
        Returns:
        self

      • isDiscoveryEnabled

        public boolean isDiscoveryEnabled()
        Returns:
        true if the discovery is enabled, false otherwise
        See Also:
        disableDiscovery()

      • initialize

        public WeldContainer initialize()
        Bootstraps a new Weld SE container with the current containerId.

        The container must be shut down properly when an application is stopped. Applications are encouraged to use the try-with-resources statement or invoke WeldContainer.shutdown() explicitly.

        However, a shutdown hook is also registered during initialization so that all running containers are shut down automatically when a program exits or VM is terminated. This means that it's not necessary to implement the shutdown logic in a class where a main method is used to start the container.

        Specified by:
        initialize in interface ContainerInstanceFactory
        Returns:
        the Weld container
        See Also:
        enableDiscovery(), WeldContainer.shutdown()

      • shutdown

        public void shutdown()
        Shuts down all the containers initialized by this builder.

      • setClassLoader

        public Weld setClassLoader​(ClassLoader classLoader)
        Set a ClassLoader. The given ClassLoader will be scanned automatically for bean archives if scanning is enabled.
        Parameters:
        classLoader -
        Returns:
        self

      • setResourceLoader

        public Weld setResourceLoader​(org.jboss.weld.resources.spi.ResourceLoader resourceLoader)
        Set a ResourceLoader used to scan the application for bean archives. If you only want to use a specific ClassLoader for scanning, use setClassLoader(ClassLoader) instead.
        Parameters:
        resourceLoader -
        Returns:
        self
        See Also:
        isDiscoveryEnabled()

      • createDeployment

        protected org.jboss.weld.bootstrap.spi.Deployment createDeployment​(org.jboss.weld.resources.spi.ResourceLoader resourceLoader,
                                                                   org.jboss.weld.bootstrap.api.CDI11Bootstrap bootstrap)

        Extensions to Weld SE can subclass and override this method to customize the deployment before weld boots up. For example, to add a custom ResourceLoader, you would subclass Weld like so: 

         public class MyWeld extends Weld {
     protected Deployment createDeployment(ResourceLoader resourceLoader, CDI11Bootstrap bootstrap) {
         return super.createDeployment(new MyResourceLoader(), bootstrap);
     }
 }

        This could then be used as normal: 

         WeldContainer container = new MyWeld().initialize();
        Parameters:
        resourceLoader -
        bootstrap -

      • getInstanceByType

        protected <T> T getInstanceByType​(javax.enterprise.inject.spi.BeanManager manager,
                                  Class<T> type,
                                  Annotation... bindings)
        Utility method allowing managed instances of beans to provide entry points for non-managed beans (such as WeldContainer). Should only called once Weld has finished booting.
        Parameters:
        manager - the BeanManager to use to access the managed instance
        type - the type of the Bean
        bindings - the bean's qualifiers
        Returns:
        a managed instance of the bean
        Throws:
        IllegalArgumentException - if the given type represents a type variable
        IllegalArgumentException - if two instances of the same qualifier type are given
        IllegalArgumentException - if an instance of an annotation that is not a qualifier type is given
        javax.enterprise.inject.UnsatisfiedResolutionException - if no beans can be resolved * @throws AmbiguousResolutionException if the ambiguous dependency resolution rules fail
        IllegalArgumentException - if the given type is not a bean type of the given bean