INTRODUCTION TO THE

JAVA EE 6 PLATFORM
Java Platform, Enterprise Edition 6 White Paper December 2009

Abstract
The Java Platform, Enterprise Edition 6 provides new capabilities that make it easier to develop and deploy enterprise and Web applications. Java EE 6 provides a simplified developer experience, embraces innovative open-source frameworks, offers a comprehensive Web Profile for lightweight, standards-based Web applications, and has started the formal process to prune outdated and unused technology from the stack. Also, there are many new and updated APIs and capabilities that significantly improve how enterprise and Web applications are created, deployed, and maintained.

Sun Microsystems, Inc

Table of Contents

Executive Summary..............................................................................................1 Introduction to the Java EE 6 Platform....................................................................2 Flexibility............................................................................................................3 Profiles................................................................................................................3 Pruning...............................................................................................................5 Development Productivity and Extensibility ...........................................................6 Servlet 3.0...........................................................................................................6 Web Fragments................................................................................................6 Asynchronous Processing..................................................................................7 JAX-RS 1.1 (JSR 311)...............................................................................................7 Enterprise JavaBeans 3.1 (EJB 3.1, JSR 318).............................................................7 EJB Lite............................................................................................................8 Java Persistence API 2.0 (JPA, JSR 317)....................................................................9 Contexts and Dependency Injection for Java EE (CDI, JSR 299)...................................9 JavaServer Faces 2.0 (JSF, JSR 314).......................................................................10 Bean Validation 1.0 (JSR 303)...............................................................................10 Connector Architecture 1.6 (JSR 322)....................................................................10 Packaging..........................................................................................................11 Sun GlassFish Enterprise Server v3......................................................................12 Integrated Development Environments (IDEs).......................................................13 Summary..........................................................................................................15 More Information...............................................................................................15 References.........................................................................................................15

1 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

Chapter 1

Executive Summary
The Java Platform, Enterprise Edition (Java EE) has gracefully evolved as an enterprise application deployment platform from several themes, including robustness, Web services, and ease of deployment. Continually shaped by users through the Java Community ProcessSM (JCPSM), Java EE is a universal standard in enterprise ITfacilitating the development, deployment, and management of multitier, server-centric applications. More recently, Java EE 5 focused on increasing developer efficiency with the introduction of annotations, the Enterprise JavaBeans (EJB) 3.0 business component development model, new and updated Web services, and improvements to the persistence model. Java EE 6 is the next phase in enterprise application development, further streamlining the development process and making the platform more flexible to better address lightweight Web applications. The Java EE 6 platform highlights new technologies, embraces open-source frameworks, and begins the process for pruning away old technologies.
Over the years, Java 2 Platform Enterprise Edition technology has grown to address

new technologies and methodologies. By increasing flexibility, the full platform continues to address enterprise applications, yet simplifies the development and deployment of lighter weight, more focused applications. Right sizing recognizes that the platform can be too big for specific tasksit is an effort to create a development and deployment environment that is lighter in weight and more focused for target applications and environments.
Profiles contribute to the flexibility of Java EE 6. The idea is to decouple specifications

to enable combinations suited for different use cases. For example, the Web Profile brings together just the technology needed for Web applications. Additional profiles are being considered, and would be created using the Java Community Process (JCP).
Pruning, similar to deprecation, removes outdated or unused technologies, such as

EJB Entity Beans, JAXR, and others. Pruning provides an orderly way to alert organizations that a technology will be removed from the specification in future releases.
Extending into open-source libraries and frameworks, Java EE 6 embraces open-

source innovation by enabling zero-configuration, drag and drop of frameworks into the container or application.
To make it easier for developers to create and deploy applications, Java EE 6 extends

the use of annotationsintroduced in Java EE 5throughout various specifications in the platform. In addition, applications developed and deployed in Java EE 6 typically requires less effort to configure than earlier versions. There are several other ease-of-development capabilities in Java EE 6. Java EE 6 continues to deliver the benefits of standards, transparency, and community participation, providing flexibility, implementation choice, and investment protection. This paper provides a technical overview of Java EE 6, and its focus on improving developer productivity, simplifying the platform, and increasing modularity and extensibility.

2 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

Chapter 2

Introduction to the Java EE 6 Platform

