I hope you guys prove that things do not have to take as long as they did with jsf.
I wonder where BEA has gone today?
Best of luck,
I blogged this:
If you're interested, the actual proposal reads like so:
The EJB architecture is a component architecture for the development
and deployment of component-based business applications. In particular,
EJB provides a programming model for components that access transactional
resources. Applications written using the Enterprise JavaBeans architecture
are scalable, transactional, and multi-user secure. The EJB 3.0 release
significantly enhanced and simplified the EJB programming model, making
heavy use of Java annotations.
Even so, the EJB component model still has some limitations:
* EJB components are not aware of the web-tier request, session and
application contexts and do not have access to state associated with
those contexts. Nor may the lifecycle of a stateful EJB component
be scoped to a web-tier context.
* EJB components are not in general suitable for use in the presentation
JavaServer Faces is a web-tier presentation framework that provides,
among other facilities, a component model for graphical user interface
components, a "managed bean" component model for application logic, and
an event-driven interaction model that binds the two component models.
The managed bean component model is a contextual model where components
are bound to one of the three web tier contexts and may hold contextual
* JSF provides no integrated facilities for accessing transactional
resources from managed bean components.
* The managed bean component model provides no component-level or
* The context model provided by the servlet specification - and
leveraged by JSF - is insufficiently rich for use in complex
applications in an enterprise environment.
* The JSF component model is not consistent with Java EE component
registry (JNDI), dependency injection, packaging and deployment
* The current release of JSF has not yet embraced Java annotations.
The goal of this work is to enable EJB 3.0 components to be used as
JSF managed beans, unifying the two component models and enabling
a considerable simplification to the programming model for web-based
applications in Java.
In particular, this work will provide a programming model suitable
for rapid development of simple data-driven applications without
sacrificing the full power of the Java EE 5 platform. This is a
domain where Java EE has been perceived as overly complex.
To enable use of this simplified programming model beyond the realm
of simple internet-facing web applications, this work will define
an enhanced context model that provides first-class constructs for
modelling user interactions. The enhanced context model will
dramatically simplify the creation of complex stateful applications
with sophisticated user interactions.
Aspects that should be considered in this work include, but are not
limited to, the following:
* Definition of additional capabilities to be used with the EJB
component model, allowing EJB beans to act as JSF managed beans in
a JavaServer Faces application. This is in principle possible without
requiring any changes to the EJB or JSF specifications. However,
where appropriate, new features could be incorporated into the EJB
specification or JSF specification at the discretion of the respective
* Definition of a unified annotation-based facility for manipulating
contextual variables in a stateful, contextual, component-based
* Definition of an enhanced context model including conversational
and business process contexts.
* Definition of an extension point allowing integration of business
process management engines with the contextual component model.
* Integration of Java Persistence API extended persistence contexts
with the enhanced context model.
* Collaboration with the JSF and Common Annotations for the Java
Platform expert groups on the definition of Java annotation based
metadata for JSF.
* Ensure that components written to conform to this specification
may be executed in the context of a Web Services invocation.
* Ensure that the component model can be used with JSR-227
The goal of the Expert Group will be to investigate these issues and
identify and pursue other directions that allow a simplification of
the overall programming model, while leaving issues relevant only
to the EJB specification or only to the JSF specification to the
respective Expert Groups.