Page 1 of 3

Monday, September 06, 2010

Search CIOL Network sites

CIOL Network Sites
Web pcquest.com
Search by Issue | Sitemap | Advanced Search

• Simplify your steps to success with wipro's unified communication Solutions

------------------------------------------------------------
This story was printed from PCQuest at http://www.pcquest.com/
------------------------------------------------------------

Article Title: Java EE 6 & GlassFish v3

URL: http://www.pcquest.com/content/search/showarticle1.asp?arid=118880
Section: Features
Author Name:
Author Email:
------------------------------------------------------------

Arun Gupta, GlassFish Evangelist

The Java EE 6 platform defines a standard way to develop, deploy, and manage distributed, and multi-
tier enterprise Java applications. There are three components of the platform – a Specification, a
Reference Implementation (RI), and a Technology Compatibility Kit (TCK). The specification is created as
Java Specification Request (JSR) 316 under the open and collaborative Java Community Process (JCP).
The different aspects of the platform, such as Transactions, Persistence, and Web services are defined in
it's own specification following the same collaborative process. For example, Java Persistence API 2.0
defines an API for the management of persistence and object/relational mapping. Reference
implementation is a binary distribution and is a proof-of-concept that the APIs and assertions defined in
the specification can be implemented.

GlassFish v3 is the open source reference implementation for Java EE 6 and is extremely lightweight,
highly performant, and production quality that can be used in mission critical applications. The TCK is a
set of tests that can be run on any Java EE 6 implementation to ensure conformance with the
specification.

The Java EE platform has evolved and matured over the past 10 Direct Hit!
years. There are three main themes in the Java EE 6 platform –
extensibility, profiles, and pruning. Extension points and server Applies To: Developers,
provider interfaces are added to the platform enabling other useful Program-mers, Project
technologies desired by the web and enterprise developer to plug into Managers, CIO
platform implementations cleanly and efficiently. This allows a third USP: Learn Java EE has evolved
party framework to be seamlessly integrated with a Java EE 6 Primary Link:
implementation, such as GlassFish. For example, typically these http://glassfish.dev.java.net
frameworks have to rely upon registering servlet filters/listeners in http://www.ciol.com/sparkIT/2010
'web.xml' or a similar mechanism to register with the Web container. Search Engine Keywords: Java
The Servlet 3.0 specification defines 'web module deployment EE, GlassFish
descriptor fragment' (aka 'web-fragment.xml') that allows all the
framework configuration information to be specified in 'META-INF/web-fragment.xml'. The Web container
uses the specified configuration for registering the framework.

http://pcquest.ciol.com/cgi-bin/printer.asp?id=118880 9/6/2010
 Page 2 of 3

Profile and Pruning together address the ever increasing size of the Java EE platform. The profiles allow
to refocus the Java EE platform on particular classes of developers and applications. A profile is a
reconfiguration of the platform and consist of a proper subset of technologies contained in the platform,
technologies not present in the platform, and may tag certain technologies optional. The platform
specification defines the rules to create or revise an existing profile. As part of Java EE 6, a Web Profile
targeted at developers of modern web applications is defined. It clearly defines the set of technologies
needed by most web application developers.

Certain technologies included in the Java EE platform are no longer relevant as

they were introduced to the platform. Pruning defines a 2-step process to convert
a required feature of the platform into an optional component. The platform Java
EE 6 specification defines the technologies that are pruned in this release. For
example JAX-RPC 1.1 and JAXR 1.0 are marked for pruning in this release and will
be marked optional in the next release of the platform.

In addition to the main themes, the platform continues to evolve on simplicity and
ease-of-development. A few new specifications are added to the platform to make it
more robust. Contexts and Dependency Injection (JSR 299), aka CDI, provides a
type-safe dependency injection for Java EE. It utilizes the annotations defined by
the more generic Dependency Injection for Java (JSR 330) and adapts it for Java EE environments.
Basically CDI adds a number of additional features useful for enterprise applications. Bean Validation
(JSR 303) defines a metadata model and API for JavaBean validation. Standard constraints like
@NotNull and @Size are defined in 'javax.validation.constraints.*' package and may be applied to JSF
managed beans and JPA entity beans. New constrains can be easily defined using the framework defined
by the specification. Java API for RESTful Web services (JSR 311), aka JAX-RS, defines an API for
RESTful Web services in the platform. This API has been available for for some time and is now included
in the platform.

