J2EE Doc Bundle Home
|
JavaTM 2 SDK, Enterprise Edition Release Notes
Version 1.2.1
|
|
Revised: 5/3/00
Note: If you are reading this document from the download bundle, you may want to check the latest version of the Release Notes on our web site.
Contents
Read This Section First
If you are using the JavaTM 2 SDK, Enterprise Edition (J2EETM SDK) for the first time you should follow these steps:
1. If you've downloaded the software but haven't read the Installation Instructions, please do so.
2. Make sure that you've installed the software that the JavaTM 2 SDK, Enterprise Edition relies on. See the Required Software section of this document.
3. Configure the JavaTM 2 SDK, Enterprise Edition software. See the Configuration Guide .
4. Read the Getting Started document to learn how to build your first J2EE application.
What's New in This Release
This release includes usability enhancements, several bug fixes, and enhanced platform support.
The new redeployment feature of the Application Deployment Tool enables the iterative development of J2EE applications. For example, if you want to modify a .class file in an enterprise bean, all you have to do is edit the source code, recompile it, and click the redeploy button on the Application Deployment Tool. The tool automatically replaces the old .class file in the application with the new one. (Prior to this release, if you wanted to modify an enterprise bean, you had to step through several wizard screens to rebuild the bean.) If you want to change a deployment setting, such as a JNDI name, you simply edit the appropriate field in the inspector panel of the Application Deployment Tool and then click the redeploy button.
This release also contains important bug fixes:
- You can create a composite primary key for an entity bean with container-managed persistence. (A composite primary key is made up of multiple instance variables of an entity bean.)
- Enterprise bean classes, home interfaces, and remote interfaces can inherit methods from super classes and interfaces.
- JSPTM pages with character encodings other than ISO-8859_1 are supported on non-English locales.
- In JSP pages, nested compile-time includes are supported when relative URIs are used to specify the JSP pages.
Supported Platforms
- SolarisTM Operating Environment, version 2.6
- Windows NT, version 4.0
Supported Databases and JDBCTM Drivers
This release supports database drivers that conform to versions 1.0 and 2.0 of the JDBC API. We have performed tests with the following database servers:
- Oracle8 Server, version 8.05
- Microsoft SQL Server, versions 6.5, 7.0
- Cloudscape, version 3.0.4
For more information on JDBC technology, see the JDBC Data Access API web page. For a list of links to driver vendors, see the JDBC Technology Drivers page. After you've installed your driver, be sure to follow the instructions in the JDBC Drivers section of the Configuration Guide. If you are using the Cloudscape DBMS included in this release, you do not have configure its driver.
What This Release Includes
This release of the JavaTM 2 SDK, Enterprise Edition includes the following software.
Services
The J2EE server starts these services:
- EJBTM
- HTTP
- HTTP over SSL
- COS naming
- Authentication
Utilities
- Application Deployment Tool
The deploytool
utility packages J2EE components and deploys J2EE applications.
- Realm Tool
The realmtool
utility manages users for the J2EE server.
- Verifier
The verifier
utility validates J2EE component files.
- Packager
The packager
utility packages J2EE components.
- Cleanup Script
The cleanup
utility deletes all deployed J2EE applications.
Cloudscape DBMS
This release includes the Cloudscape 3.0.4 product, a relational DBMS written in the JavaTM programming language. Although the documented code examples were tested with a Cloudscape database, you may use any database that meets the requirements described in the section, Supported Databases and JDBCTM Drivers.
Java APIs for the Enterprise
- Enterprise JavaBeansTM API, version 1.1
- JavaTM Servlets, version 2.2
- JavaServer PagesTM technology, version 1.1
- JDBCTM Standard Extension, version 2.0
- Java Naming and Directory InterfaceTM API, version 1.2 (CosNaming SPI)
- RMI/IIOP
- JavaTM Transaction API, version 1.0
- JavaMailTM API, version 1.1
- JavaTM Messaging Service, version 1.0 (API only, no implementation)
Required Software
The JavaTM 2 SDK, Enterprise Edition requires you to install the Java 2 SDK, Standard Edition. You need the JavaTM 2 SDK, Standard Edition to run the J2EE server and to build and run J2EE applications. If your J2EE client resides on a different machine than the J2EE server, then you must install the Java TM 2 SDK, Standard Edition on both the server and client machines. (This rule applies only to Java application clients, not to Web browser clients.)
The JavaTM 2 SDK, Enterprise Edition (v 1.2.1) requires the versions of the JavaTM 2 SDK, Standard Edition listed in the following table:
TABLE 0-1 Required Versions of the JavaTM 2 SDK, Standard Edition (J2SE)
Operating System
|
J2SE Version
|
---|
SolarisTM Operating Environment
|
1.2.2_05 Production Release
|
Windows NT
|
1.2.2 or 1.3.0
|
Versions of the JavaTM 2 SDK, Standard Edition not listed in the preceding table have not been tested and are not supported.
Current Limitations
The purpose of this release is to introduce you to JavaTM 2 Enterprise Edition technology and to provide you with an opportunity to give us feedback on the work we've done so far. This release has several limitations.
Container-Managed Persistence
The implementation of container-managed persistence for entity beans does not provide a full set of features for mapping objects to relational databases:
- The entity bean class may be mapped to only one table in the database.
- A container-managed field may be mapped to only one column in the table.
- When the container loads the container-managed fields from the underlying database, it loads all of them. If the amount of data loaded is large, this approach may be inefficient because a business method may not need all of the container-managed fields.
- If the container-managed fields of multiple entity beans map to the same data item in a database, and if these beans are invoked in the same transaction, they may see an inconsistent view of the data item.
- The Application Deployment Tool generates SQL statements for the ejbCreate, ejbRemove, ejbLoad, and ejbStore methods. You may modify only the table and column names of these SQL statements. You may not modify the number and order of the question marks, which are place holders for the input parameters.
- You cannot call stored procedures in the generated SQL statements.
- In the "Create Table" SQL statement, you may change the SQL type of a table column provided that the SQL type is compatible with its corresponding instance variable.
- The table and column names in all of the SQL statements must be consistent.
- The generated SQL statements have been tested with these types of databases: Cloudscape, Oracle, and Microsoft SQL Server. You may need to edit the generated SQL statements to satisify the requirements of your database.
Database Calls During Result Set Iteration
With some JDBC drivers you cannot access the database while iterating through a result set. In the following code example, the stmt.executeUpdate
call will fail:
String query = "SELECT DEPTNO FROM DEPT . . .";
String update = "UPDATE EMPLOYEE . . .";
ResultSet rs = stmt.executeQuery(query);
while (rs.next()) {
String s = rs.getString("DEPTNO");
// The following statement will FAIL:
stmt.executeUpdate(update);
. . .
}
You may be able to get around this limitation by trying the following approaches:
1. Use a stored procedure that contains the same SQL calls.
2. Substitue the iteration with a single SQL statement that contains a subquery. Here's an example:
String update = "UPDATE EMPLOYEE
SET DEPTNO =
(SELECT DEPTNO FROM DEPT
WHERE LOC = `ATLANTA')
WHERE TITLE = `ENGINEER'";
3. Call another method that issues the second SQL statement. The method must use the RequiresNew transaction attribute. If you try this approach, you should be aware that the second SQL statement is executed in another transaction. Therefore, if the second transaction fails, you need to mark the first transaction for rollback.
Scalability and Memory Requirements
We have experienced intermittent problems when the J2EE server is run on a system with less than 128 MB of memory, or when a large number (> 16) of J2EE applications are deployed, or when a large number (in the thousands) of enterprise beans are instantiated. If you run out of memory, shutdown and restart the J2EE server.
Common Development Environment
Each developer should work with his or her own J2EE SDK installation. Multiple developers should not share the same J2EE server.
Redeployment
Release 1.2.1 of the Application Deployment Tool has a new redeployment feature (invoked from the Tools menu by the Update and Redeploy Application item). However, J2EE applications created with versions prior to 1.2.1 cannot be updated and redeployed with this feature.
RMI-IIOP and JAXP Standard Extensions
The J2EE SDK will not work with a J2SE installation which has the RMI-IIOP and JAXP standard extensions. The j2ee.jar file of the J2EE SDK already has the RMI-IIOP and JAXP classes. Workaround: Use a fresh J2SE installation without the standard extensions.
Known Bugs
TABLE 0-2 Known Bugs for this Release
Bug ID
|
Description
|
---|
.
|
A bug in the Java 2 SDK, Standard Edition 1.2.2 JIT causes Cloudscape to crash on the SolarisTM platform unless the environment contains the following: setenv JIT_ARGS="bco=off"
|
.
|
Before switching the J2EE server from non-recoverable to recoverable mode (for transactions), it is necessary to run the the cleanup script first.
|
.
|
J2EE clients and servers cannot interoperate with ORB products using the IIOP1.0 protocol (such as JavaIDL in Java 2 SDK v. 1.2). Workaround: Use an ORB product which supports the IIOP1.1 protocol (such as RMI-IIOP 1.0.1 standard extension).
|
.
|
The entire Java 2, SDK, Standard Edition is required to run the J2EE software. The standard edition contains a JRE (Java Runtime Environment). On some systems, when installing the standard edition the user has the option of installing a stand-alone JRE. This separate JRE cannot be used to run the J2EE software . In addition, a problem can occur if the root directory of the stand-alone JRE is set to the root directory where the standard edition was installed. In this case, everything will appear to run correctly until you deploy an enterprise bean: java.rmi.RemoteException: Error processing ejb jar:access denied: (java.io.FilePermission e:\testjava\lib ext read)
|
4330251
|
The server incorrectly resolves extension mapping. For example, when FooServlet is mapped to *.foo, it is invoked even when the request URI is /bar/foo/something. Workaround: Use the exact macthing wherever possible.
|
4333017
|
The web server of the J2EE SDK uses the operating system's default character encoding for converting bytes (received from HTML forms) to Java strings. If the browser sends strings in HTTP requests which are encoded using a different character encoding than the webserver, then the servlet or JSP code will see incorrect Java strings. (This error might occur if the HTML file received from the webserver has a different character encoding than the webserver.) Workaround: Obtain the bytes from the Java string in the servlet or JSP code and then create a new string from the bytes with the correct encoding.
|
4335409
|
Loading servlets at server startup may fail under certain conditions. The J2EE server can load a servlet and call a servlet's init method when the server is started, but the results are unpredictable. Such servlets include those that are registered in the web.xml file with a <load-on-startup> element.
|
4295863
|
In the New Enterprise Bean Wizard, if the wrong classes are chosen and you go back to correct them, sometimes the container-managed persistence attributes for the classes chosen do not appear correctly. Workaround: Either restart the wizard; or, change the type of the bean, move forward, move back, change the bean type back to entity, and re-choose the classes.
|
4313158
|
Applications with spaces in the application name cannot be deployed. Workaround: Remove the space from the application name.
|
4332122
|
While specifying the URI paths in the descriptor make sure that you specify the path from the context (paths starting with "/"). This will ensure that the correct page gets invoked no matter where you are within the application.
|
4333858
|
During the installation, if you don't have enough disk space available, this misleading error message may be displayed: "The download file appears to be corrupted." Workaround: Free up sufficient disk space.
|
4335414
|
For a component with a long list of contents, you may reach the limit on the length of a string allowable in the command-line arguments for the packager. Workaround: Package the helper classes into a library .jar file and add the .jar file to the application's .ear file.
|
Differences Between Tomcat and the J2EETM SDK
Tomcat is an implementation of the JavaServerTM Pages and JavaTM Servlet specifications. This version of the J2EE SDK includes Tomcat version 3.0 and some additional bug fixes, but it does not include any features added to Tomcat version 3.1. For more information about Tomcat, please see http://jakarta.apache.org/.
Copyright © 2000 Sun Microsystems, Inc.
All rights reserved.