MUHAMMAD AHMAD

ROLL NO 208
=======================================================
Service Technologies:
The J2EE platform service technologies allow applications to access a wide range
of services in a uniform manner. This section describes technologies that provide access
to databases, transactions, naming and directory services, and enterprise information
systems.

JDBC API:
The JDBC API provides database-independent connectivity between the
J2EE platform and a wide range of tabular data sources. JDBC technology allows
an Application Component Provider to:
Perform connection and authentication to a database server
Manage transactions
Move SQL statements to a database engine for preprocessing and
execution
Execute stored procedures
Inspect and modify the results from Select statements
The J2EE platform requires both the JDBC 2.0 Core API (included in the
J2SE platform), and the JDBC 2.0 Extension API, which provides row sets,
connection naming via JNDI, connection pooling, and distributed transaction
support. The connection pooling and distributed transaction features are intended
for use by JDBC drivers to coordinate with a J2EE server.

Java Transaction API and Service:

The Java Transaction API (JTA) allows applications to access transactions in
a manner that is independent of specific implementations. JTA specifies standard
Java interfaces between a transaction manager and the parties involved in a
distributed transaction system: the transactional application, the J2EE server, and
the manager that controls access to the shared resources affected by the
transactions.

Java Naming and Directory Interface:

The Java Naming and Directory Interface (JNDI) API provides naming and
directory functionality. It provides applications with methods for performing
standard directory operations, such as associating attributes with objects and
searching for objects using their attributes. Using JNDI, an application can store
and retrieve any type of named Java object.

 Connector Architecture:
A future version of the J2EE platform will support the Connector
architecture, a standard API for connecting the J2EE platform to enterprise
information systems, such as enterprise resource planning, mainframe
transaction processing, and database systems. The architecture defines a set of
scalable, secure, and transactional mechanisms that describe the integration of
enterprise information systems with an EJB server and enterprise applications

Communication Technologies:
Communication technologies provide mechanisms for communication between
clients and servers and between collaborating objects hosted by different servers.
The J2EE specification requires support for the following types of communication
technologies:
Internet protocols
Remote method invocation protocols
Object Management Group protocols
Messaging technologies
Data formats

Internet Protocols:
Internet protocols define the standards by which the different pieces of
the J2EE platform communicate with each other and with remote entities. The
J2EE platform supports the following Internet protocols:
TCP/IPTransport Control Protocol over Internet Protocol. These two
protocols provide for the reliable delivery of streams of data from one host to
another. Internet Protocol (IP), the basic protocol of the Internet, enables the
unreliable delivery of individual packets from one host to another. IP makes no
guarantees about whether or not the packet will be delivered, how long it will
take, or if multiple packets will arrive in the order they were sent. The Transport
Control Protocol (TCP) adds the notions of connection and reliability.
HTTP 1.0Hypertext Transfer Protocol. The Internet protocol used to
fetch hypertext objects from remote hosts. HTTP messages consist of requests
from client to server and responses from server to client.
SSL 3.0Secure Socket Layer. A security protocol that provides privacy
over the Internet. The protocol allows client-server applications to communicate
in a way that cannot be eavesdropped or tampered with. Servers are always
authenticated and clients are optionally authenticated.

 Remote Method Invocation Protocols:

Remote Method Invocation (RMI) is a set of APIs that allow developers to
build distributed applications in the Java programming language. RMI uses Java
language interfaces to define remote objects and a combination of Java
serialization technology and the Java Remote Method Protocol (JRMP) to turn
local method invocations into remote method invocations. The J2EE platform
supports the JRMP protocol, the transport mechanism for communication
between objects in the Java language in different address spaces.

Object Management Group Protocols:

Object Management Group (OMG) protocols allow objects hosted by the
J2EE platform to access remote objects developed using the OMGs Common
Object Request Broker Architecture (CORBA) technologies and vice versa. CORBA
objects are defined using the Interface Definition Language (IDL).

Java IDL:
Java IDL allows Java clients to invoke operations on CORBA objects that
have been defined using IDL and implemented in any language with a CORBA
mapping. Java IDL is part of the J2SE platform. It consists of a CORBA API and
ORB. An Application Component Provider uses the idlj IDL compiler to generate a
Java client stub for a CORBA object defined in IDL. The Java client is linked with
the stub and uses the CORBA API to access the CORBA object.
RMI-IIOP:
RMI-IIOP is an implementation of the RMI API over IIOP. RMI-IIOP
allows Application Component Providers to write remote interfaces in the Java
programming language. The remote interface can be converted to IDL and
implemented in any other language that is supported by an OMG mapping and an
ORB for that language. Clients and servers can be written in any language using
IDL derived from the RMI interfaces.

Messaging Technologies:
Messaging technologies provide a way to asynchronously send and receive
messages. The Java Message Service provides an interface for handling
asynchronous requests, reports, or events that are consumed by enterprise
applications. JMS messages are used to coordinate these applications. The
JavaMail API provides an interface for sending and receiving messages intended
for users.

 Java Message Service:

The Java Message Service (JMS) is an API for using enterprise messaging
systems such as IBM MQ Series and TIBCO Rendezvous. JMS messages contain
well defined information that describe specific business actions. Through the
exchange of these messages, applications track the progress of the enterprise.
The JMS supports both point-to-point and publish-subscribe styles of messaging.
JavaMail:
The JavaMailTM API provides a set of abstract classes and interfaces that comprise
an electronic mail system. The abstract classes and interfaces support many
different implementations of message stores, formats, and transports. Many
simple applications will only need to interact with the messaging system through
these base classes and interfaces.

Data Formats:
Data formats define the types of data that can be exchanged between
components.
The J2EE platform requires support for the following data formats:
HTML 3.2: The markup language used to define hypertext documents
accessible over the Internet. HTML enables the embedding of images, sounds,
video streams, form fields, references to other HTML documents and basic text
formatting.
Image files: The J2EE platform supports two formats for image files: GIF
(Graphics Interchange Format), a protocol for the online transmission and
interchange of raster graphic data, and JPEG (Joint Photographic Experts
Group), a standard for compressing gray-scale or color still images.
JAR file: A platform-independent file format that permits many files to
be aggregated into one file.
Class file: The format of a compiled Java file as specified in the Java
Virtual Machine specification. Each class file contains one Java language type
either a class or an interfaceand consists of a stream of 8-bit bytes.
XML: A text-based markup language that allows you to define the
markup needed to identify the data and text in XML documents. XML will be
supported in a future version of the J2EE specification. As with HTML, you
identify data using tags.