eclipse web tools
platform project

The J2EE Standard Tools Subproject

This project proposal is in the Proposal Phase and is posted here to solicit additional project participation and ways the project can be leveraged from the Eclipse membership-at-large. You are invited to comment on and/or join the project. Please send all feedback to the eclipse.webtools newsgroup or the wtp-proposal mailing list.

Project Vision

Project vision is to extend eclipse platform with support for building multi-tier J2EE applications. The project will grow the community of eclipse users, and grow the community of developers that create Web applications based on the J2EE platform. In this way, we will help make eclipse the industry standard tool integration platform for development based on Open Standards and Technologies. The project must preserve the eclipse value proposition by providing integration, ease-of-use, function, and "coolness". Web artifacts must be first class citizens with respect to the capabilities that eclipse users expect. Servers must be first class execution environments, including both Open and Commercial implementations, therefore encourage support of eclipse by server vendors.

Project Context

The scope of the J2EE Standard Tools subproject is the support of J2EE programming. This includes the support of APIs covered by the J2EE1.4 specifications (e.g. JSP, Servlets, EJBs, JCA, JMS, JNDI, JDBC, Java Web Services, JAX* and related JSRs). Support for JCP specifications commonly used in Web Applications, but not included in J2EE1.4 is to be studied on a case by case basis (ex: JSF,JDO).

Support of frameworks not covered by the JCP (ex: Struts, Hibernate, XMLC) is outside the scope of this project, such projects could find a home in the Eclipse Technology project.

JST will have annotation support (JSR 175-Metadata), on top of those provided in the JDT, e.g. for code assist, where applicable. Annotation support will include JSR 181-Metadata for Web Services, and in the future will include support for other standardized metadata such as EJBs. In the transitional period until there are JSRs for J2EE annotations, JST will have some support for widely accepted open technologies such as XDoclet.

Some Architectural Principles*

  • Seamlessly extend the Eclipse user experience
  • Accommodate common J2EE application project directory layouts
    • Avoid need for migration
  • Apply capabilities orthogonally to source artifacts:
    • Syntax Coloring
    • Code Assist
    • Quick Fixes
    • Refactoring
    • Etc.
  • Extend the Run command to J2EE artifacts, e.g. JSP
  • Enable hybrid source editing:
    • Java in JSP
    • JavaScript in JSP
    • EJB-QL in Java
    • Etc.
  • Enable extension of editors with value-add
    • Graphical views
    • Form based views
  • Provide modular design of tools for enabling separate tool deliveries for differents classes of developers
    • Enable separate deliveries of servlet/JSP and EJB tools
    • Etc
*We invite the Eclipse membership-at-large to apply their collective wisdom and experience here by proposing additional principles. Suggestions should be made on the WTP forum

Some use cases*

  • Develop a J2EE Web Application
    • Develop JSP pages
    • Develop tag libraries
    • Develop Servlets and Servlet Filters
    • Package the contents of war files
    • Edit deployment descriptors
    • Run, Test, Debug Web Applications
  • Develop an EJB Application
    • Add an EJB
    • Add methods/fields/relationships/mappings to an EJB
    • Edit the deployment descriptors
    • Package the contents of an EJB-JAR
      • Generate necessary classes
      • Run, Test, Debug EJBs
  • Develop an Enterprise Application
    • Assemble an enterprise application
      • Add, remove Web Applications, EJBs
      • Add, remove client applications
    • Package the contents of an ear
    • Edit the deployment descriptors
    • Run, Test, Debug an Enterprise Application
  • Import existing Web applications, EJBs, and ears into a project
    • Enhance the "PetStore" blue-print application
  • Develop Java Web Services
    • Develop a Web Service based on Session Beans
    • Develop a Web Service based on JavaBeans
    • Create Web Service Clients
  • Provide Exemplar Server Tools for open-technology server runtimes such as Apache Tomcat, JOnAS, JBoss, J2EE 1.4 SDK and others.

*we invite the membership-at-large to propose additional use-cases to focus this project on the most important frameworks and tools. Suggestions should be made on the WTP forum

Goals for J2EE Core Model and Tools

These structures will provide common facilities required by most J2EE tool builders, as well as exemplary tools for J2EE developers. The project will leverage the Web Core Model of the WST, to build J2EE specific models (for project, editors, artifacts, components, servers) providing extensible framework and APIs. Our goals are:
  • Divide and Conquer: Lots of components, so divide the work using the classical principle of hierarchy
  • Layer Build Dependencies: J2EE Standards builds on the Web Standards, the J2EE Extensions build on the J2EE
  • The structure of software reflects the structure of the organization that built it: We are building a platform and need to validate our API.

J2EE Core Model

This is a set of frameworks, and models, which provide the necessary abstractions and APIs to work and develop with J2EE Tools, and to build IDEs and tools to support these activities. JCM is not just an adaptation of the J2EE specifications, but it will focus on the additional requirements of developers and tool builders. JCM is naturally related to the models and tools defined in the Web Standard Tools subproject, and will address at a minimum the following areas:

J2EE Project Model

