Which JavaEE container contains which elements?

Question

I'm trying to get a deeper understanding about JavaEE containers. I need to understands the architecture (that's ok) of a project and especially the repercussion on the Java EE containers. To make it simple, everything is running on the same full Java EE GlassFish server.

Some class definition I have : (sorry I can't post an UML diagram due to reputation)

@Entity public class MyEntity{...}
@Stateless public class MyEntityDAO{...}
@Stateless public class MyEntityFacade{...}
public class MyEntityTO{...} //Data Transfer Object, it's a POJO
@Named @ViewScoped public class MyEntityPageController{...}

And JSF page : myEntityPageJSF.xhtml

Now I want to categorize the different elements in the following containers like so :

EJB container :

MyEntity because it's a Entity Bean
MyEntityDAO because it's a Session Bean
MyEntityFacade because it's a Session Bean

Web container :

MyEntityPageController because it's a CDI Bean
JSF pages
Servlets

The only official answer I found is [1]:

Enterprise JavaBeans (EJB) container: Manages the execution of enterprise beans for Java EE applications. Enterprise beans and their container run on the Java EE server.

Web container: Manages the execution of web pages, servlets, and some EJB components for Java EE applications. Web components and their container run on the Java EE server.

The problem is the "and some EJB components" part... no idea what they're exactly talking about. So, can anyone categorize the following elements [2] in the correct container ?

Session Bean
Entity Bean
Message Bean
JSF
sevelet
so fare it's not so difficult but now :
Managed Bean
CDI Bean
WebService (maybe it's a Session Bean too, I don't know)

Thanks in advance.

References :

KeyMaker00 · Accepted Answer

It's all about containers, components and services.

Java EE Application containers

The Java EE application server contains only two container types (web and EJB container). Those containers have some components that uses some APIs, provided by the container itself.

Your application server can be interpreted as the application container. Just to cite a few: Tomcat, JBoss/Wildfly, Oracle Weblogic, Jetty or GlassFish are Java EE Application Container.

At this point, you can already notice that server is often a synonym of container. It resides in the fact that one has usually, for small application, one container per server. However, a server can consist of more that one container.

Strictly speaking, Java application servers are based on the Java Platform Enterprise Edition, which is a multi-tier distributed model. This model is composed by:

Client Tier (can be one or more applications or browsers),
Middle Tier (Web container and EJB container),
EIS Tier (Database, integration services, resources, ...)

Multi-tier architecture means, in Java EE world, that some containers are on the client side, and some on the server side.

Java EE container types

From the point of view of your server, the JCP (Java Community Process) defines in the JSR 342 only four types of Java EE containers:

Applet Container (runs in the client's browser)
Application Client Container (runs on a client machine)
Web Container (sometimes called Web Server and runs on a JEE application server)
EJB Container (sometimes called EJB server, runs on a JEE application server)

Java EE containers are the interface between the component and the lower-level functionality provided by the Java EE platform to support that component.

Containers provide the runtime support for Java EE application components. Containers provide a federated view of the underlying Java EE APIs to the application components. Java EE application components never interact directly with other Java EE application components. [...] A typical Java EE product will provide a container for each application component type: application client container, applet container, web component container, and enterprise bean container.

The Web container as the EJB container(s), provide naming context and life management to their component(s). Note that, even if a Web container may work with an EJB container, they do not need to be deployed on the same machine.

A fully conformant JEE application server, such as Websphere, Glassfish or JBoss, has both containers.

Java EE core components

JEE applications are made up of components. A component is a self-contained functional software unit that is assembled into a JEE application with its related classes and files and that communicates with other components.

Technically speaking, the containers provides the host execution environments for the components.

The specifications say that:

Application client container has a component called Application client (Standalone or applet).
Web container has a Servlet component, or JavaServer Pages (JSP) component.
EJB container has EJB component(s). The EJB containers are provided by the platform vendors.

Example of communication between components from different containers: The Web container includes JavaBeans components to manage the user input and send that input to enterprise beans running in the EJB container for processing.

Java EE Container Services

Sun has defined a container as follow:

A container is a runtime environment that provides services such as security and transaction management to Java EE components.

I.e the containers are also responsible for providing the APIs, and the distributed communication protocols.

Container services:

Naming: allows components to locate other components and resources.
Transactions: consequence of reading and/or amendment operations in the database or another system with a defined beginning and a defined end.
Security: used to support authentication and authorisation.
Remoting: EJB remoting or Web Services.
Pooling
Persistence
Asynchronicity
Messaging: communication model for asynchronous transfer of data between processes.
Concurrency: parallelism in Java EE applications.
Validation
...

Those container services or APIs can be logically divied into tiers: backend tier, middle tier and web tier: