| # JavaTM 2 SDK, Standard Edition, version 1.3 Summary of New Features and Enhancements | Contents

> The new features of version 1.3 of the Java 2 SDK, Standard Edition are listed below. The full list of features, including features brought forward from previous versions of the SDK, is available at Guide to Features.

>   Java 2 Platform
>   - Java Naming and Directory InterfaceTM (JNDI)
>   - Remote Method Invocation (RMI)
>   - RMI/IIOP
>   - CORBA ORB
>   - Java IDL compiler, idlj
>   - Drag and Drop Enhancements
>   - Java Sound
>   - Applet Deployment Enhancements
>   - Java 2DTM Enhancements
>   - Swing Enhancements
>   - AWT Enhancements
>   - Security Enhancements
>   - Networking Enhancements
>   - Reflection Enhancements
>   - Object Serialization Enhancements
>   - Accessibility Enhancements
>   - Input Method Framework
>   - Collections Framework Enhancements
>   - Enhancements to java.math
>   - Enhancements in java.lang and java.util.*
>   - Enhancements to the Extension Mechanism and Jar Files
>   - Support for Motif 2.1
>   Performance
>   - Performance
>   Tool Support
>   - Java Platform Debugger Architecture (JPDA)
>   Tools
>   - Tools and Utilities

## Java 2 Platform

- Java Naming and Directory InterfaceTM (JNDI)
  - The Java Naming and Directory Interface (JNDI), formerly available only as a standard extension, has been added to the Java 2 Platform. JNDI provides Java platform-based applications with a unified interface to multiple naming and directory services in the enterprise. JNDI includes support for event notification and LDAP v3 extensions and controls, as well as class libraries and service providers for the Lightweight Directory Access Protocol(LDAP), the CORBA Object Services (COS) Naming Service, and the Java Remote Method Invocation (RMI) Registry.

- Remote Method Invocation (RMI)
  - RMI Release Notes
  - `java.rmi.server.RMIClassLoader` has a new method, `getClassLoader`.
  - Serialization enhancements notable for RMI:
    - Strings longer than 64K can now be serialized.
    - Serialization performance enhancements yeild up to 20% faster writes during serialization and reads during deserialization.
    - Improved exception reporting now reports the actual class or interface that cannot be found during deserialization, rather than the higher-level class that was being deserialized (such as the RMI stub class).
  - `rmic` has several new options and now defaults to using '`-d .`' behavior if no other destination directory is specified using the `-d` option.
  - `rmid` now requires a security policy file.

- RMI over IIOP
  - RMI programmers can now use CORBA's IIOP communications protocol to communicate with clients of any type, whether written entirely in the Java programming language or made up of components written in other CORBA-compliant languages. RMI over IIOP enables the programming of CORBA servers and applications via the `rmi` API. The RMI API utilizes the Java CORBA ORB and IIOP, so you can write all of your code in Java, and use the `rmic` compiler to generate the code necessary for connecting your applications via the Internet InterORB Protocol (IIOP) to others written in any CORBA-compliant language.

- CORBA ORB
  - A CORBA 2.3.1-compliant Object Request Broker (ORB) is part of the Java 2 Platform, Standard Edition, v1.3. The ORB is a runtime component that is a fully-compliant Java ORB for distributed computing using IIOP communication. This ORB can interoperate with any CORBA 2.3.1-compliant ORB. This eliminates the requirement for licensing and distributing third-party Java ORBs.
  - The Java CORBA ORB supports both the RMI and IDL programming models, both of which use the underlying IIOP wire-level protocol for communication.

- Java IDL compiler, idlj
  - J2SE v.1.3 includes a new version of the IDL-to-Java compiler, `idlj`.
  - The `idlj` compiler is 100% pure Java, so no preprocessor is necessary.
  - The `idlj` compiler has more options than `idltojava`. Link to `idlj - The IDL-to-Java compiler (RMI-IIOP version)` for a list of options.
  - The `idlj` compiler supports mapping for interface, as described in the OMG IDL to Java Language Mapping Specification, 1.12, Mapping for Interface. This change means that a non-abstract IDL interface is mapped to two public Java interfaces: a signature interface and an operations interface.
  - The `idlj` compiler supports Java mapping for IDL value types, as described in the OMG IDL to Java Language Mapping Specification, 1.13, Mapping for Value Types.

- Drag and Drop Enhancements
  Two new methods in class java.awt.datatransfer.DataFlavor enhance Drag and Drop operations in this release: `
  - getReaderForText(Transferable)
  - selectBestTextFlavor(DataFlavor[])
  `

