CDI is fully integrated into the Java EE environment. Beans have access to Java EE resources and JPA persistence contexts. They may be used in Unified EL expressions in JSF and JSP pages. They may even be injected into other platform components, such as servlets and message-driven Beans, which are not beans themselves.

In the Java EE environment, the container provides the following built-in beans, all with the qualifier @Default: the current JTA UserTransaction, a Principal representing the current caller identity, the default Bean Validation ValidationFactory, and a Validator for the default ValidationFactory. The CDI specification does not require the servlet context objects, HttpServletRequest, HttpSession and ServletContext to be exposed as injectable beans. If you really want to be able to inject these objects, it's easy to create a portable extension to expose them as beans. However, we recommend that direct access to these objects be limited to servlets, servlet filters and servlet event listeners, where they may be obtained in the usual way as defined by the Java Servlets spec. The FacesContext is also not injectable. You can get at it by calling FacesContext.getCurrentInstance(). Oh, you really want to inject the FacesContext? Alright then, try this producer method:

All managed beans may take advantage of Java EE component environment injection using @Resource, @EJB, @PersistenceContext, @PeristenceUnit and @WebServiceRef. We've already seen a couple of examples of this, though we didn't pay much attention at the time: The Java EE @PostConstruct and @PreDestroy callbacks are also supported for all managed beans. The @PostConstruct method is called after all injection has been performed. Of course, we advise that component environment injection be used to define CDI resources, and that typesafe injection be used in application code.

It's easy to use a bean from a servlet in Java EE 6. Simply inject the bean using field or initializer method injection. Since instances of servlets are shared across all incoming threads, the bean client proxy takes care of routing method invocations from the servlet to the correct instances of Credentials and Login for the current request and HTTP session.

CDI injection applies to all EJBs, even when they aren't managed beans. In particular, you can use CDI injection in message-driven beans, which are by nature not contextual objects. You can even use CDI interceptor bindings for message-driven Beans. Please note that there is no session or conversation context available when a message is delivered to a message-driven bean. Only @RequestScoped and @ApplicationScoped beans are available. But how about beans which send JMS messages?

Sending messages using JMS can be quite complex, because of the number of different objects you need to deal with. For queues we have Queue, QueueConnectionFactory, QueueConnection, QueueSession and QueueSender. For topics we have Topic, TopicConnectionFactory, TopicConnection, TopicSession and TopicPublisher. Each of these objects has its own lifecycle and threading model that we need to worry about. You can use producer fields and methods to prepare all of these resources for injection into a bean: In this example, we can just inject the prepared MessageProducer, Connection or QueueSession: The lifecycle of the injected JMS objects is completely controlled by the container.

CDI doesn't define any special deployment archive. You can package beans in jars, ejb jars or wars—any deployment location in the application classpath. However, the archive must be a "bean archive". That means each archive that contains beans must include a file named beans.xml in the META-INF directory of the classpath or WEB-INF directory of the web root (for war archives). The file may be empty. Beans deployed in archives that do not have a beans.xml file will not be available for use in the application. In an embeddable EJB container, beans may be deployed in any location in which EJBs may be deployed. Again, each location must contain a beans.xml file.