This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process) and is written to declare its intent and scope. We solicit additional participation and input from the community. Please login and add your feedback in the comments section.

This project is created as part of the process of transitioning Java EE 8 technologies to the Eclipse Foundation as described in The EE4J Project Top Level Project Charter. Unlike most of the Java EE specifications, Contexts and Dependency Injection was led by a non-Oracle organization, namely Red Hat.

The project aims to continue the standardization work of the Contexts and Dependency Injection (CDI) specification, which is part of the Java EE platform, but which also is designed since version 2.0 for use in Java SE environments. Previous revisions of that specification were created under the Java Community Process (JCP):

• CDI 1.0 (JSR 299), part of Java EE 6
• CDI 1.1 and 1.2 (JSR 346), part of Java EE 7
• CDI 2.0 (JSR 365), part of Java EE 8

Quoting the CDI2.0 specification, its goals are these:

This specification defines a powerful set of complementary services that help to improve the structure of application code.

• A well-defined lifecycle for stateful objects bound to lifecycle contexts, where the set of contexts is extensible

• A sophisticated, typesafe dependency injection mechanism, including the ability to select dependencies at either development or deployment time, without verbose configuration

• Support for Java EE modularity and the Java EE component architecture - the modular structure of a Java EE application is taken into account when resolving dependencies between Java EE components

• Integration with the Unified Expression Language (EL), allowing any contextual object to be used directly within a JSF or JSP page

• The ability to decorate injected objects

• The ability to associate interceptors to objects via typesafe interceptor bindings

• An event notification model

• A web conversation context in addition to the three standard web contexts defined by the Java Servlets specification

• An SPI allowing portable extensions to integrate cleanly with the container

The services defined by this specification allow objects to be bound to lifecycle contexts, to be injected, to be associated with interceptors and decorators, and to interact in a loosely coupled fashion by firing and observing events. Various kinds of objects are injectable, including EJB 3 session beans, managed beans and Java EE resources. We refer to these objects in general terms as beans and to instances of beans that belong to contexts as contextual instances. Contextual instances may be injected into other objects by the dependency injection service.

To take advantage of these facilities, the developer provides additional bean-level metadata in the form of Java annotations and application-level metadata in the form of an XML descriptor.

The use of these services significantly simplifies the task of creating Java EE applications by integrating the Java EE web tier with Java EE enterprise services. In particular, EJB components may be used as JSF managed beans, thus integrating the programming models of EJB and JSF.

It’s even possible to integrate with third-party frameworks. A portable extension may provide objects to be injected or obtain contextual instances using the dependency injection service. The framework may even raise and observe events using the event notification service.

An application that takes advantage of these services may be designed to execute in either the Java EE environment or the Java SE environment. If the application uses Java EE services such as transaction management and persistence in the Java SE environment, the services are usually restricted to, at most, the subset defined for embedded usage by the EJB specification.