Java EE 6.0 with GlassFish 3 Application Server
This book begins with the installation of Glassfish 3 and deploying Java applications. It
also explains how to develop, configure, package, and deploy servlets. Additionally, we
will learn the processing of HTML forms. As we move on, we will develop Java Server
Pages and get to know about implicit JSP objects. We will also get to know about all the
JSTL (JSP Standard Tag Library) tag libraries. This book gives us a better understanding
on how to manage data from a database through the Java Database Connectivity (JDBC)
API and the Java Persistence API (JPA). We will also learn more about the newly
introduced features of JPA 2.0 and develop JSF 2.0 applications to learn how to
customize them. We will then set up Glassfish for the Java Messaging (JMS) API and
understand the working of message queues and message topics. Later, we will use the
Context and Dependency Injection (CDI) API to integrate application layers and study
the SOAP-based web service development using the JAX-WS specification. Finally, we
will learn more about the RESTful web service development using the JAX-RS
The book covers the various Java EE 6 conventions and annotations that can simplify
enterprise Java application development. The latest versions of the Servlet, JSF, JPA,
EJB, and JAX-WS specifications are covered, as well as new additions to the
specification, such as JAX-RS and CDI.
What This Book Covers
Chapter 1, Getting Started with GlassFish will discuss how to download and install
GlassFish. We will look at several methods of deploying a Java EE application through
the GlassFish web console, through the asadmin command, and by copying the file to
the autodeploy directory. We will cover basic GlassFish administration tasks such as
setting up domains and setting up database connectivity by adding connection pools and
Chapter 2, Servlet Development and Deployment will cover how to develop, configure,
package, and deploy servlets. We will also cover how to process HTML form
information by accessing the HTTP request object. Additionally, forwarding HTTP
requests from one servlet to another will be explained, as well as redirecting the HTTP
response to a different server. We will discuss how to persist objects in memory across
requests by attaching them to the servlet context and the HTTP session. Finally, we will
look at all the major new features of Servlet 3.0, including configuring web applications
via annotations, pluggability through web-fragment. xml , programmatic servlet
configuration, and asynchronous processing.
Chapter 3, JavaServer Pages will talk about how to develop and deploy simple JSPs. We
will cover how to access implicit objects such as request, session, and so on, from
JSPs. Additionally, we will look at how to set and get the values of JavaBean properties
via the <jsp:useBean> tag. In addition to that, we will find out how to include a JSP
into another JSP at runtime via the <jsp:include> tag, and at compilation time via the
JSP include directive. We will discuss how to write custom JSP tags by extending
javax.servlet.jsp.tagext.SimpleTagSupport or by writing TAG files. We
will also discuss how to access JavaBeans and their properties via the Unified Expression
Language. Finally, we will cover the JSP XML syntax that allows us to develop XMLcompliant
Chapter 4, JSP Standard Tag Library will cover all JSP Standard Tag Library tags,
including the core, formatting, SQL, and XML tags. Additionally, JSTL functions will be
explained. Examples illustrating the most common JSTL tags and functions will be
provided; additional JSTL tags and functions will be mentioned and described.
Chapter 5, Database Connectivity will talk about how to access data in a database via
both the Java Database Connectivity (JDBC) and through the Java Persistence API (JPA).
Defining both unidirectional and bidirectional one-to-one, one-to-many, and many-tomany
relationships between JPA entities will be covered. Additionally, we will discuss
how to use JPA composite primary keys by developing custom primary key classes. We
will also discuss how to retrieve entities from a database by using the Java Persistence
Query Language (JPQL). We will look at how to build queries programmatically through
the JPA 2.0 Criteria API and automating data validation through JPA 2.0′s Bean
Chapter 6, JavaServer Faces will cover how to develop web-based applications using
JavaServer Faces—the standard component framework for the Java EE 5 platform. We
will talk about how to write a simple application by creating JSPs containing JSF tags
and managed beans. We will discuss how to validate user input by using JSF‘s standard
validators and by creating our own custom validators, or by writing validator methods.
Additionally, we will look at how to customize standard JSF error messages; both the
message text and the message style (font, color, and so on). Finally, we will discuss how
to write applications by integrating JSF and the Java Persistence API (JPA).
Chapter 7, Java Messaging Service will talk about how to set up JMS connection
factories, JMS message queues, and JMS message topics in GlashFish using the
GlashFish web console. We will cover how to send and receive messages to and from a
message queue. We will discuss how to send and receive messages to and from a JMS
message topic. We will find out how to browse messages in a message queue without
removing the messages from the queue. Finally, we will look at how to set up and interact
with durable subscriptions to JMS topics.
Chapter 8, Security will talk about how to use GlashFish‘s default realms to authenticate
our web applications. We will cover the file realm, which stores user information in a flat file, and the certificate realm, which requires client-side certificates for user
authentication. Additionally, we will discuss how to create additional realms that behave
just like the default realms, by using the realm classes included with GlashFish.
Chapter 9, Enterprise JavaBeans will cover how to implement business logic via stateless
and stateful session beans. Additionally, we will explain the concept of containermanaged
transactions and bean-managed transactions. We will look at the life cycles for
the different types of Enterprise Java Beans. We will talk about how to have EJB
methods invoked periodically by the EJB container, by taking advantage of the EJB timer
service. Finally, we will explain how to make sure that EJB methods are only invoked by
Chapter 10, Contexts and Dependency Injection will talk about how JSF pages can access
CDI named beans as if they were JSF managed beans. We will explain how CDI makes it
easy to inject dependencies into our code. We will discuss how we can use qualifiers to
determine what specigic implementation of dependency to inject into our code. Finally,
we will look at all the scopes that a CDI bean can be placed into.
Chapter 11, Web Services with JAX-WS will cover how to develop web services and
web service clients via the JAX-WS API. We will discuss how to send attachments to a
web service. We will explain how to expose an EJB’s methods as web services. Finally,
we will look at how to secure web services so that they are not accessible to unauthorized
Chapter 12, RESTful Web Services with Jersey and JAX-RS will discuss how to easily
develop RESTful web services using JAX-RS—a new addition to the Java EE
specification. We will explain how to automatically convert data between Java and XML
by taking advantage of the Java API for XML Binding (JAXB). Finally, we will cover
how to pass parameters to our RESTful web services via the @PathParam and
Java Messaging Service
The Java Messaging API (JMS) provides a mechanism for Java EE applications to
send messages to each other. JMS applications do not communicate directly, instead
message producers send messages to a destination and message consumers receive
the message from the destination.
The message destination is a message queue when the point-to-point (PTP)
messaging domain is used, or a message topic when the publish/subscribe
(pub/sub) messaging domain is used.
In this chapter, we will cover the following topics:
- Setting up GlashFish for JMS
- Working with message queues
- Working with message topics
Setting up GlassFish for JMS
Before we start writing code to take advantage of the JMS API, we need to configure
some GlashFish resources. Specifically, we need to set up a JMS connection factory,
a message queue, and a message topic.
Setting up a JMS connection factory
The easiest way to set up a JMS connection factory is via GlashFish‘s web console.
Recall from Chapter 1 that the web console can be accessed by starting our domain,
by entering the following command in the command line:
asadmin start-domain domain1
Then point the browser to http://localhost:4848 and log in:
A connection factory can be added by expanding the Resources node in the tree
at the left-hand side of the web console, expanding the JMS Resources node and
clicking on the Connection Factories node, then clicking on the New… button in
the main area of the web console.
For our purposes, we can take most of the defaults. The only thing we need to do is
enter a Pool Name and pick a Resource Type for our connection factory.
It is always a good idea to use a Pool Name starting with “jms/” when
picking a name for JMS resources. This way JMS resources can be
easily identified when browsing a JNDI tree.
In the text field labeled Pool Name, enter jms/GlassFishBookConnectionFactory.
Our code examples later in this chapter will use this JNDI name to obtain a reference
to this connection factory.
The Resource Type drop-down menu has three options:
- javax.jms.TopicConnectionFactory – used to create a connection factory that
creates JMS topics for JMS clients using the pub/sub messaging domain
- javax.jms.QueueConnectionFactory – used to create a connection factory
that creates JMS queues for JMS clients using the PTP messaging domain
- javax.jms.ConnectionFactory – used to create a connection factory that
creates either JMS topics or JMS queues
For our example, we will select javax.jms.ConnectionFactory. This way we can use
the same connection factory for all our examples, those using the PTP messaging
domain and those using the pub/sub messaging domain.
After entering the Pool Name for our connection factory, selecting a connection
factory type, and optionally entering a description for our connection factory,
we must click on the OK button for the changes to take effect.
We should then see our newly created connection factory listed in the main area of
the GlashFish web console.
Setting up a JMS message queue
A JMS message queue can be added by expanding the Resources node in the tree
at the left-hand side of the web console, expanding the JMS Resources node and
clicking on the Destination Resources node, then clicking on the New… button in
the main area of the web console.
In our example, the JNDI name of the message queue is jms/GlassFishBookQueue.
The resource type for message queues must be javax.jms.Queue. Additionally,
a Physical Destination Name must be entered. In this example, we use
GlassFishBookQueue as the value for this field.
After clicking on the New… button, entering the appropriate information for
our message queue, and clicking on the OK button, we should see the newly
Setting up a JMS message topic
Setting up a JMS message topic in GlashFish is very similar to setting up a
In the GlashFish web console, expand the Resources node in the tree at the left hand
side, then expand the JMS Resouces node and click on the Destination Resources
node, then click on the New… button in the main area of the web console.
Our examples will use a JNDI Name of jms/GlassFishBookTopic. As this is a
message topic, Resource Type must be javax.jms.Topic. The Description field is
optional. The Physical Destination Name property is required. For our example, we
will use GlassFishBookTopic as the value for this property.
After clicking on the OK button, we can see our newly created message topic:
Now that we have set up a connection factory, a message queue, and a message
topic, we are ready to start writing code using the JMS API.
- Integrating Spring with JMS by Christy
- JMS Articles
- Spring JMS API and Weblogic JMS Integration by Sangeetha