- Java Sound
  - Sound engine
  - Support for audio in applications as well as applets.
  - New API for capturing, processing, and playing back audio and MIDI (Musical Instrument Digital Interface) data.
  - Audio file formats: AIFF, AU and WAV
  - Music file formats: MIDI Type 0, MIDI Type 1, and Rich Music Format (RMF)
  - Sound formats: 8- and 16-bit audio data, in mono and stereo, with sample rates from 8 kHz to 48 kHz
  - Linear, a-law, and mu-law encoded data in any of the supported audio file formats
  - MIDI wavetable synthesis and sequencing in software, and access to hardware MIDI devices
  - An all-software mixer that can mix and render up to 64 total channels of digital audio and synthesized MIDI music

- Applet Deployment Enhancements
  - Improved Applet Caching Control to ensure critical functions remain in fast-loading cache for improved performance.
  - Fast Loading of Applet Support Classes Jar files containing support classes for applets can now be placed in the Java 2 Runtime Environment/Plug-in `lib/applet/` directory. This reduces startup time for large applets by allowing applet classes to be pre-loaded from the local file system by the applet class loader, providing the same protections as if they had been downloaded over the net.
  - Automatic Installation of Extensions gets the right version of the extension installed on the end-user machine, without requiring it to be downloaded repeatedly each time an applet is loaded. Hence, faster start-up of applets.
  - Jar Indexing allows developers to break functionality into different Jar files and ensure that only those that are needed for a given run of the applet are actually downloaded.

- Java 2DTM
  - Multiple Monitor Support is enabled by the new `Frame(GraphicsConfiguration)` and `Window(Window, GraphicsConfiguration)` constructors and `getBounds` method.
  - Portable Network Graphics format support is supported by the Java 2D API.
  - Dynamic font loading is provided by new API in class `Font`.
  - Customized stroke offsets are enabled by new API in class `java.awt.BasicStroke`.
  - New ICC Profile tags have been added to bring the Java 2D API into compliance with the latest ICC specification.
  - Improved paragraph balancing and hyphenation is enabled by the `TextMeasurer` class.
  - Access to a ColorModel's transfer type is possible through the new `getTransferType` method.
  - Validity checking of Palette Entries is enabled by a new `IndexColorModel` constructor and the new `isValid(int)` and `getValidPixels` methods.

- Swing Enhancements
  - Many enhancements have been made to Swing, including additions to the API and performance enhancements to the SDK's implementation. See Swing Changes and New Features for descriptions of enhancements added to Swing in this release.

- AWT Enhancements
  - See AWT Enhancements for more details on the changes summarized here.
  - Multiple Monitor Support is enabled by the new `Frame(GraphicsConfiguration)` and `Window(Window, GraphicsConfiguration)` constructors and `getBounds` method.
  - New class `java.awt.Robot` has been added to the Java 2 Platform. `Robot` is designed to make it possible to automate testing of AWT components.
  - New event masks for PaintEvents and Invocation events have been added to class `AWTEvent`.
  - Paint coalescing has been implemented which will enhancement painting performance.
  - The printing API has been enhanced by the addition of two new classes: `java.awt.JobAttributes` and `java.awt.PageAttributes`. These classes control attributes of print jobs and printed pages, respectively, and are used by new form of method `Toolkit.getPrintJob`.
  - A new event type for tracking changes to component hierarchies has been introduced. The new event type notifies listeners of various changes in a component's hierarchy, such as ancestor moves, ancestor deletions, and more.
  - New C headers have been added to the SDK as a convenient, standard way to allow native code to access AWT components.

