WebSphere Application Server 7.0 Administration Guide
As a J2EE (Enterprise Edition) administrator, you require a secure, scalable,
and resilient infrastructure to support and manage your J2EE applications and
service-oriented architecture services.
The WebSphere suite of products from IBM provides many different industry
solutions and WebSphere Application Server is the core of the WebSphere product
range from IBM.
WebSphere is optimized to ease administration and improve runtime performance.
It runs your applications and services in a reliable, secure, and high-performance
environment to ensure that your core business opportunities are not lost due to
application or infrastructure downtime.
Whether you are experienced or new to WebSphere, this book will provide you with a
cross-section of WebSphere Application Server features and how to configure these
features for optimal use. This book will provide you with the knowledge to build and
manage performance-based J2EE applications and service-oriented architecture (SOA)
services, offering the highest level of reliability, security, and scalability.
Taking you through by examples, you will be shown the different methods for installing
WebSphere Application Server and will be shown how to configure and prepare
WebSphere resources for your application deployments. The facets of data-aware and
message-aware applications are explained and demonstrated, giving the reader real-world
examples of manual and automated deployments.
WebSphere security is covered in detail showing the various methods of implementing
federated user and group repositories. Key administration features and tools are
introduced, which will help WebSphere administrators manage and tune their WebSphere
implementation and applications. You will also be shown how to administer your
WebSphere server standalone or use the new administrative agent, which provides the
ability to administer multiple installations of WebSphere Application Server using one
single administration console.
What This Book Covers
Chapter 1, Installing WebSphere Application Server covers how to plan and prepare
your WebSphere installation and shows how to manually install WebSphere using the
graphical installer and how to use a response file for automated silent installation. The
fundamentals of application server profiles are described and the administrative console
Chapter 2, Deploying your Applications explains the make-up of Enterprise Archive
(EAR) files, how to manually deploy applications, and how Java Naming and Directory
Interface (JNDI) is used in the configuration of resources. Connecting to databases is
explained via the configuration of Java database connectivity (JDBC) drivers and data
sources used in the deployment of a data-aware application.
Chapter 3, Security demonstrates the implementation of global security and how to
federate lightweight directory access protocol (LDAP) and file-based registries for
managing WebSphere security. Roles are explained where users and groups can be
assigned different administrative capabilities.
Chapter 4, Administrative Scripting introduces ws_ant, a utility for using apache Ant
build scripts to deploy and configure applications. Advanced administrative scripting is
demonstrated by using the wsadmin tool with Jython scripts, covering how WebSphere
deployment and configuration can be automated using the extensive WebSphere Jython
Chapter 5, WebSphere Configuration explains the WebSphere installation structure and
key XML files, which make up the underlying WebSphere configuration repository.
WebSphere logging is covered showing the types of log and log settings that are vital for
administration. Application Server JVM settings and class loading are explained.
Chapter 6, WebSphere Messaging explains basic Java message service (JMS) messaging
concepts and demonstrates both JMS messaging using the default messaging provider
and WebSphere Message Queuing (MQ) along with explanations of message types. Use
of Queue Connection Factories, Queues, and Queue Destinations are demonstrated via a
Chapter 7, Monitoring and Tuning shows how to use TivoliPerformance Monitor,
request metrics, and JVM tuning settings to help you improve WebSphere performance
and monitor the running state of your deployed applications.
Chapter 8, Administrative Features covers how to enable the administrative agent for
administering multiple application servers with a central administrative console. IBM
HTTP Server and the WebSphere plug-in are explained.
Chapter 9, Administration Tools demonstrates some of the shell-script-based utilities
vital to the WebSphere administrator for debugging and problem resolution.
Chapter 10, Product Maintenance shows how to maintain your WebSphere Application
Server by keeping it up-to-date with the latest fix packs and feature packs.
Messaging in a large enterprise is common and a WebSphere administrator needs
to understand what WebSphere Application Server can do for Java Messaging
and/or WebSphere Message Queuing (WMQ) based messaging. Here, we will
learn how to create Queue Connection Factories (QCF) and Queue Destinations
(QD) which we will use in a demonstration application where we will demonstrate
the Java Message Service (JMS) and also show how WMQ can be used as part of a
In this chapter, we will cover the following topics:
- Java messaging
- Java Messaging Service (JMS)
- WebSphere messaging
- Service integration bus (SIB)
- WebSphere MQ
- Message providers
- Queue connection factories
- Queue destinations
Messaging is a method of communication between software components or
applications. A messaging system is often peer-to-peer, meaning that a messaging
client can send messages to, and receive messages from, any other client. Each
client connects to a messaging service that provides a system for creating, sending,
receiving, and reading messages. So why do we have Java messaging? Messaging
enables distributed communication that is loosely-coupled. What this means is
that a client sends a message to a destination, and the recipient can retrieve the
message from the destination. A key point of Java messaging is that the sender and
the receiver do not have to be available at the same time in order to communicate.
The term communication can be understood as an exchange of messages between
software components. In fact, the sender does not need to know anything about the
receiver; nor does the receiver need to know anything about the sender. The sender
and the receiver need to know only what message format and what destination
to use. Messaging also differs from electronic mail (email), which is a method of
communication between people or between software applications and people.
Messaging is used for communication between software applications or software
components. Java messaging attempts to relax tightly-coupled communication
(such as, TCP network sockets, CORBA, or RMI), allowing software components
to communicate indirectly with each other.
Java Message Service
Java Message Service (JMS) is an application program interface (API) from Sun. JMS
provides a common interface to standard messaging protocols and also to special
messaging services in support of Java programs. Messages can involve the exchange
of crucial data between systems and contain information such as event notification
and service requests. Messaging is often used to coordinate programs in dissimilar
systems or written in different programming languages. By using the JMS interface,
a programmer can invoke the messaging services like IBM’s WebSphere MQ (WMQ)
formerly known as MQSeries, and other popular messaging products. In addition,
JMS supports messages that contain serialized Java objects and messages that contain
A JMS application is made up of the following parts, as shown in the
- A JMS provider is a messaging system that implements the JMS interfaces
and provides administrative and control features.
- JMS clients are the programs or components, written in the Java
programming language, that produce and consume messages.
- Messages are the objects that communicate information between
- Administered objects are preconfigured JMS objects created by an
administrator for the use of clients. The two kinds of objects are
destinations and Connection Factories (CF).
As shown in the diagram above, administrative tools allow you to create destinations
and connection factories resources and bind them into a Java Naming and Directory
Interface (JNDI) API namespace. A JMS client can then look up the administered
objects in the namespace and establish a logical connection to the same objects
through the JMS provider.
Application clients, Enterprise Java Beans (EJB), and Web components can send or
synchronously receive JMS messages. Application clients can, in addition, receive
JMS messages asynchronously. A special kind of enterprise bean, the message-driven
bean, enables the asynchronous consumption of messages. A JMS message can also
participate in distributed transactions.
The JMS API supports two models:
Point-to-point or queuing model
As shown below, in the point-to-point or queueing model, the sender posts messages
to a particular queue and a receiver reads messages from the queue. Here, the sender
knows the destination of the message and posts the message directly to the receiver’s
queue. Only one consumer gets the message. The producer does not have to be
running at the time the consumer consumes the message, nor does the consumer need
to be running at the time the message is sent. Every message successfully processed
is acknowledged by the consumer. Multiple queue senders and queue receivers can
be associated with a single queue, but an individual message can be delivered to
only one queue receiver. If multiple queue receivers are listening for messages on a
queue, Java Message Service determines which one will receive the next message on a
first-come-first-serve basis. If no queue receivers are listening on the queue, messages
remain in the queue until a queue receiver attaches to the queue.
Publish and subscribe model
As shown by the above diagram, the publish/subscribe model supports publishing
messages to a particular message topic. Unlike the point-to-point messaging model,
the publish/subscribe messaging model allows multiple topic subscribers to receive
the same message. JMS retains the message until all topic subscribers have received
it. The Publish & Subscribe messaging model supports durable subscribers, allowing
you to assign a name to a topic subscriber and associate it with a user or application.
Subscribers may register interest in receiving messages on a particular message topic.
In this model, neither the publisher nor the subscriber knows about each other.
By using Java, JMS provides a way of separating the application from the transport
layer of providing data. The same Java classes can be used to communicate with
different JMS providers by using the JNDI information for the desired provider.
The classes first use a connection factory to connect to the queue or topic, and then
populate and send or publish the messages. On the receiving side, the clients then
receive or subscribe to the messages.