SeamFramework.orgCommunity Documentation

Chapter 18. Application servers and environments supported by Weld

18.1. Using Weld with WildFly
18.2. GlassFish
18.3. Servlet containers (such as Tomcat or Jetty)
18.3.1. Tomcat
18.3.2. Jetty
18.4. Java SE
18.4.1. CDI SE Module
18.4.2. Bean Discovery Mode in Weld SE
18.4.3. Bootstrapping CDI SE
18.4.4. Thread Context
18.4.5. Setting the Classpath
18.4.6. Bean archive isolation

If you are using WildFly 8.0 or better, no additional configuration is required to use Weld (or CDI for that matter).

Weld is also built into GlassFish from V3 onwards. Since GlassFish V3 is the Java EE 6 reference implementation, it must support all features of CDI. What better way for GlassFish to support these features than to use Weld, the CDI reference implementation? Just package up your CDI application and deploy.

While CDI does not require support for servlet environments, Weld can be used in a servlet container, such as Tomcat or Jetty.

Weld can be used as a library in an web application that is deployed to a Servlet container. You should place weld-servlet.jar within the WEB-INF/lib directory relative to the web root. weld-servlet.jar is an "uber-jar", meaning it bundles all the bits of Weld and CDI required for running in a Servlet container, for your convenience. Alternatively, you can use its component jars. A list of transitive dependencies can be found in the META-INF/DEPENDENCIES.txt file inside the weld-servlet.jar artifact.

You also need to explicitly specify the servlet listener (used to boot Weld, and control its interaction with requests) in WEB-INF/web.xml in the web root:


Actually you don't have to register this listener in Servlet 3.x compliant containers which support javax.servlet.ServletContainerInitializer service properly (e.g. Tomcat 7.0.50). In this case org.jboss.weld.environment.servlet.EnhancedListener will do all the necessary work automatically, and what is more important - injection into Listeners will work on some containers as well (see Section 18.3.1, “Tomcat” and Section 18.3.2, “Jetty” for more info).

The downside of javax.servlet.ServletContainerInitializer approach is that the Weld listener will be added to the end of the ordered list of discovered listeners. In practice the request and session context will not be active during ServletRequestListener and HttpSessionListener notifications. Fortunately, it's possible to combine the EnhancedListener and the old Listener to fix this problem - simply add the old Listener to the web.xml as mentioned above. Note that it must be defined before the listeners using request and session context.


There is quite a special use-case where one more special component must be involved. If you want the session context to be active during HttpSessionListener.sessionDestroyed() invocation when the session times out or when all the sessions are destroyed because the deployment is being removed then org.jboss.weld.servlet.WeldTerminalListener must be specified as the last one in your web.xml. This listener activates the session context before other listeners are invoked (note that the listeners are notified in reverse order when a session is being destroyed).

Since Weld 2.0.2.Final only Jetty 7, 8 and 9 are supported.

To bind the BeanManager into JNDI, you should either populate WEB-INF/jetty-env.xml with the following contents:

<!DOCTYPE Configure PUBLIC "-//Mort Bay Consulting//DTD Configure//EN"

<Configure id="webAppCtx" class="org.eclipse.jetty.webapp.WebAppContext">
    <New id="BeanManager" class="">
        <Arg> <Ref id="webAppCtx"/> </Arg>
            <New class="javax.naming.Reference">

Or you can configure a special Servlet listener to bind the BeanManager automatically:


Just like in Tomcat, you need to make the BeanManager available to your deployment by adding this to the bottom of web.xml:


Jetty only allows you to bind entries tojava:comp/env, so the BeanManager will be available at java:comp/env/BeanManager

Weld also supports Servlet and Filter injection in Jetty containers. Listener injection should also work on Jetty 9.1.x and newer versions.

In addition to improved integration of the Enterprise Java stack, the "Contexts and Dependency Injection for the Java EE platform" specification also defines a state of the art typesafe, stateful dependency injection framework, which can prove useful in a wide range of application types. To help developers take advantage of this, Weld provides a simple means for being executed in the Java Standard Edition (SE) environment independently of any Java EE APIs.

When executing in the SE environment the following features of Weld are available:

EJB beans are not supported.

CDI SE applications can be bootstrapped in the following ways.

For added flexibility, CDI SE also comes with a bootstrap API which can be called from within your application in order to initialize CDI and obtain references to your application's beans and events. The API consists of two classes: Weld and WeldContainer.

public class Weld

   /** Boots Weld and creates and returns a WeldContainer instance, through which
    * beans and events can be accesed. */
   public WeldContainer initialize() {...}
   /** Convenience method for shutting down the container. */
   public void shutdown() {...}
public class WeldContainer

   /** Provides access to all beans within the application. */
   public Instance<Object> instance() {...}
   /** Provides access to all events within the application. */
   public Event<Object> event() {...}
   /** Provides direct access to the BeanManager. */
   public BeanManager getBeanManager() {...}

Here's an example application main method which uses this API to initialize a bean of typeMyApplicationBean.


public static void main(String[] args) {
   Weld weld = new Weld();
   WeldContainer container = weld.initialize();

Alternatively the application could be started by firing a custom event which would then be observed by another simple bean. The following example fires MyEvent on startup.;

public static void main(String[] args) {
   Weld weld = new Weld();
   WeldContainer container = weld.initialize();
   container.event().select(MyEvent.class).fire( new MyEvent() );