The Manager interface lets us register and obtain Web Beans, interceptors, decorators, observers and contexts programatically.

public interface Manager
{

   public <T> Set<Bean<T>> resolveByType(Class<T> type, Annotation... bindings);

   public <T> Set<Bean<T>> resolveByType(TypeLiteral<T> apiType,
         Annotation... bindingTypes);

   public <T> T getInstanceByType(Class<T> type, Annotation... bindingTypes);

   public <T> T getInstanceByType(TypeLiteral<T> type,
         Annotation... bindingTypes);

   public Set<Bean<?>> resolveByName(String name);

   public Object getInstanceByName(String name);

   public <T> T getInstance(Bean<T> bean);

   public void fireEvent(Object event, Annotation... bindings);

   public Context getContext(Class<? extends Annotation> scopeType);

   public Manager addContext(Context context);

   public Manager addBean(Bean<?> bean);

   public Manager addInterceptor(Interceptor interceptor);

   public Manager addDecorator(Decorator decorator);

   public <T> Manager addObserver(Observer<T> observer, Class<T> eventType,
         Annotation... bindings);

   public <T> Manager addObserver(Observer<T> observer, TypeLiteral<T> eventType,
         Annotation... bindings);

   public <T> Manager removeObserver(Observer<T> observer, Class<T> eventType,
         Annotation... bindings);

   public <T> Manager removeObserver(Observer<T> observer,
         TypeLiteral<T> eventType, Annotation... bindings);

   public <T> Set<Observer<T>> resolveObservers(T event, Annotation... bindings);

   public List<Interceptor> resolveInterceptors(InterceptionType type,
         Annotation... interceptorBindings);

   public List<Decorator> resolveDecorators(Set<Class<?>> types,
         Annotation... bindingTypes);

}

We can obtain an instance of Manager via injection:

@Current Manager manager

Instances of the abstract class Bean represent Web Beans. There is an instance of Bean registered with the Manager object for every Web Bean in the application.

public abstract class Bean<T> {
    
    private final Manager manager;
    
    protected Bean(Manager manager) {
        this.manager=manager;
    }
    
    protected Manager getManager() {
        return manager;
    }
    
    public abstract Set<Class> getTypes();
    public abstract Set<Annotation> getBindingTypes();
    public abstract Class<? extends Annotation> getScopeType();
    public abstract Class<? extends Annotation> getDeploymentType(); 
    public abstract String getName();
    
    public abstract boolean isSerializable();
    public abstract boolean isNullable();

    public abstract T create();
    public abstract void destroy(T instance);
    
}

It's possible to extend the Bean class and register instances by calling Manager.addBean() to provide support for new kinds of Web Beans, beyond those defined by the Web Beans specification (simple and enterprise Web Beans, producer methods and JMS endpoints). For example, we could use the Bean class to allow objects managed by another framework to be injected into Web Beans.

There are two subclasses of Bean defined by the Web Beans specification: Interceptor and Decorator.

The Context interface supports addition of new scopes to Web Beans, or extension of the built-in scopes to new environments.

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

For example, we might implement Context to add a business process scope to Web Beans, or to add support for the conversation scope to an application that uses Wicket.