What does not work out of the box is binding BeanManager to JNDI. Tomcat has a read-only JNDI, so Weld can’t automatically bind the BeanManager extension SPI. To bind the BeanManager into JNDI, you should populate META-INF/context.xml in the web root with the following contents:

<Context>

   <Resource name="BeanManager"

      auth="Container"

      type="javax.enterprise.inject.spi.BeanManager"

      factory="org.jboss.weld.resources.ManagerObjectFactory"/>

</Context>

and make it available to your deployment by adding this to the bottom of web.xml:

<resource-env-ref>

   <resource-env-ref-name>BeanManager</resource-env-ref-name>

   <resource-env-ref-type>

      javax.enterprise.inject.spi.BeanManager

   </resource-env-ref-type>

</resource-env-ref>

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

With embedded Tomcat it is necessary to register Weld’s listener programmatically:

public class Main {


    public static void main(String[] args) throws ServletException, LifecycleException {

        Tomcat tomcat = new Tomcat();

        Context ctx = tomcat.addContext("/", new File("src/main/resources").getAbsolutePath());


        Tomcat.addServlet(ctx, "hello", HelloWorldServlet.class.getName());

        ctx.addServletMapping("/*", "hello");


        // ctx.addApplicationListener(Listener.class.getName()); 


        tomcat.start();

        tomcat.getServer().await();

    }


    public static class HelloWorldServlet extends HttpServlet {


        @Inject

        private BeanManager manager;


        @Override

        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

            resp.setContentType("text/plain");

            resp.getWriter().append("Hello from " + manager);

        }

    }

}

No further configuration is needed when starting Jetty as an embedded webapp server from within another Java program. However, if you’re using a Jetty standalone instance one more configuration step is required.

The reason is that since Jetty 8 some internal classes are not visible from the web application. See also Setting Server Classes. Therefore, we have to tell Jetty not to hide the system classes which Weld integration code is using. Unfortunately, it’s not so simple. The only workaround is to use a Jetty Deployable Descriptor XML File (this is a Jetty 9 feature, in Jetty 8 a similar feature is incorporated - ContextProvider). For instance, if there is an application archive named weld-numberguess.war deployed in the webapps directory, an XML descriptor named weld-numberguess.xml should be created in the same directory (the file should have the same base name as the war - see alse the scanning rules described in Jetty docs):

<?xml version="1.0"?>

<!DOCTYPE Configure PUBLIC "-//Mort Bay Consulting//DTD Configure//EN" "http://www.eclipse.org/jetty/configure_9_0.dtd">

<Configure class="org.eclipse.jetty.webapp.WebAppContext">

  <Set name="contextPath">/weld-numberguess</Set>

  <Set name="war"><Property name="jetty.webapps" default="."/>/weld-numberguess.war</Set>

  <Call name="prependServerClass">

    <Arg>-org.eclipse.jetty.server.handler.ContextHandler</Arg>

  </Call>

  <Call name="prependServerClass">

    <Arg>-org.eclipse.jetty.servlet.FilterHolder</Arg>

  </Call>

  <Call name="prependServerClass">

    <Arg>-org.eclipse.jetty.servlet.ServletContextHandler</Arg>

  </Call>

  <Call name="prependServerClass">

    <Arg>-org.eclipse.jetty.servlet.ServletHolder</Arg>

  </Call>

</Configure>

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"

   "http://www.eclipse.org/jetty/configure.dtd">



<Configure id="webAppCtx" class="org.eclipse.jetty.webapp.WebAppContext">

    <New id="BeanManager" class="org.eclipse.jetty.plus.jndi.Resource">

        <Arg> <Ref id="webAppCtx"/> </Arg>

        <Arg>BeanManager</Arg>

        <Arg>

            <New class="javax.naming.Reference">

                <Arg>javax.enterprise.inject.spi.BeanManager</Arg>

                <Arg>org.jboss.weld.resources.ManagerObjectFactory</Arg>

                <Arg/>

            </New>

        </Arg>

    </New>

</Configure>

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

<listener>

   <listener-class>org.jboss.weld.environment.servlet.BeanManagerResourceBindingListener</listener-class>

</listener>

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

<resource-env-ref>

   <resource-env-ref-name>BeanManager</resource-env-ref-name>

   <resource-env-ref-type>

      javax.enterprise.inject.spi.BeanManager

   </resource-env-ref-type>

