In a web application always put the stuff (which is not packaged a single JARs)  in /WEB-INF/classes/META-INF (e.g. persistence.xml or service files) and not in /META-INF. Otherwise the various applications will not be able to locate them.

Having said that lets go to…

Obtaining the BeanManager

In your web.xml/context.xml you declared a managed resource called BeanManager which is main interface to all Bean related stuff (adding/removing beans from a context etc.). There are two ways for obtaining the Bean Manager. The first way is to use dependey injection with the @Resource annotation:

@Resource(mappedName="java:/comp/env/BeanManager")
BeanManager beanManager;

Here you let the container do all the work. Or you cann ask Weld to inject the BeanManager by using @Inject:

@Inject
BeanManager beanManager;

Simple Dependency Injection

In the previous section I made a little trip to the future by using the @Inject annotation. As you might have already guessed this annotation tells Weld that the field/parameter should be injected. This is the simplest dependency injection available. You just tell Weld that you need something injected and Weld takes care of it. A good example for this would be a Cache which is typically application scoped (although every scoped bean can be injected):

package de.publicstaticfinal.web.jsf;

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Named;

@Named
@ApplicationScoped
public class Cache {...}

As you learned already this managed bean can be accessed via EL using #{cache}. But most often you’re not only using the Cache in the frontend but in the business logic too. The extenden HelloWeld bean would look like this:

package de.publicstaticfinal.web.jsf;

import java.io.Serializable;
import javax.enterprise.context.SessionScoped;
import javax.inject.Named;

@Named("helloWeld")
@SessionScoped
public class HelloWeld implements Serializable {
  private String message = "Hello Weld";

  @Inject
  private transient Cache cache;

  public String getMessage() {
    return message;
  }
}

The injected Cache object has to be marked as transient since HelloWeld is serializable while the Cache is not. If the cache field is not marked as transient Weld will throw an Exception since it enforces serializability. This is really a good feature in Weld since it leads to consistent data.

Another good point is that you can use loose coupling without much effort. If the Cache class above would be “CacheImpl” and implementing a Cache interface you don’t have to change your code that much. The Cache implementation class would look like this:

package de.publicstaticfinal.web.jsf;

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Named;

@Named("cache")
@ApplicationScoped
public class CacheImpl implements Cache
{

}

And the CacheImpl would be injected like this:

@Inject @Named("cache")
private transient Cache cache;

What if you need mor than one Caches? I’m too lazy at the moment to think of a scenario where you might need this but of course this is possible. Although with the restriction that this cannot be achieved directly by dependency injection. If you asked yourself why I explained how to obtain the BeanManager here’s the answer: the BeanManager helps you to create new instances of an injectable resource. The following mehtod gets called with getNewCache(“cache”):

private Cache getNewCache(String elName) {
  Set<Bean<?>> beans = beanManager.getBeans(elName);
  for (Bean<?> bean : beans) {
    Set<Type> beanTypes = bean.getTypes();
    for (Type type : beanTypes) {
      if (type.equals(Cache.class)) {
        Bean<Cache> tmp = (Bean<Cache>) bean;
        Cache newCache = tmp.create(beanManager.createCreationalContext(tmp));
        return newCache;
      }
    }
 }
 return null;
}

• 2: In this line all beans which can be accessed by #{cache} are retrieved
• 4: all types of the bean are read
• 6: Check if the bean is of type Cache
• 7: cast to the proper type
• 8: retrieval of the proxy object by api calls

I’m not going into detail of every single API call. If you’re interested in more information please refer to the Javadoc (link: http://docs.jboss.org/cdi/api/1.0-CR1/).

I think that’s enough for the second part of my tutorial. This part just covered injection of scoped beans. While this is a pretty powerful tool JSR-299 doesn’t limit injection to scoped beans. Generally speaking you can blow inject your foot away using Weld.

• Mojarra 2.0.0 (Instructions for obtaining can be found here)
• Weld 1.0.0CR1 Servlet Environment (“weld-servlet.jar” contained in Weld donwload archive)
• JSR-250 API
• jstl 1.2
• el-impl 2.1.2-b04

Thats’s not really much (just about 5 MB of JARs) but all you need to get your application running. I’m not going into detail on how to configurate JSF but just what’s additionally required for Weld.

First you have to “tell” Weld and Tomcat that Weld is present by including the Weld Servlet listener in your application’s web.xml:

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

After that create an empty file called “beans.xml” in the WEB-INF folder. Now Weld can do its magical stuff with all incoming Servlet request. Buth there’s more. This was just the setup of the Weld Servlet environment. Next you need to tell Weld what BeanManager should be used. The BeanManager is the reference to the Injection Manager itself.

The first thing to add is a resource reference in web.xml:

<resource-env-ref>
 <description>Object factory for the CDI Bean Manager</description>
 <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>

And finally if not already present create META-INF/context.xml and put the Resource itself in it:

<Resource
 name="BeanManager"
 auth="Container"
 type="javax.enterprise.inject.spi.BeanManager"
 factory="org.jboss.weld.resources.ManagerObjectFactory"
/>

That’s all. Tomcat6 is now running with JSF 2.0 and Weld 1.0.0CR1 and ready for hours of fun. As you might have already guessed this post doesn’t contain anything about how to use Weld but just how to set it up with Tomcat6. However I’m writing a short introduction for Wled which should be online within 3 or 4 days.

UPDATE: For those using Maven here’s a simple POM containing the required repositories and dependencies:

<project
 xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>de.publicstaticfinal</groupId>
 <artifactId>WeldJSF2</artifactId>
 <packaging>war</packaging>
 <version>0.0.1-SNAPSHOT</version>
 <repositories>
  <repository>
   <id>maven2-repository.dev.java.net</id>
   <name>Java.net Repository for Maven</name>
   <url>http://download.java.net/maven/2/</url>
   <layout>default</layout>
  </repository>
  <repository>
  <snapshots />
   <id>ibiblio</id>
   <url>http://www.ibiblio.org/maven2/</url>
   </repository>
   <repository>
   <id>JBoss</id>
   <url>http://repository.jboss.com/maven2</url>
  </repository>
 </repositories>
 <dependencies>
  <dependency>
   <groupId>com.sun.faces</groupId>
   <artifactId>jsf-api</artifactId>
   <version>2.0.1</version>
  </dependency>
  <dependency>
   <groupId>com.sun.faces</groupId>
   <artifactId>jsf-impl</artifactId>
   <scope>runtime</scope>
   <version>2.0.1</version>
  </dependency>
  <dependency>
   <groupId>javax.enterprise</groupId>
   <artifactId>cdi-api</artifactId>
   <scope>provided</scope>
   <version>1.0-CR1</version>
  </dependency>
  <dependency>
   <groupId>javax.annotation</groupId>
   <artifactId>jsr250-api</artifactId>
   <version>1.0</version>
  </dependency>
  <dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>jstl</artifactId>
   <version>1.2</version>
   <scope>runtime</scope>
  </dependency>
  <dependency>
   <groupId>org.jboss.weld.servlet</groupId>
   <artifactId>weld-servlet</artifactId>
   <version>1.0.0-CR1</version>
   <scope>runtime</scope>
  </dependency>
  <dependency>
   <groupId>org.glassfish.web</groupId>
   <artifactId>el-impl</artifactId>
   <version>2.1.2-b04</version>
   <scope>runtime</scope>
   <exclusions>
    <exclusion>
     <groupId>javax.el</groupId>
     <artifactId>el-api</artifactId>
    </exclusion>
   </exclusions>
  </dependency>
 </dependencies>
</project>