# The Java EE 7 Tutorial

# 23.1 Getting Started

Contexts and Dependency Injection (CDI) enables your objects to have their dependencies provided to them automatically, instead of creating them or receiving them as parameters. CDI also manages the lifecycle of those dependencies for you.

For example, consider the following servlet:

    @WebServlet("/cdiservlet")
    public class NewServlet extends HttpServlet {
        private Message message;

        @Override
        public void init() {
            message = new MessageB();
        }

        @Override
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                      throws IOException {
            response.getWriter().write(message.get());
        }
    }

This servlet needs an instance of an object that implements the `Message` interface:

    public interface Message {
        public String get();
    }

The servlet creates itself an instance of the following object:

    public class MessageB implements Message {
        public MessageB() { }

        @Override
        public String get() {
            return "message B";
        }
    }

Using CDI, this servlet can declare its dependency on a `Message` instance and have it injected automatically by the CDI runtime. The new servlet code is the following:

    @WebServlet("/cdiservlet")
    public class NewServlet extends HttpServlet {
        @Inject private Message message;

        @Override
        public void doGet(HttpServletRequest request, HttpServletResponse response)
                      throws IOException {
            response.getWriter().write(message.get());
        }
    }

The CDI runtime looks for classes that implement the `Message` interface, finds the `MessageB` class, creates a new instance of it, and injects it into the servlet at runtime. To manage the lifecycle of the new instance, the CDI runtime needs to know what the scope of the instance should be. In this example, the servlet only needs the instance to process an HTTP request; the instance can then be garbage collected. This is specified using the `javax.enterprise.context.RequestScoped` annotation:

    @RequestScoped
    public class MessageB implements Message { ... }

For more information on scopes, see Using Scopes.

The `MessageB` class is a CDI bean. CDI beans are classes that CDI can instantiate, manage, and inject automatically to satisfy the dependencies of other objects. Almost any Java class can be managed and injected by CDI. For more information on beans, see About Beans. A JAR or WAR file that contains a CDI bean is a bean archive. For more information on packaging bean archives, see Configuring a CDI Application in this chapter and Packaging CDI Applications in Chapter 25, "Contexts and Dependency Injection for Java EE: Advanced Topics".

In this example, `MessageB` is the only class that implements the `Message` interface. If an application has more than one implementation of an interface, CDI provides mechanisms that you can use to select which implementation to inject. For more information, see Using Qualifiers in this chapter and Using Alternatives in CDI Applications in Chapter 25, "Contexts and Dependency Injection for Java EE: Advanced Topics".