The J2EE Project model extends Web Project Model to support the development of J2EE applications in a variety of ways; projects divided across multiple related projects, or modules factored into one project that can host multiple artifacts. This includes support for:

  • A wide variety of project layouts
    • J2EE Development divided across multiple related projects
      • Structural - EAR, EJBs, WARs
      • Functional (e.g. CRM, ERP...)
    • J2EE Development factored into one project with multiple J2EE artifacts.
      • Integrated views
      • Sophisticated module management
      • Project management tools
  • Management of build dependencies and activities
  • Server class-loader models
    • Resolution of names and types across multiple projects

J2EE Editor Model

The Editor Model will offer developers a set of APIs to access J2EE models, participate in build and refactoring activities, and allow them to easily create various text, and graphical editors for J2EE.

These editors will:

  • Extend the eclipse user experience
  • Accommodate existing common project directory layouts
  • Be modular and extensible
    • Graphical views
  • Allows hybrid source editing
    • Java, HTML, XML in JSP, SQL in Java or JSP, etc.
  • Will provide access to JCM models
  • Will be participate in refactoring and builds
  • Provide content based selection
  • Apply editors capabilities orthogonally to source artifacts such as JSPs
    • Syntax Coloring
    • Code Assist
    • Quick Fixes
    • Refactoring
    • Etc.

J2EE Artifacts and Components

These models will represent J2EE standard modules, files, deployment descriptors and various other artifacts, associated natures, builders, validators and EMF models. They will at minimum include models for:
  • JSP
  • Servlet
  • ServletFilter
  • EJBs
  • JCAs
  • Java Web Services
  • Modules,
    • Deployment descriptors, web.xml, ejb-jar.xml, application.xml, etc.
    • Web Modules(war),
    • EJB Modules (ejb jars),
    • Applications (ear) ,
    • Resource Archives (rar).

J2EE Server Models

J2EE Application Servers are multi-tier distributed component-based products, typically implemented in Java, that reside in the middle-tier of a server centric architecture. They provide middleware services for security and state maintenance, along with data access and persistence. This model generally includes a Client Tier, a Middle Tier, and an EIS Tier. The Client Tier can be one or more applications or browsers. The J2EE Platform is in the Middle Tier and consists of a Web Server and an EJB Server (These servers are also called "containers"). There can be additional sub-tiers in the Middle Tier. The Enterprise Information System (EIS) tier includes the existing applications, files, and databases.

Although based on the same standard, there are significant variations on how available servers support J2EE components, the way they are administered, started, stopped and how J2EE modules are managed, and how they support development time activities such as debugging and hot deployment and automatic refreshes.

The server model must at a minimum define abstract facilities and configurations to:
  • Support any J2EE Compliant Servers
    • LCD is J2EE, Versions, Avoid Vendor Locking
  • Implement eclipse launching APIs
    • In process/project, local, remote runtimes
  • Manage environmental and JVM parameters, classpath configurations
  • Package, deploy, remove, import, export J2EE modules
  • Provide an extensible framework for server administration
  • Provide a meta-model for easy adaptation of new server types
    • extensions for exceptions (Tomcat)
  • Support for related JSRs
    • JSR 45: Debugging Support
    • JSR 77: J2EE Management
    • JSR 88: J2EE Application Deployment

J2EE Standard Tools

J2EE Standard Tools will provide extensible plug-ins for the development of J2EE Applications and support development, testing and debugging with a wide range of J2EE servers. Exemplar tools will support the development of Web Applications (.war), Enterprise JavaBeans, Java Web Services, and support development, testing and debugging with standard compliant J2EE application servers ('specific additional extensions may be required').

The interaction of JCM and the exemplar tools based on JCM will provide a healthy environment where requirements and APIs are based on actual needs. Tools will verify the APIs. This is a critical feature of the project in that JCM without tools, or tools without JCM, will not achieve our goal to provide a platform for high quality web development based on J2EE.

All JST tools will be based on JCM.

The exemplar tools for J2EE will include:

  • Server Tooling
    • More than starting a VM
    • Complex environmental setup and classloader models
    • In process, local and remote development scenarios
    • Must support all J2EE compliant servers
      • Exceptions managed with extensions
    • Launchers - Run, Debug, Profile, Stop and Restart...
    • Configuration wizards and editors, starting, debugging, profiling, stopping and restarting applications servers
  • Tools for J2EE Modules
      • Web Apps, EJB, Resource Archives, Enterprise applications
    • Create modules
      • Wizards - Imports
    • Build modules
    • Validate modules
    • Edit modules
      • Deployment descriptors
      • Package contents
    • Aggregate modules (ears)
    • Server deployment support
  • Editors for J2EE Components
    • JSP
      • Standard editor capabilities (coloring, code assist, refactoring, formatting)
      • JSR-45 Debugging
      • Content based selection
      • Hybrid editing
      • Build Participation
    • EJB Tools
      • Annotation based editing and code generation
      • Wizards
      • Validation
    • Java Web Services and support for JSR-109 Implementing Enterprise Web Services
      • Axis Adapter
  • Tools for Navigation
    • J2EE Perspective(s)
    • Module Views
    • J2EE Structures
    • Servers
  • Tools to Improve the J2EE Development Process
    • Testing Tools
      • Unit and Integration Testing
    • Performance Tools
      • Profiling
      • Load & Stress Testing