- Security
  - See Security Enhancements for a fuller list of changes in this release.
  - trustProxy property is now true by default. See the Security Enhancements document for more details.
  - A new signature verification method, `initVerify(Certificate)` has been added to `java.security.Signature`, and this new method is FIPS 140-1 compliant. FIPS 140-1 requires a public key to be passed as a certificate, which is accomplished through the addition of `initVerify(Certificate)`.
  - New `DomainCombiner` interface provides a means to dynamically update the ProtectionDomains associated with the current `AccessControlContext`.
  - New class `java.security.spec.RSAKeyGenParameterSpec` makes it possible to specify both the size of the (to-be-generated) public modulus and the value of the public exponent when generating an RSA keypair.
  - Two new methods have been added to `java.security.Security`, making it possible to select service providers based on the capabilities that they offer:
    `
    - getProviders(Map)
    - getProviders(String)
    `
  - Method `java.security.KeyPairGenerator.generateKeyPair()` has been restored to ensure backwards compatibility with JDK 1.1.x.
  - The new -provider command line option has been added to keytool and jarsigner which allows the user to specify a particular service provider not listed in the security properties file.
  - Jarsigner can now verify Netscape-signed jar files.
  - The handling of X.509 certificates has been updated to include support for multiple Attribute/Value Assertions (AVA's) within a Relative Distinguished Name (RDN).
  - The RSAKey interface has been added to allow a generic examination of keys before examining them in detail.
  - Enhancements have been made to support all X.520 attributes that are either mandated or recommended by PKIX RFC 2459.

- Networking
  The following enhancements have been made to networking. See also Networking Enhancements for more details.
  - TCP half-close sockets are now supported with the additions of methods `shutdownInput()` and `shutdownOutput()` to classes `java.net.Socket` and `java.net.SocketImpl`
  - Java sockets now support the keepalive option with the addition of methods `setKeepAlive(boolean on)` and `boolean getKeepAlive()` in `java.net.Socket`.
  - New interface `java.net.DatagramSocketImplFactory`, which is used by `DatagramSocket` to create actual socket implementations. This addition makes `DatagramSocket` consistent with the other socket types, by allowing the user to set the `DatagramSocketImplFactory` through a public API.
  - Improved system flexibility through changes in `java.net.URL, java.net.URLConnection`, and `java.net.ContentHandler`. The URL parsing now better matches the rules specified in RFC 2396. Some new methods have been added to obtain the components of a parsed URL.
  - Added HTTP 1.1 client-side support.

- Reflection Enhancements
  - A new API for dynamic proxy classes has been added to the Java 2 Platform. A dynamic proxy class is a class that implements a list of interfaces specified at runtime such that a method invocation through one of the interfaces on an instance of the class will be encoded and dispatched to another object through a uniform interface. Thus, a dynamic proxy class can be used to create a type-safe proxy object for a list of interfaces without requiring pre-generation of the proxy class, such as with compile time tools. Dynamic proxy classes are useful to applications that need to provide type-safe reflective dispatch of invocations to objects that present interface APIs. For example, an application can use a dynamic proxy class to create an object that implements multiple arbitrary event listener interfaces -- interfaces that extend `java.util.EventListener` -- to process a variety of events of different types in a uniform fashion, such as by logging all such events to a file.

- Object Serialization
  Many enhancements to serialization's functionality and performance have been made in version 1.3 of the Java 2 Platform. See Object Serialization Enhancements for details.
  - Strings longer than 64K can now be serialized.
  - Serialization performance enhancements yeild up to 20% faster writes during serialization and reads during deserialization.
  - Improved exception reporting now reports the actual class or interface that cannot be found during deserialization, rather than the higher-level class that was being deserialized (such as the RMI stub class).
  - New methods for enhanced functionality.
    - java.io.ObjectOutputStream.writeClassDescriptor
    - java.io.ObjectOutputStream.annotateProxyClass
    - java.io.ObjectInputStream.readClassDescriptor
    - java.io.ObjectInputStream.resolveProxyClass

- Accessibility
  - Several new classes and interfaces have been added to the accessibility API of the Java 2 Platform.
    - AccessibleIcon provides information about icons and is implemented by Swing icons.
    - AccessibleRelation and AccessibleRelationSet provide information about the ways user interface objects are related to each other.
    - AccessibleTable provides information about tables, and is implemented by Swing's JTable.AccessibleJTable class.
    - AccessibleTableModelChange is a helper class which encapsulates a change to the model of a table.
  - Accessibility support has been included in both AWT Component and AWT Container, making creation of accessible custom components easier. This also means that accessibility support is not only present in Swing components, it is also part of all lightweight AWT components.
  - Class java.applet.Applet now implements the Accessible interface.
  - The AWT's new Robot class provides a way to insert keystrokes and mouse events at the system level. This feature enhances accessibility because it allows the physical on-screen mouse cursor to be moved. This enables screen magnification software for native environments to recognize and respond to mouse movements that could not previously be identified by assistive technologies outside of the virtual machine.

- Input Method Framework
  - An Input Method Engine Service Provider Interface has been added to the platform. The new SPI enables the development of input method engines in the Java programming language that can be used with any Java runtime environment.
  - Below-the-spot text input has been implemented. Below-the-spot text input, popular in Chinese-speaking countries, uses a separate composition window that is positioned automatically to be near the point where the text is to be inserted after being committed.

- Collections Framework Enhancements
  - Added singletonList and singletonMap. Previously, there was a convenience implementation for singleton Set, but no corresponding implementation for List and Map. Both of these implementations proved desirable in practice.
  - Added EMPTY_MAP. Previously, there were constant convenience implementations for the empty Set and List, but no corresponding implementation for Map.
  - Added Map constructor for WeakHashMap. The Map interface dictates that most Map implementations should have a "copy constructor" that takes a Map argument. WeakHashMap lacked such a constructor in the 1.2 release.

- Enhancements to `java.math`
  - The `BigDecimal(String)` constructor has been enhanced to allow signed strings (for example, `"+2.71828"`) and exponential notation (for example, `"1.23E-23"`) as input.
  - Class `java.math.BigInteger` has been reimplemented in pure Java programming-language code. Previously, `BigInteger`'s implementation was based on an underlying C library. The new implementation performs all standard operations much faster than the old implementation. The speed-up realized in the new implementation can be as much as 5x or more, depending on the operation being performed and the length of the operands.

- Enhancements in java.lang and java.util.*
  - Package `java.lang` now has both a `Math` class and a `StrictMath` class. New class `StrictMath` has the same API as class `Math`, but is defined to return bit-for-bit reproducible results for numeric operations in all implementations. This is in contrast to class `Math` which is not defined to return bit-for-bit same results across implementations. Implementations of class `Math` can vary within specified constraints to allow flexibility for better performance.
  - A new Timer API has been added to the Java 2 Platform to support animations, human interaction timeouts, on-screen clocks and calendars, work-scheduling routines, reminder facilities, and more.
    - `java.util.Timer`
    - `java.util.TimerTask`
    `Countdown.java` is a simple demo application that uses the new Timer API.
  - An API for virtual machine shutdown hooks has been added to class `java.lang.Runtime` that provides a simple, portable interface to the underlying operating system's process-shutdown notification so that an application written in the Java programming language can initiate shutdown actions such as closing down network connections, saving session state, and deleting temporary files.
  - New "delete-on-close" mode for opening Zip and Jar files has been added so that long-running server applications can delete no-longer-needed JarFile objects and data to keep disk space free.

- Enhancements to the Extension Mechanism and Jar Files
  - Automatic Installation of Extensions gets the right version of the extension installed on the end-user machine, without requiring it to be downloaded repeatedly each time an applet is loaded. Hence, faster start-up of applets.
  - Jar Indexing allows developers to break functionality into different Jar files and ensure that only those that are needed for a given run of the applet are actually downloaded.

- Support for Motif 2.1
  J2SE 1.3 uses Motif 2.1 (on the Solaris 7 and Solaris 8 operating environments), as distinguished from Motif 1.2 (which is still used on the Solaris 2.6 operating environment). Since 2.1 is the supported version of Motif going forward, switching to 2.1 allows the Java 2 platform to take advantage of future features and bug fixes in Motif.

  Motif 2.1 is compatible in both functionality and performance to Motif 1.2, except that it adds two features that might be of use for the Java 2 platform:

  - Motif 2.1 is multi-thread safe. Applications implemented partly in native code that use Motif directly through the `jawt` interface or the `DrawingSurface` interface can benefit from this feature. (Pure Java applications are already MT-safe.)
  - Motif 2.1 includes new Complex Text Layout (CTL) software for advanced locale support.

## Performance

- Performance
  - Many enhancements have been made to improve the performance of the Java 2 SDK and Java 2 Runtime Environment. These changes include the addition of the Java HotSpotTM Client Virtual Machine. The Solaris and Linux versions of the Java 2 SDK and Java 2 Runtime Environment also contain the Java HotSpot Server VM. Both the Client and Server VMs contain state-of-the-art Java HotSpot technology. The Client VM is tuned to maximize performance on client systems, improving performance in areas of startup time and memory footprint. The Server VM is tuned to maximize performance of program execution speed and is aimed at server applications that are less concerned with startup and memory footprint.

    The Java HotSpot Server VM is available for Win32 platforms as a separate download. See the Java HotSpot web site to obtain the Win32 Java HotSpot Server VM v2.0.

## Tool Support

- Java Platform Debugger Architecture
  - The Java Platform Debugger Architecture (JPDA) consists of three interfaces designed for use by debuggers in development environments for desktop systems. The Java Virtual Machine Debug Interface defines the services a VM must provide for debugging. The Java Debug Wire Protocol defines the format of information and requests transferred between the process being debugged and the debugger front end, which implements the Java Debug Interface. The Java Debug Interface defines information and requests at the user code level.

## Tools

- Tools and Utilities
  See Tool Changes for details on the changes summarized here.

  - The javac compiler has been completely re-implemented in version 1.3 of the Java 2 SDK for faster operation.

  - The jarsigner and keytool utilities have a new `-provider` option that can be used to specify the name of cryptographic service provider's master class file when the service provider is not listed in the security properties file.

  - The Jar tool now provides for the indexing of Jar files so that Jar-file contents can be accessed quickly and easily.

  - The functionality of the rmic tool (the Java RMI stub compiler) has been enhanced with several new options.

  - Version 1.3 of the Java 2 SDK uses the new high-performance virtual machine with Java HotSpotTM technology.

  - The version-related options of the Java application launcher have been modified to present information in terms of the values of system properties. .

  - The javaw launcher has been modified so that it will now display a window with error messages in the event that an application fails to launch.

Copyright © 1999, 2000 Sun Microsystems, Inc. All Rights Reserved. |