Developers today recognize the need for distributed, transactional, and portable applications that leverage the speed, security, and reliability of server-side technology. Enterprise applications must be designed, built, and produced for less money, with greater speed, and with fewer resources. With the Java Platform, Enterprise Edition (Java EE), development of Java enterprise applications has never been easier or faster. The Java EE Platform is a set of well-integrated technologies that significantly reduce the cost and complexity of developing, deploying, and managing multitier, server-centric applications. Building on the Java Platform, Standard Edition (Java SE), Java EE adds the capabilities to create complete, stable, secure, and high performance Java applications for the enterprise. Figure 1 shows the themes for the major Java EE Platform releases. This includes the theme for Java EE 6simpler and more flexible development and deploymentand the introduction of profiles.

Figure 1: The main theme for the Java EE 6 Platform is a more flexible environment. The Java EE platform provides developers with a powerful set of APIs that can reduce development time and application complexity, while improving application performance. This paper discusses the key capabilities that make Java EE 6 a more flexible development and deployment platform, and how it can apply a focused set of technologies to an application scenario. This includes profiles, pruning, new ease of development capabilities, and other new functionality.

3 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

Chapter 3

Flexibility
As a robust and mature platform for deploying enterprise applications, Java EE 6 delivers new capabilities that enable it to be a better fit in more situations. There are several aspects to Java EE 6 platform flexibility, including profiles and pruning. Profiles enable standards-compliant and more focused solutions to be created using the JCP process. Pruning is an orderly mechanism for reducing outdated and less-relevant technologies, simplifying the platform.

Profiles
For many applications, the full set of Java EE APIs may not be appropriate. Profiles enable the deployment of a standardized set of Java EE platform technologies, targeting particular classes of applications, which could be aligned with an industry vertical, a frequently occurring use case, and so on. The concept of profiles is not newJava EE is leveraging experience gained from various sources such as Java ME, where profiles are applied to specific device runtime environments, and Web service standards like WS-I Basic Profile. Java EE 6 introduces the Web Profile, which is designed for modern Web application development. The Web Profile provides transaction processing, security, and persistence management for creating small- to medium-sized Web applications. As illustrated on the left side of Figure 2, developers often create Web applications starting with a Web container, then add technology such as data persistence. As technology is added or updated, it is configured and debugged. This is repeated until the required functionality is attained. The result is multiple, non-standard solution stacks that are difficult to create, integrate and maintain.

Figure 2: The Web Profile provides everything needed for developing database-driven Web applications.

4 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

