2 Replies Latest reply on May 16, 2006 10:30 PM by Gavin King

    Web Beans JSR

    Gavin King Master

      JBoss announced today that we are submitting a JSR proposal for "Web Beans", a unified contextual component model for EJB3 and JSF. This proposal is supported by Sun, Oracle, JBoss, Sybase, Google and Borland, and will draw on the experience of frameworks like Seam, Shale and and ADF Faces. The goal is to bring ideas from these frameworks into the standard Java platform.

      You can read more here:

      http://jboss.com/elqNow/elqRedir.htm?ref=/pdf/press/webbeans.pdf

        • 1. Re: Web Beans JSR
          Ronald van Kuijk Master

          Great, Congratulations.

          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,

          Ronald

          • 2. Re: Web Beans JSR
            Gavin King Master

            I blogged this:

            http://blog.hibernate.org/cgi-bin/blosxom.cgi/2006/05/16#web-beans

            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
            tier.

            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
            state.

            * JSF provides no integrated facilities for accessing transactional
            resources from managed bean components.

            * The managed bean component model provides no component-level or
            method-level security.

            * 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
            standards.

            * 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
            expert groups.

            * Definition of a unified annotation-based facility for manipulating
            contextual variables in a stateful, contextual, component-based
            architecture.

            * 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
            databinding.


            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.