The Java Runtime Environment (JRE) is the minimum standard Java platform for running
applications written in the Java programming language. It contains the Java Virtual Machine, Java
core classes, and supporting files. The JRE does not contain any of the development tools (such
as appletviewer or javac) or classes that pertain only to a development environment.
The JRE for Win 32 platforms is bundled with its own installer program. The availability of an
easily installable JRE adds flexibility to the ways in which software suppliers can deliver software
to their customers. Vendors of applications have the option of not bundling a copy of the JRE
with their software. End-users can download and install the Windows JRE themselves. Once a
user has installed the JRE, it can be used to run any number of applications written in the Java
programming language.
JTS
The standard Java transaction management interfaces are
defined in two separate standard extensions: the Java
Transaction Service (JTS) and the Java Transaction API
(JTA).
Java Transaction Service defines a low-level
transaction management specification intended for
vendors who provide the transaction system
infrastructure required to support application run time
environment.
Java Transaction API (JTA) defines a high-level
transaction management specification intended for
resource managers and transactional applications in
distributed transaction systems.
The revised Java Transaction Service (JTS), which now
consists of
A standard Java mapping of the OMG Object
Transaction Service (OTS). The Java mapping of the
OTS interfaces is defined in the packages
org.omg.CosTransactions and
org.omg.CosTSPortability.
Java mapping of the OMG Object Transaction Service (OTS)
The packages org.omg.CosTransactions and
org.omg.CosTSPortability define the Java mapping of the
Object Management Group's Transaction Service (OTS)
1.1 interfaces using the standard IDL/Java language mapping.
This API is intended for a CORBA application or system
programmer using the Java language. The API provides the
programmer the following functionality:
Transaction demarcation interface.
Transactional resource manager interface.
Transactional object synchronization interface.
Transaction propagation interface.
JTAPI
The Java Telephony API (JTAPI) is a portable, object-oriented application
programming interface for Java-based computer-telephony applications.
JTAPI serves a broad audience, from call center application developers to
web page designers.
The Java Telephony API is, in fact, a set of API's. The "core" API
provides the basic call model and rudimentary telephony features,
such as placing telephone calls and answering telephone calls.
patchlet
An update module for modifying the Java classes in a deployed device. This requires
reprogrammable non-volatile memory such as Flash ROM or battery-backed up RAM.
Steps
Downloading a Patchlet. Shutdown VM. Replace Patchlet. Start VM.
Now running the updated code Other Available Formats
PersonalJava
PersonalJava is a new Java Application Environment for
network-connectable applications on personal consumer devices for
home, office, and mobile use.
Like Java, PersonalJava consists of core and standard extension
(optional) APIs. It has been designed specifically for resource limited
environments, with the addition of specific features required by
consumer applications.
PersonalJava includes a feature-level subset of Java, so any
PersonalJava-based application is also upward-compatible to Java.
Why PersonalJava?
With the advent of the World Wide Web, consumer devices need to
be web-connectable, meaning they must support the download and
execution of applets and applications. In addition, many of these
devices will in themselves become development platforms as more
content is brought to the consumer. PersonalJava is designed to
reduce the overall cost of porting to multiple consumer device
platforms, to create a stable resource for downloaded applets and
applications to execute upon, and to enable developers to easily write
total solutions--including back-end server and device-resident
applications --using one development kit, the JDK.
PureJava
Basically, a pure Java program is one that relies only on the documented
and specified Java platform. That means no native methods, no external
dependencies aside from the Java Core APIs, and some other requirements
that are detailed in the developer's 100% Pure Java Cookbookon our Web
site. The certification process verifies that the code is in fact 100% Pure
Java.
It is the only way to
guarantee to both the developer and the end-user that the program really
will run on multiple platforms.
scriptlet
Any valid Java code inside a < % and a % >
servlet, Java Servlets
What Are Servlets? Server side applets but faceless
Dynamically extend server functionality and extensible Java
API that defines the interface to a Servlet Return to Tracks
JDK 1.2 Contents Java Servlet API enables the
creation of Java Servlets. For example, servlets can extend a
web server's functionality in the same way that CGI scripts do.
Servlets, however, are much less resource intensive than CGI
scripts. Because servlets are written entirely in Java, again
unlike CGI scripts, they are cross-platform as well.
Servlet API
Servlets are protocol - and platform-independent server side components,
written in Java. They basically replace cumbersome CGI script.
Because the servlets are written in Java they are more flexible and stable than CGI
scripts and give developers an interface that can be used on any platform
without additional porting. As a result, servlets enable users to dynamically
extend the functionality of their web server on the fly.
Servlets offer limitless opportunities to create and deploy a wide range of
new, customized services and applications. For example, servlets can be
used to look up records in a database in order to generate a web page on
the fly. System administrators to manage network resources can upload
administration servlets on demand. For instance, log servlets can monitor
visitor activity at a web site, or proxy servlets are useful for traffic
characterization and filtering.
Servlets are also suitable for load balancing in multi-tier applications that
are a key requirement for building next-generation enterprise-class business
systems. In a three-tier system, for example, the first tier could be a
Java-enabled browser on a thin client, with the second tier consisting of
servlets that encapsulate specific business rules and logic and the third tier
comprised of legacy database information.
Signed applets ( Trusted applets )
Signed applets are delivered as cryptographically signed JAR files.
If an applet is signed with a trusted cryptographic key
then the applet will be
allowed to run fully trusted and will be able to access a user's
local disk files, open arbitrary network connections, call native
methods, etc.obj file, you should use the javakey -cs command
to create a trusted identity and the javakey -ic command to
import a certificate.
SQLJ
SQL statements include queries (SELECT), data-manipulation statements (INSERT,
UPDATE, DELETE), and others that operate on data stored in tables in relational
databases. SQLJ is a convention for embedding those SQL statements in Java, in a
way that allows programing tools to perform translation-time (compile-time) analysis of
SQL in Java, for syntax checking of SQL statements, for type checking to determine
that the data exchanged between Java and SQL have compatible types and proper
type conversions, and for schema checking to assure that the SQL constructs are
well-formed and valid in the database schema where they will be executed. Embedded
SQL statements are said to be "static" because they are textually evident in the Java
program, and can therefore be compiled (the usual term is "pre-compiled") when the
containing Java program is compiled. We propose SQLJ as a convenient and efficient
standard for tightly integrated Java/SQL programs.