Several other specifications in the platform received a major face lift as well. Servlets 3.0 make 'web.xml'
optional in most of the cases by introducing equivalent annotations and following the better defaults and
convention-over-configuration rules defined in the specification. Dynamic registration of servlets and
filters, asynchronous processing, and security enhancements are some other enhancements in this area.
Java Server Faces (JSF) 2.0 now uses Facelets as the view technology, has Ajax support integrated,
does not require 'faces-config.xml' in common cases, and makes composite components' authoring
easier. Starting with Enterprise Java Beans (EJB) 3.1, EJBs can now be easily packaged into a Web
ARchive (WAR) file. A singleton bean for shared state across the java Virtual Machine (JVM), optional
interface, and cron-like calendar semantics are some other improvements made in this area. JPA 2
expands the object/relational mapping and makes it more natural to a Java developer. A type-safe Criteria
API, improvements to the Java Persistence Query Language (JPQL), and a metamodel API provides
useful additions for database developers.

Several other specifications like Java EE Connector Architecture 1.6, Java API for XML Web Services
(JAX-WS) 2.2, Java API for XML Binding (JAXB) 2.2, Web Services Metadata MR3, Java Server Pages
(JSP) 2.2 / Expression Language (EL) 2.2, and many others are also updated to align with the platform.
The complete list of specifications is included in the Java EE 6 platform specification.

All features mentioned above can be taken for a test drive with GlassFish v3 which can be downloaded
from http://glassfish.dev.java.net. GlassFish v3 is a light-weight, modular, embeddable, extensible, and
Java EE 6 compliant application server. The modularity comes from the fact that the core of GlassFish is
an OSGi R4.1 compliant runtime. Even though Apache Felix is used, and bundled, as the OSGi runtime
but GlassFish can be easily configured to run on top of other OSGi runtimes such as Equinox and
Knopflerfish. Any standard OSGi bundle can easily run on GlassFish.

Each deployed application is associated with one or more containers such as Web, Security, and JPA. An
efficient utilization of resources and memory is achieved by starting only the containers required by all the
deployed applications. The embeddable feature allows GlassFish to run inside an existing JVM using
programmatic APIs. This removes the need for explicitly downloading and configuring a binary bundle. In

http://pcquest.ciol.com/cgi-bin/printer.asp?id=118880 9/6/2010
 Page 3 of 3

addition to Java EE 6, GlassFish can also run Ruby-on-Rails, Sinatra, Ramaze, Groovy-and-Grails, and
Python/Django applications natively. Well defined extension points in monitoring, deployment,
configuration, administration, and other modules allow to extend the core functionality of GlassFish in a
very smooth and seamless manner. A RESTful interface to monitoring and management data from
GlassFish allows toolkit developers to write their custom scripts and clients using language of their choice
such as Java, JavaScript, or Ruby.

NetBeans, Eclipse, and IntelliJ provide a comprehensive set of tooling around different Java EE 6
features. Wizard-drive development, integrated javadocs, code completion, syntax coloring, debugging,
and many other features like these truly provide an integrated experience to develop Java EE 6
applications in these IDEs. In addition, NetBeans and Eclipse boosts developer productivity multi-folds by
automatically deploying the application when the application files are saved. Optionally, the session state
may be preserved across multiple deploys.

------------------------------------------------------------

Copyright (c) 2010 CMIL All rights reserved. Additional reproduction in whole or in part or in any form or
medium without express written permission of CIOL is prohibited.
Send your questions to webmaster@ciol.com

Close this window

http://pcquest.ciol.com/cgi-bin/printer.asp?id=118880 9/6/2010