The Context interface provides an operation for obtaining contextual instances of any Web Bean with a particular scope.

public interface Context {
    
    public Class<? extends Annotation> getScopeType();
    
    public <T> T get(Bean<T> bean, boolean create);
    
    boolean isActive();
    
}

The Context SPI is called by the Web Bean manager. It should not be called directly by the application.

User instance = context.get(userBean, true);

The get() method may either:

The get() method may not return a null value unless the create parameter is false or Bean.create() returns a null value.

The get() method may not create a new instance of the given Web Bean unless the create parameter is true.

The Context implementation is responsible for destroying any Web Bean instance it creates by passing the instance to the destroy() method of the Bean object representing the Web Bean. A destroyed instance must not subsequently be returned by the get() method.

At a particular point in the execution of the program a scope may be inactive with respect to the current thread. When a scope is inactive, any invocation of the get() from the current thread upon the Context object for that scope results in a ContextNotActiveException.

Otherwise, we say that the scope is active.

The isActive() method returns false when the scope of the context object is inactive, and true when it is active.

Most scopes are normal scopes. The context object for a normal scope type is a mapping from each enabled Web Bean with that scope type to an instance of that Web Bean. This mapping may be associated with a single thread or with a set of threads. There may be no more than one mapped instance per Web Bean per thread. The mapped instance of a Web Bean associated with the current thread is called the current instance of the Web Bean. The set of all current instances for a certain thread is called the context associated with that thread. A context is said to propagate when the set of current instances is preserved.

The get() operation of the Context object for an active normal scope returns the current instance of the given Web Bean.

At certain points in the execution of the program a context associated with the current thread may be destroyed. When a context is destroyed, all current instances of Web Beans with that scope type are destroyed by passing them to the Bean.destroy() method.

Contexts with normal scopes must obey the following rule:

Suppose Web Beans A, B and Z all have normal scopes. Suppose A has an injection point x, and B has an injection point y. Suppose further that both x and y resolve to Web Bean Z according to the typesafe resolution algorithm. If a is the current instance of A, and b is the current instance of B, then both a.x and b.y refer to the same instance of Z. This instance is the current instance of Z.

Any scope that is not a normal scope is called a pseudo-scope. The concept of a current instance is not well-defined in the case of a pseudo-scope.

All pseudo-scopes must be explicitly declared @ScopeType(normal=false), to indicate to the Web Bean manager that no client proxy is required.

All scopes defined by the Web Beans specification, except for the @Dependent pseudo-scope, are normal scopes.

The @Dependent scope type is a pseudo-scope. Components declared with scope type @Dependent behave differently to Web Beans with other built-in scope types.

When a Web Bean is declared to have @Dependent scope:

Every invocation of the get() operation of the Context object for the @Dependent scope with the value true for the create parameter returns a new instance of the given Web Bean.

Every invocation of the get() operation of the Context object for the @Dependent scope with the value false for the create parameter returns a null value.

The @Dependent scope is inactive except:

A passivating scope requires that instances of Web Beans with that scope be serializable, so that their state may be stored to disk when the scope becomes inactive. The process of storing the state of Web Bean instances belonging to a scope that is about to become inactive to disk is called context passivation. Passivating scopes must be explicitly declared @ScopeType(passivating=true).

For example, the built-in session and conversation scopes defined in Section 8.5, “Context management for built-in scopes” are passivating scopes.

The Web Bean manager must validate that every Web Bean declared with a passivating scope truly is serializable:

The built-in session and conversation scopes are passivating. No other built-in scope is passivating.

A Web Bean instance may be serialized under one of two circumstances:

In either case, any non-transient field that holds a reference to another Web Bean must be serialized along with the Web Bean that is being serialized. Therefore, the reference must be to a serializable type.

Web Beans client proxies are serializable. Therefore, any reference to a Web Bean which declares a normal scope type is serializable. On the other hand, dependent objects (including interceptors and decorators with scope @Dependent) of a stateful session bean or of a Web Bean with a passivating scope must be serialized and deserialized along with their owner:

The method Bean.isSerializable() may be used to detect if a Web Bean is serializable.

The Web Bean manager provides an implementation of the Context interface for each of the built-in scopes.

For each of the built-in normal scopes, contexts propagate across any Java method call, including invocation of EJB local business methods. The built-in contexts do not propagate across remote method invocations or to asynchronous processes such as JMS message listeners or EJB timer service timeouts.

An integrated Web Bean manager may, but is not required to, utilize standard Java EE APIs such as servlet filters and listeners, JSF phase listeners and EJB interceptors to perform context management. A plugin Web Bean manager must use only standard Java EE APIs.

public interface Conversation {
   public void begin();
   public void begin(String id);
   public void end();
   public boolean isLongRunning();
   public String getId();
   public long getTimeout();
   public void setTimeout(long milliseconds);
}

A custom implementation of Context may be associated with any scope type at any point in the execution of a Web Beans application, by calling Manager.addContext().

public interface Manager {
    
    public Manager addContext(Context context);
    
    ...
    
}

For example:

manager.addContext(new MethodContext());

Every time Manager.getInstance() is called, for example, during instance or EL name resolution, the Web Bean manager must call Manager.getContext() to retrieve an active context object associated with the Web Bean scope. The getContext() method searches for an active context object for the given scope type. If no active context object exists for the given scope type, getContext() must throw a ContextNotActiveException. If more than one active context object exists for the given scope type, getContext() must throw an IllegalStateException.

public interface Manager {
    
    public Context getContext(Class<? extends Annotation> scopeType);
    
    ...
    
}