</resource-env-ref>

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

When starting embedded Jetty programmatically from the main method it is necessary to register Weld’s listener:

public class Main {


    public static void main(String[] args) throws Exception {

        Server jetty = new Server(8080);

        WebAppContext context = new WebAppContext();

        context.setContextPath("/");

        context.setResourceBase("src/main/resources");

        jetty.setHandler(context);

        context.addServlet(HelloWorldServlet.class, "/*");


        context.addEventListener(new Listener()); 


        jetty.start();

        jetty.join();

    }


    public static class HelloWorldServlet extends HttpServlet {


        @Inject BeanManager manager;


        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

            resp.setContentType("text/plain");

            resp.getWriter().append("Hello from " + manager);

        }

    }

}

Thanks to the power of CDI’s typesafe event model, application developers need not write any bootstrapping code. The Weld SE module comes with a built-in main method which will bootstrap CDI for you and then fire a ContainerInitialized event. The entry point for your application code would therefore be a simple bean which observes the ContainerInitialized event, as in the previous example.

In this case your application can be started by calling the provided main method like so:

java org.jboss.weld.environment.se.StartMain <args>

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.

/** A builder used to bootsrap a Weld SE container. */

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 all the containers initialized by a specific builder instance. */

   public void shutdown() {...}


}

/** Represents a Weld SE container. */

public class WeldContainer implements javax.enterprise.inject.Instance<Object>

{


   /** Provides access to all events within the application. */

   public Event<Object> event() {...}


   /** Provides direct access to the BeanManager. */

   public BeanManager getBeanManager() {...}


   /** Returns the identifier of the container */

   String getId() {...}


   /** Shuts down the container. */

   public void shutdown() {...}


   /** Returns the running container with the specified identifier or null if no such container exists */

   public static WeldContainer instance(String id) {...}


}

Here’s an example application main method which uses this API to bootsrap a Wedl SE container and call a business method of a bean MyApplicationBean.

import org.jboss.weld.environment.se.Weld;


public static void main(String[] args) {

   Weld weld = new Weld();

   WeldContainer container = weld.initialize();

   container.select(MyApplicationBean.class).get().callBusinessMethod();

   container.shutdown();

}

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.

org.jboss.weld.environment.se.Weld;


public static void main(String[] args) {

   Weld weld = new Weld();

   WeldContainer container = weld.initialize();

   container.event().select(MyEvent.class).fire( new MyEvent() );

   // When all observer methods are notified the container shuts down

   container.shutdown();

}

Because WeldContainer implements AutoCloseable, it can be used within a try-with-resources block. Should the execution get out of the code block, the Weld instance is shut down and all managed instances are safely destroyed. Here is an example using the above code but leaving out the shutdown() method:

org.jboss.weld.environment.se.Weld;


public static void main(String[] args) {

   Weld weld = new Weld();

   try (WeldContainer container = weld.initialize()) {

      container.select(MyApplicationBean.class).get().callBusinessMethod();

   }

}

In case of more complex scenarios, it might be handy to gain higher level of control over the bootstraping process. Using the builder, it is possible to disable automatic scanning and to explicitly select classes/packages which will be managed by Weld. Interceptors, decorators and extensions can be defined in the very same manner. Last but not least, builder can be used to set Weld-specific configuration. Following example demonstrates these features:

Weld weld = new Weld()

    .disableDiscovery()

    .packages(Main.class, Utils.class)

    .interceptors(TransactionalInterceptor.class)

    .property("org.jboss.weld.construction.relaxed", true);


try (WeldContainer container = weld.initialize()) {

    MyBean bean = container.select(MyBean.class).get();

    System.out.println(bean.computeResult());

}

Furthermore, it is also possible to create several independent Weld instances. Code snippet below shows how achieve that:

Weld weld = new Weld()

    .disableDiscovery();


weld.containerId("one").beanClasses(MyBean.class).initialize();

weld.containerId("two").beanClasses(OtherBean.class).initialize();


MyBean bean = WeldContainer.instance("one").select(MyBean.class).get();

System.out.println(bean.computeResult());


// Shutdown the first container

WeldContainer.instance("one").shutdown();


// Shutdown all the containers initialized by the builder instance

weld.shutdown();