Use the Learn about WebSphere applications section as a
starting point to study technologies used in and by applications deployed
on the application server.
WebSphere applications use the following kinds of technologies:
- Java specifications and other open standards for developing applications
- WebSphere programming model extensions to enhance application functionality
- Containers and services in the application server, used by deployed applications,
and which sometimes can be extended
The following diagram shows applications and their clients, and the application
server containers and services in a single application server installation.
The remainder of this topic introduces each technology, including the many Learn about WebSphere programming extensions (not shown).
Product architecture
and programming model, at a glance
Product subsystems |
WebSphere applications |
WebSphere applications |
Servers
- Application servers
- More server types
- Core groups
- Workload balancing
Environment
- Virtual hosts
- Variable settings
- Shared libraries
System administration
- Administrative clients
- Configuration files
- Domains (cells, nodes)
Performance
- Monitoring
- Tuning performance
Troubleshooting
- Diagnostic tools
- Support and self-help
The product subsystems are discussed in the Product architecture. For the most part, they do not depend on the type
of applications being deployed
|
Services
- Security
- Naming
- ORB
- Transactions
J2EE applications
- Web applications
- EJB applications
Clients
- Client applications
- Web clients
- Web services clients
- Administrative clients
Web services
- Web services and Service Oriented Architecture (SOA)
|
J2EE resources
- Data access resources
- Messaging resources
- Mail, URLs, and more
WebSphere extensions
- ActivitySessions
- Application profiling
- Asynchronous beans
- Dynamic caching
- Dynamic and EJB query
- Internationalization
- Object pools
- Scheduler
- Startup beans
- Work areas
|
J2EE application components
- Web applications
The diagram shows the Web container, the part of the application server
in which Web application components run. Web applications are comprised of
one or more related servlets, JavaServer Pages technology (JSP files), and
Hyper Text Markup Language (HTML) files that you can manage as a unit. Combined,
they perform a business logic function.
Servlets can support
dynamic Web page content, provide database access, serve multiple clients
at one time, and filter data.
JSP files enable the separation
of the HTML code from the business logic in Web pages. IBM extensions to the
JSP specification make it easy for HTML authors to add the power of Java technology
to Web pages, without being experts in Java programming.
An HTTP
session is a series of requests to a servlet, originating from the same
user at the same browser. Sessions allow applications running in a Web container
to keep track of individual users. For example, many Web applications allow
users to dynamically collect data as they move through the site, based on
a series of selections on pages they visit. Where the user goes next, or what
the site displays next, might depend on what the user has chosen previously
from the site. To maintain this data, the application stores it in a "session."
- EJB (Enterprise
JavaBeans) applications
The diagram shows the EJB container, which provides all of the runtime
services needed to administer enterprise beans. The container is an interface
between EJB components and the application server. It provides many low-level
services, including threading and transaction support. From an administrative
perspective, the container handles data access for the contained beans.
Enterprise
beans are Java components that typically implement the business logic
of J2EE applications, as well as accessing data.
Client applications and other types of clients
In
a client-server environment, clients communicate with applications running
on the server.
Client applications or
application clients generally
refers to clients implemented according to a particular set of Java specifications,
and which run in the client container of a J2EE-compliant application server.
Other clients in the WebSphere Application Server environment include clients
implemented as Web applications (
Web clients), clients of Web services
programs (
Web services clients), and clients of the product systems
administration (
administrative clients).
- Client applications
- The diagram shows a Java client running in the client container, which
is installed separately on the client machine. It enables the client to run
applications in an EJB-compatible J2EE environment. Depending on the source
of technical information, client applications might be called application
clients. This documentation tends to use the two terms synonymously
- Web clients
- The diagram shows a Web browser client making a request to the Web container
of the application server, by route of the HTTP server. A Web client or Web
browser client runs in a Web browser, and is comprised of Web application
components. See the Web applications section for Web client information.
- Web services
clients
- The diagram shows the Web services container, but does not depict a Web
services client. Web services clients are yet another kind of client that
might exist in your application serving environment. See the Web services
section for details about this kind of client.
- Administrative
clients
- The diagram shows the administrative interface (Admin UI) and a scripting
client accessing parts of the systems administration infrastructure. Although
the current discussion focuses on the technologies in the programming model,
administrative clients are mentioned here for completeness.
Web services
- Web services
- The diagram shows the Web services engine, part of the Web services support
in the application server runtime. Web services are self-contained, modular
applications that can be described, published, located, and invoked over a
network. They implement a services oriented architecture (SOA), which supports
the connecting or sharing of resources and data in a very flexible and standardized
manner. Services are described and organized to support their dynamic, automated
discovery and reuse.
Data access, messaging, and J2EE resources
- Data access
resources
- The diagram shows the application using the JCA container to access an
application database. Connection management for access to enterprise information
systems (EIS) in the application server is based on the J2EE Connector Architecture
(JCA) specification. The connection between the enterprise application and
the EIS is done through the use of EIS-provided resource adapters, which are
plugged into the application server. The architecture specifies the connection
management, transaction management, and security contracts between the application
server and EIS.
The Connection Manager in the application server pools
and manages connections. It is capable of managing connections obtained through
both resource adapters defined by the JCA specification and data sources defined
by the JDBC 2.0 Extensions specification.
JDBC resources (JDBC
providers and data sources) are a type of J2EE resource used by applications
to access data. Although data access is a broader subject than that of JDBC
resources, this documentation often groups data access under the heading of
J2EE resources for simplicity.
- Messaging
resources
- JMS support enables applications to exchange messages asynchronously with
other JMS clients by using JMS destinations (queues or topics). Applications
can use message-driven beans to automatically to automatically retrieve messages
from JMS destinations and JCA endpoints without explicitly polling for messages.
For
inbound non-JMS requests, message-driven beans use a Java Connector Architecture
(JCA) 1.5 resource adapter written for that purpose.
For JMS messaging,
message-driven beans can use a JCA-based messaging provider such as the default
messaging provider that is part of WebSphere Application Server. For compatibility
with WebSphere Application Server version 5, you can configure JMS message-driven
beans against a listener port.
- Mail, URLs,
and other J2EE resources
- J2EE resources are used by applications deployed on a J2EE-compliant application
server. They include:
- JDBC resources and other technology for data access (previously discussed)
- JMS resources and other messaging system support (previously discussed)
- JavaMail support, for applications to send Internet mail
- URLs, for describing logical locations
- Resource environment entries, for mapping logical names to physical names
Security
- Security
- The diagram shows the security server. The product provides security infrastructure
and mechanisms to protect sensitive J2EE resources and administrative resources
and to address enterprise end-to-end security requirements on authentication,
resource access control, data integrity, confidentiality, privacy, and secure
interoperability.
Additional services for use by applications
- Naming and
directory
- The name server provides a Java Naming and Directory Interface (JNDI)
name space. The naming service registers resources hosted on the application
server. It is built on top of a Common Object Request Broker Architecture
(CORBA) naming service (CosNaming).
JNDI provides the client-side access
to naming and presents the programming model used by application developers.
CosNaming provides the server-side implementation and is where its name space
is actually stored. JNDI essentially provides a client-side wrapper of the
name space stored in CosNaming, and interacts with the CosNaming server on
behalf of the client.
Clients of the application server use the naming
architecture to obtain references to objects related to those applications.
The objects are bound into a mostly hierarchical structure called the name
space. It consists of a set of name bindings, each one of which is a name
relative to a specific context and the object bound with that name. The name
space can be accessed and manipulated through a name server.
With this
product, you receive the following features:
- Distributed name space, for additional scalability
- Transient and persistent partitions, for binding at various scopes
- Federated name space structure across multiple servers
- Configured bindings for defining bindings bound by the system at server
startup
- Support for CORBA Interoperable Naming Service (INS) object URLs
- Object Request
Broker (ORB)
- The product uses an ORB to manage communication between client applications
and server applications, as well as among product components.
An ORB manages
the interaction between clients and servers, using IIOP. It enables clients
to make requests and receive requests from servers in a network distributed
environment.
The ORB provides a framework for clients to locate objects
in the network and call operations on those objects as though the remote objects
were located in the same running process as the client, providing location
transparency.
- Transactions
- Part of the application server is the transaction service. The product
provides advanced transactional capabilities to help application developers
avoid custom coding. It provides support for the many challenges related to
integrating existing software assets with a J2EE environment. These measures
include ActivitySessions (described below).
Applications running on the
server can use transactions to coordinate multiple updates to resources as
one unit of work such that all or none of the updates are made permanent.
Transactions are started and ended by applications or the container in which
the applications are deployed.
The application server is a transaction
manager that supports coordination of resource managers and participates in
distributed global transactions with other compliant transaction managers.
The
server can be configured to interact with databases, JMS queues, and JCA connectors
through their local transaction support when distributed transaction support
is not required.
WebSphere extensions
WebSphere extensions
are the programming model benefits you gain by purchasing WebSphere Application
Server products. They represent leading edge technology to enhance application
capability and performance, and make programming and deployment faster and
more productive. WebSphere extensions (and the corresponding application
services that support them in the application server runtime) can be considered
in three groups: Business Object Model extensions, Business Process Model
extensions, and extensions for producing Next Generation Applications.
Extensions
pertaining to the Business Object Model
Business object model extensions
operate with business objects, such as enterprise bean (EJB) applications.
- Application
profiling
- Application profiling is a WebSphere extension for defining strategies
to dynamically control concurrency, prefetch, and read-ahead.
Application
profiling and access intent provide a flexible method to fine-tune application
performance for enterprise beans without impacting source code. Different
enterprise beans, and even different methods in one enterprise bean, can have
their own intent to access resources. Profiling the components based on their
access intent increases performance in the application server runtime.
- Dynamic
query
- Dynamic query is a WebSphere programming extension for unprecedented application
flexibility. It lets you dynamically build and submit queries that select,
sort, join, and perform calculations on application data at runtime. Dynamic
Query service provides the ability to pass in and process EJB query language
queries at runtime, eliminating the need to hard-code required queries into
deployment descriptors during application development.
Dynamic query improves
enterprise beans by enabling the client to run custom queries on EJB components
during runtime. Until now, EJB lookups and field mappings were implemented
at development time and required further development or reassembly in order
to be changed.
- Dynamic
cache
- The dynamic cache service improves performance by caching the output of
servlets, commands, and JSP files. This service within the application server
intercepts calls to cacheable objects and either stores the output of the
object or serves the content of the object from the dynamic cache.
Because
J2EE applications have high read-write ratios and can tolerate small degrees
of latency in the currency of their data, the dynamic cache can create opportunity
for significant gains in server response time, throughput, and scalability.
Features
include cache replication among clusters, cache disk offload, Edge side include
caching, and external caching - the ability to control caches outside of the
application server, such as that of your Web server.
Extensions pertaining to the Business Process Model
Business
process model extensions provide process, workflow functionality, and services
for the application server. Use them in conjunction with business integration
capabilities.
- ActivitySessions
- ActivitySessions are a WebSphere extension for reducing the complexity
of dealing with commitment rules and limitations associated with one-phase
commit resources.
ActivitySessions provide the ability to extend the scope
of multiple local transactions, and to group them. This enables them to be
committed based on deployment criteria or through explicit program logic.
- Web services
- Web services are self-contained, modular applications that can be described,
published, located, and invoked over a network. They implement a services
oriented architecture (SOA), which supports the connecting or sharing of resources
and data in a very flexible and standardized manner. Services are described
and organized to support their dynamic, automated discovery and reuse.
Extensions for creating next generation applications
Next
generation applications can be used in applications that need the specific
extensions. These enable next generation development by leveraging the latest
innovations that build on today's J2EE standards. This provides greater control
over application development, execution, and performance than was ever possible
before.
- Asynchronous
beans
- Asynchronous beans offer performance enhancements for resource-intensive
tasks by enabling single tasks to run as multiple tasks. Asynchronous scheduling
facilities can also be used to process parallel processing requests in "batch
mode" at a designated time. The product provides full support for asynchronous
execution and invocation of threads and components within the application
server. The application server provides execution and security context for
the components, making them an integral part of the application.
- Startup
beans
- Startup beans allow the automatic execution of business logic when the
application server starts or stops. For example, they might be used to pre-fill
application-specific caches, initialize application-level connection pools,
or perform other application-specific initialization and termination procedures.
- Object
pools
- Object pools provide an effective means of improving application performance
at runtime, by allowing multiple instances of objects to be reused. This reuse
reduces the overhead associated with instantiating, initializing, and garbage-collecting
the objects. Creating an object pool allows an application to obtain an instance
of a Java object and return the instance to the pool when it has finished
using it.
- Internationalization
- The internationalization service is a WebSphere extension for improving
developer productivity. It allows you to automatically recognize the time
zone and location information of the calling client, so that your application
can act appropriately. The technology enables you to deliver each user, around
the world, the right date and time information, the appropriate currencies
and languages, and the correct date and decimal formats.
- Scheduler
- The scheduler service is a WebSphere programming extension responsible
for starting actions at specific times or intervals. It helps minimize IT
costs and increase application speed and responsiveness by maximizing utilization
of existing computing resources. The scheduler service provides the ability
to process workloads using parallel processing, set specific transactions
as high priority, and schedule less time-sensitive tasks to process during
low traffic off-hours.
- Work areas
- Work areas are a WebSphere extension for improving developer productivity.
Work areas provide a capability much like that of "global variables." They
provide a solution for passing and propagating contextual information between
application components.
Work areas enable efficient sharing of information
across a distributed application. For example, you might want to add profile
information as each customer enters your application. By placing this information
in a work area, it will be available throughout your application, eliminating
the need to hand-code a solution or to read and write information to a database.