The Web Profile is designed to be a reasonably complete, out-of-the-box platform composed of standard APIs that meets the needs of most Web applications. The Web Profile provides a stable, standard foundation that can be enhanced by applying innovative open source frameworks and additional technology. As needs change, it is easy to move from the Web Profile to the full platform. Other profiles are expected to be developed and approved, and they can be subsets or supersets of the full Java EE 6 Platform. Table 1 identifies those features comprising the Web Profile. Table 1: Java EE 6 Web Profile and Java EE 6 Full Platform
(source: http://jcp.org/aboutJava/communityprocess/pfd/jsr316/index.html) Java EE 6 Web Profile Servlet 3.0 JavaServer Pages (JSP) 2.2 Expression Language (EL) 2.2 Debugging Support for Other Languages (JSR 045) Java EE 6 Full Platform Servlet 3.0 JavaServer Pages (JSP) 2.2 Expression Language (EL) 2.2 JSR 045, Debugging Support for Other Languages

Standard Tag Library for JavaServer Pages (JSTL) Standard Tag Library for JavaServer Pages (JSTL) 1.2 1.2 JavaServer Faces (JSF) 2.0 Common Annotations for Java Platform (JSR 250) 1.1 Enterprise JavaBeans (EJB) Lite Java Transaction API (JTA) 1.1 Java Persistence API (JPA) 2.0 Bean Validation 1.0 Managed Beans 1.0 Interceptors 1.1 Contexts and Dependency Injection for the Java EE Platform 1.0 (JSR 299) Dependency Injection for Java 1.0 (JSR 330) JavaServer Faces (JSF) 2.0 Common Annotations for Java Platform (JSR 250) 1.1 Enterprise JavaBeans (EJB) 3.1 and EJB 3.1 Lite Java Transaction API (JTA) 1.1 Java Persistence API (JPA) 2.0 Bean Validation 1.0 Managed Beans 1.0 Interceptors 1.1 Contexts and Dependency Injection for the Java EE Platform 1.0 (JSR 299) Dependency Injection for Java 1.0 (JSR 330) JMS 1.1 JavaMail 1.4 Connector 1.6 JAX-WS 2.2, JAX-RS 1.1, JAX-RPC 1.1, JAXB 2.2, JAXR 1.0 Java EE Management 1.1 Java EE Deployment 1.2 JACC 1.3

5 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

Java EE 6 Web Profile

Java EE 6 Full Platform JASPIC 1.0 JSP Debugging 1.0 Web Services Metadata 2.0 SAAJ 1.3 Web Services 1.3

Pruning
Pruning a specification means that it can become an optional component in the next release of the platform, rather than a required component. Carefully pruning APIs that are outdated, not well supported, or not widely deployed will result in a more lightweight platform that is easier to use, and also provides room for new enhancements and refinements. Pruning is marked in the JavaDoc, and means it is a candidate to become optional. More specifically, this means identified technologies may be optional in the next release, and may be deleted in the following release, although vendors may continue to offer and support pruned specifications. Candidates for pruning are recommended by the Java EE Expert Group. Current specifications that are in the process of being pruned are:
Java APIs for XML-Based RPC (JAX-RPC, JSR 101): This API was effectively superseded by

JAX-WS with the release of Java EE 5.

EJB Entity Beans (defined as part of JSR 153: Enterprise JavaBeans 2.0, and earlier):

Replaced by Java Persistence API (JPA).

Java API for XML Registries (JAXR, JSR 93): JAXR has not been superseded but has seen

very limited adoption.

Java EE Application Deployment (JSR 88): This has not been widely adopted by

vendors.

6 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

Chapter 4

Development Productivity and Extensibility

The Java EE 6 Platform advances the ease of development features introduced by the Java EE 5 Platformimproving developer productivity by simplifying application development. The heavy use of annotations in Java EE 6 results in more plain old Java objects (POJOs) and far less configuration, resulting in fewer developer artifacts to create, manage, and maintain. Ease of development features in Java EE 6 include Web Fragments in servlets, EJB Lite, annotations in Connectors, and the ability to directly embed EJB components in Web modules. These and other enhanced features provide an easier development environment that significantly reduces development time and increases developer productivity. Several new capabilities of Java EE 6 enable developers to leverage the innovation that is available in the open-source community. An example of extensibility and ease-of-use is the zero-configuration, drag-and-drop design methodology for Web frameworks. Within the Java EE 6 release, servlets, servlet filters and context listeners are now discovered and registered automatically. By providing features that are easier to use, such as plug-in library jars that contain Web Fragments, the user community can be even more successful. The following is a high-level description of some of the major technologies and innovations that contribute to developer productivity and platform extensibility.

Servlet 3.0
The Servlet 3.0 specification is a major focus of Java EE 6. In Java EE 5, servlet classes and the accompanying web.xml file (which includes configuration metadata) were needed. In Servlet 3.0, annotations are used to declare servletsweb.xml files are no longer required. Servlet 3.0 makes it easier to add third party libraries without any web.xml changes. (Note that web.xml is optional, and can still be used where desirable.) For example, JavaServer Faces (JSF) 2.0 is integrated into Sun GlassFish Enterprise Server v3 using this capability. Developers can continue to use other annotations related to security and dependency injection from the servlet or filter.

Web Fragments
Servlet 3.0 offers a Web fragments descriptor that would specify the details of each library used by the container. Web fragments provide modularity, enabling logical partitioning of the web.xml deployment descriptor so that frameworks such as JavaServer Faces (JSF), IceFaces v2.0, and Atmosphere can have their own piece of information added in the JAR file. Framework authors do not have to edit web.xml they can predefine configuration information with the framework itself. There can be multiple Web Fragments, and the set can be viewed as an entire web.xml file. This logical partitioning of the web.xml file enables containers to auto-register Web frameworks. Each Web framework used in a Web application can define in a Web fragment all the artifactssuch as servlets and listenersthat it needs without requiring additional edits to the web.xml file.

7 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

Asynchronous Processing
Servlet 3.0 introduces support for asynchronous processing, avoiding a thread blocking request while waiting for a response from a database or message connection. With this support, a servlet no longer has to wait for a response from a resource, such as a database, before its thread can continue processing. Developers can mark servlets as asynchronous using annotations. Support for asynchronous processing makes the use of servlets with AJAX more efficient, and an improved ability to scale with minimal resources.

JAX-RS 1.1 (JSR 311)

The Java API for RESTful Web Services 1.1 (JAX-RS) specification provides a means through which URIs can be used to access and manipulate Web resources, including data and functionality, from anywhere on the Net. Using familiar commandsGET, PUT, POST, and DELETEthis technology enables clients and servers to communicate and exchange representations of these resources. RESTful Web Services are built using the REST architectural style. Building Web Services using the RESTful approach has emerged as a popular alternative to using SOAP-based technologies due to its lightweight nature and much simpler interface. For example, GlassFish v3 exposes its administration and monitoring capabilities as a RESTful service, enabling developers to create innovative services. Note that Sun offers a productionquality JAX-RS reference implementationJersey.

Enterprise JavaBeans 3.1 (EJB 3.1, JSR 318)

The EJB 3.0 specification, which is part of the Java EE 5 platform, made EJB technology easier to use than previous versions. The latest release of the technology, JSR 318: Enterprise JavaBeans 3.1 is available in the Java EE 6 platform and further simplifies the technology. EJB 3.1 makes many improvements that reflect common usage patterns, including:
Singletons. A session bean that is instantiated once per application, and can be

shared among multiple components within that application. Singleton beans provide the ability to easily share state between multiple instances of an enterprise bean component or between multiple enterprise bean components in an application. Singleton beans enable concurrent access, which can be managed using synchronization, or by the container. Singleton beans are like any other EJB componentsthey are POJOs that developers can mark as Singleton beans using annotations.
No-interface view. This enables the specification of an enterprise bean using only a

bean class, without having to write a local business interface. A local interface defines the business methods that are exposed to the client and that are implemented on the bean class. The no-interface view has the same behavior as the EJB 3.0 local view; for example, it supports other semantics such as pass-by reference, and transaction and security propagation. This interface is now optional, which means the enterprise bean can provide the same functionality without having to write a separate business interface.

8 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

Java Naming and Directory Interface (JNDI). Provides a means to globally locate EJB

components. Java EE 6 specifies portable global JNDI names, improving EJB portability across multiple implementations.
Asynchronous Session Bean. A session bean can be annotated to support asynchron-

ous method invocations. Prior to EJB 3.1, any method invocation on a session bean was always synchronous.
Embeddable API. EJB 3.1 provides an embeddable API and container for use in the

Java SE environment (same JVM). This allows easier testing of EJB components outside of a Java EE container.
Timer service. The EJB 3.1 architecture enhances the EJB timer service, which enables

cron-like scheduling (both declarative and programmatic) for all types of enterprise beans (except for stateful session beans). Implemented using annotations.

EJB Lite
EJB component technology provides robust functionality, but this is often more than some applications really need. EJB Lite is designed to meet the needs of applications that require only a subset of the features provided by EJB technology. EJB Lite is a standardized subset of the EJB 3.1 API, and not a one-off product or implementation. Applications developed using EJB Lite can run in application servers that implement either the Web Profile or the full Java EE 6 platform. Developers can use EJB Lite to simplify the development of security, transactional business components without having to learn the full power of EJBs up front. Vendor implementations of EJB Lite are expected to be simpler and more focused than full EJB component implementations. EJB Lite is also part of the Web Profile. See Table 2 for a comparison. Table 2: Different capabilities of EJB Lite. If an application needs only the features selected in the EJB Lite column, then the Web Profile distribution can be used.
EJB Lite Local Session Beans Declarative Security Transactions (CMT/BMT) Interceptors Security Message Driven Beans RMI/IIOP Interoperability and Remote View EJB 2.x Backwards Compatibility Timer Service Asynchronous X X X X X EJB 3.1 X X X X X X X X X X

9 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

Java Persistence API 2.0 (JPA, JSR 317)

Persistence is the technique through which object models broker the access and manipulation of information from a relational database. JPA handles the details of how relational data is mapped to Java objects, and it standardizes Object/Relational mapping. JPA was introduced in Java EE 5, and provided a POJO-based persistence model for Java EE and Java SE applications. JPA has been enhanced in Java EE 6. The Java Persistence API (JPA) version 2.0 specification facilitates more effective and reliable (that is, more strongly typed) methodology for building object-centric criteria-based dynamic database queries.
Object/Relational mapping enhancements. For example, JPA 2.0 adds the ability to

map collections of basic data types, such as Strings or Integers, as well as collections of embeddable objects. There are new annotations that support collection mappings.
Java Persistence Query Language (JPQL) enhancements. These include new operators

such as NULLIF, VALUE, and others, and case expressions can be used in queries.
Criteria API. A type safe query mechanism, based on the metamodel concept, which

can verify persistent Java objects. It can be statically or dynamically accessed. A string-based model is also available, but not as type safe.

Contexts and Dependency Injection for Java EE (CDI, JSR 299)

Dependency injection can be applied to all resources that a component needs, effectively hiding the creation and lookup of resources from application code. It allows the Java EE container to automatically insert references to other required components or resources using annotations. Dependency injection can be used in EJB containers, Web containers, and application clients. Previously known as Web Beans, CDI adds dependency injection and context management facilities to the existing Java EE component models. This functionality allows developers to use plain Java beans, session beans and JSF managed beans interchangeably to hold state in their applications. Moreover, each bean can be attached to a particular scope, for example a single request, an HTTP session or a conversation. The CDI runtime will then ensure that beans are created, injected, and destroyed at the appropriate time within the lifecycle of the application, in accordance with the scope they are attached to, resulting in simpler, error-free state management. Beans also have the ability to fire and observe events, enabling components within a single application to interact in a more loosely-coupled way than was possible before. CDI brings transactional support to the Web tier, making it easier to access transactional resources in Web applications. For example, CDI services facilitate building a Java EE Web application that accesses a database with persistence provided by the Java Persistence API. Note that dependency injection is a popular technique in developing enterprise Java applications, but there has not been a standardized approach. Dependency Injection For Java (JSR 330) introduces a standard set of annotations that can be used for dependency injection.

10 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

JavaServer Faces 2.0 (JSF, JSR 314)

JavaServer Faces technology, the server-side component framework designed to simplify the development of user interfaces for Java EE applications, has been simplified and improved, especially in the area of page authoring. Facelets is a powerful but lightweight page declaration language to design JavaServer Faces views using HTML style templates and to build component trees. Facelets also enables code reuse through templating and can significantly reduce the time to develop and deploy user interfaces. Templating is used to create a page that acts as a template for other pages in an application. This helps avoid creating similarly constructed pages multiple times, while maintaining a standard look and feel in an application with a large number of pages. Facelets views are usually written using XHTML markup language, enabling them to be more portable across development platforms. An example of annotation support in JSF 2.0 is the simplified approach to configuring managed beans. Instead of registering a managed bean by configuring it in the JSF configuration file, faces-config.xml, the bean need only be marked and the scope set with the appropriate annotations.

Bean Validation 1.0 (JSR 303)

Validating data is a common task that occurs throughout an application, from the presentation layer to the persistence layer. For example, validation logic can be applied to an entry field, ensuring that a number is within a certain range. Often the same validation logic is implemented within each layer, proving time consuming and errorprone. To avoid duplication of these validations in each layer, developers often bundle validation logic directly into the domain model, cluttering domain classes with validation code that is, in effect, metadata about the class itself. JSR 303 defines a metadata model and an API to provide JavaBeans validation. Bean Validation is integrated across the Java EE 6 platform. For example, presentation layer technologies such as JSF and enterprise layer technologies such as JPA have access to the constraint definitions and validators provided through the Bean Validation framework. The default metadata syntax uses annotations, with the ability to override and extend the metadata through the use of XML validation descriptors. The validation API described within JSR 303 is specifically not intended to be limited to any particular tier of the multitiered programming model. As such, the functionality offered by the validation API is available for both server-side application programming, as well as for richclient Swing application developers. This API is seen as a general extension to the JavaBeans object model, and is expected to be used as a core component within other specifications. Ease of use and flexibility were the guiding objectives throughout the development of this specification.

Connector Architecture 1.6 (JSR 322)

For enterprise application integration, bidirectional connectivity between enterprise applications and an Enterprise Information System (EIS) is essential. The Java EE Connector Architecture defines a standard set of contracts that allow bidirectional connectivity between enterprise applications and EIS providers. It also formalizes the relationships, interactions, and the packaging of the integration layer, thus enabling

11 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

unfettered enterprise application integration. If an application server vendor extends its system once to support the connector architecture, the application server vendor is assured of being able to seamlessly connect to multiple off-the-shelf EIS offerings. Likewise, if an EIS vendor provides an industry standard resource adapter, such as is described within JSR 322, the EIS vendor is assured of being able to plug into any application server that supports the connector architecture. New features include: The Connector 1.6 specification (JSR 322) enhances the Connector Architecture through the following means:
Ease of development: Dramatically simplifies the development of resource adapters

through extensive use of Java language annotations, reducing the need to write redundant code and the need for a deployment descriptor (ra.xml), provides better configuration defaults, and so on.
Generic Work Context mechanism: Defines a generic mechanism for propagating

contextual information during Work execution. The specification standardizes passing in security, transactional and other quality-of-service parameters from an EIS to a Java EE component during Work execution.
Security Work Context: Defines a standard contract that a resource adapter could

employ to establish security information (established identity) while submitting a Work instance for execution to a WorkManager, and while delivering messages to message endpoints (MDBs) residing in the application server.

Packaging
Packaging and deployment are easier than in previous versions. In the example shown in Figure 3, the left side represents what is needed to develop and deploy under Java EE 5: the web.xml for configuration metadata and presentation code are packaged in BuyBooks.war; the business logic is packaged in ShoppingCart.jar; everything is then packaged up in the BuyBooks.ear file. This is greatly simplified under Java EE 6, where the same shopping cart example is shown on the right side of Figure 3. EJB components can be packaged directly in a .war file. However, the traditional method of supporting EJB files is still supported.

Figure 3: Packaging and deploying applications is easier under Java EE 6 (on the right). EJB class files can be packaged as part of the .war file.

12 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

Chapter 5

Sun GlassFish Enterprise Server v3

Sun GlassFish Enterprise Server v3 is the first compatible, production implementation of the Java EE 6 Platform specification. Many of the Java EE 6 themes carry over to GlassFish Enterprise Server v3flexibility, extensibility, and developer ease of use. This lightweight, flexible, and open-source application server enables organizations to not only leverage the new capabilities introduced within the Java EE 6 specification, but to add to their existing capabilities through a faster and more streamlined development and deployment cycle. Notable features of the GlassFish Enterprise Server v3 release include a modular architecture based on OSGi for improved startup time, reduced resource utilization, rapid iterative development, and fine-grained monitoring. Dynamic Trace (DTrace) probes for improved observability are expected to be added shortly after release. GlassFish v3 also delivers support for third party dynamic languages such as JRuby, Jython, and Groovyoften without the need for a Web container. To support rapid iterative development cycles, GlassFish Enterprise Server v3 saves session state when an application is deployed. Instead of six time-consuming steps (edit, save code, compile, package, deploy, and repopulate session data), the same process now requires just three, when using integrated development environments (IDEs) such as Eclipse and NetBeans: edit, save, and refresh the browser. Strong support and tight integration with GlassFish v3 improves ease-of-use and productivity. GlassFish Enterprise Server v3 is available as a standalone offering, and as part of the GlassFish Portfolio. A comprehensive offering for building end-to-end enterprise applications, GlassFish Portfolio includes:
GlassFish ESB: A lightweight integration platform that delivers new and existing

content to the Web. The technology is created by the OpenESB community on java.net and is subject to the same grade of testing as the Java Composite Application Platform Suite (Java CAPS). It is the leading business integration platform, providing a robust foundation for service-oriented architectures (SOAs).
GlassFish Web Stack: A complete (L/S)AMP stack for enterprise-wide deployment, it

allows developers and administrators to leverage and standardize on technologies they already know: Apache HTTP Server, Tomcat, MySQL, PHP, and more.
GlassFish Web Space Server: Market-leading, open-source portal for building and

deploying collaborative workspaces, including SharePoint functionality.

Additional components, including Message Queue, Proxy Server, and more.

Subscribers to GlassFish Portfolio get access to production patch management capabilities, and can choose from several different support levels.

13 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

Chapter 6

Integrated Development Environments (IDEs)

Leading integrated development environments (IDEs) such as NetBeans and Eclipse, can be used to develop applications and other components for the Java EE 6 Platform. These leading IDEs support virtually all of the Java EE 6 capabilities described in this paper: Singletons, Web Fragments, Facelets, and others. NetBeans provides comprehensive support of the Java EE 6 Platform and its reference implementationGlassFish v3as shown in Figure 4.

Figure 4: GlassFish v3 and NetBeans For example, NetBeans automatically determines what versions of the sub-specifications to use based on what is supported by the target environment (such as Java EE Platform and application server release levels). There are some Java EE 6 technologies that can be used in Java EE 5 applications serversJSF 2.0 can be used with Java EE 5 projects, as well as JAX-RS (Java API for RESTful Web Services 1.0), and NetBeans allows this option as appropriate.

14 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

The open source GlassFish Tools Bundle for Eclipse, as shown in Figure 5, enables developers to build applications with the Eclipse IDE and deploy them to the GlassFish Server. This distribution contains a comprehensive environment for using Eclipse to develop Java EE applications for deployment on the GlassFish environment. Both GlassFish v2.1 and v3 Prelude are bundled and pre-configured with the build.

Figure 5: GlassFish v3 and Eclipse

15 Introduction to the Java EE 6 Platform

Sun Microsystems, Inc.

Chapter 7

Summary
After 10 years of running business critical applications for thousands of organizations, the Java Enterprise Edition technology platform continues to make tremendous progress as an enterprise application development and deployment platform. Java EE 6 delivers a comprehensive set of APIs that can simplify the developer experience while improving productivity. Annotation-based programming and zero-configuration Web frameworks that leverage open-source innovation further simplify the developer environment while extending the platform, Profiles create new, focused architectures of standards-based EJB components, while pruning clears out unused technologies. There are several technical enhancements, including Servlet 3.0, Facelets, RESTful Web services, Connectors, an enhanced persistence architecture, dependency injection, and much more. Developing enterprise applications with Java technology has never been easier.

More Information
Java: java.sun.com/javaee GlassFish v3: sun.com/glassfishv3 GlassFish v3 Resources: sun.com/glassfish/resources NetBeans: netbeans.org

References
Webinar: Java EE 6 Overview (sun.com/offers/details/java_EE6_overview.xml) Webinar: JavaServer Faces 2.0 (sun.com/offers/details/javaserver_faces.xml) JSR 045: Debugging Support for Other Languages JSR 052: Standard Tag Library for JavaServer Pages 1.2 JSR 109: Implementing Enterprise Web Services 1.1 JSR 196: Authentication Service Provider Interface 1.1 JSR 222: Java Architecture for XML Binding (JAXB) 2.1 JSR 224: Java API for XML Web-Based Services (JAX-WS) 2.2 JSR 245: JavaServer Pages (JSP) 2.1 JSR 250: Common Annotations for the Java Platform JSR 252: JavaServer Faces (JSF) 1.2 JSR 299: Contexts and Dependency Injection for the Java EE Platform JSR 303: Bean Validation 1.0 JSR 311: The Java API for RESTful Web Services (JAX-RS) JSR 314: JavaServer Faces 2.0 JSR 315: Java Servlet 3.0 JSR 317: Java Persistence API (JPA) 2.0 JSR 318: Enterprise JavaBeans (EJB) 3.1 JSR 322: Java EE Connector Architecture 1.6 JSR 907: Java Transaction API (JTA) 1.1

Introduction to the Java EE 6 Platform

Sun Microsystems, Inc

Sun Microsystems, Inc. 4150 Network Circle, Santa Clara, CA 95054 USA Phone 1-650-960-1300 or 1-800-555-9SUN (9786) Web sun.com
2009 Sun Microsystems, Inc. All rights reserved. Sun, Sun Microsystems, the Sun logo, GlassFish, Java, Java Community Process, JCP, EJB, JSP, JNDI, JavaBeans, JavaServer, JavaMail, and NetBeans are trademarks or registered trademarks of Sun Microsystems, Inc. or its subsidiaries in the United States and other countries. Information subject to change without notice. 12/09