All Examples  All EJB Examples  This Group

Package examples.ejb.sequence.oracle

Enterprise JavaBean container-managed JDBC persistence
with automatic primary key generation
example packages and classes

Client application
Client (client application documentation and source)

Deployment
DeploymentDescriptor.txt
manifest

Interfaces
Oracle (remote interface documentation and source)
OracleHome (home interface documentation and source)
OraclePK (primary key interface documentation and source)
ProcessingErrorException (application-specific exception documentation and source)

Server (EJBean)
OracleBean (EJBean documentation and source)

about this example

This example is a package that demonstrates an Enterprise JavaBean. Please run this example before attempting to create your own Enterprise JavaBeans, as it will show you the different steps involved. The example is an entity EJBean called OracleBean. It is a modified version of the example EJBean of container-managed persistence, AccountBean.

The example demonstrates:

Using an entity bean that automatically generates its primary key by calling directly to a database using a connection pool and JDBC
Accessing properties in the Deployment Descriptor using a hashtable
Client application

Note that this application scales by caching a range of unique IDs as class attributes of the bean. The bean only goes to the database for an ID when the range is exhausted.

Performance could be further improved by using a stored procedure on the database to generate the primary key instead of the procedure contained in the EJBean.

A similar example is the JDBC sequence example, which uses a database table.

Client application

The Client application performs these steps:

Contacts the Oracle home ("OracleHome") through JNDI to find the EJBean
Creates two new accounts, showing their account IDs
Removes the new accounts before finishing

how to use this example

To get the most out of this example, first read through the source code files. Start with DeploymentDescriptor.txt to find the general structure of the EJBean, which classes are used for the different objects and interfaces, then look at Client.java to see how the application works.

In general, you'll need to adjust certain WebLogic Server properties to match your setup. You'll need to set up the persistent storage of the EJBean.

You'll use an Oracle database for the persistent storage of the entity EJBean. Note that the persistent storage is completly invisible to the client; the actual storage of the EJBean is handled automatically by the container and not by the EJBean.

However, the EJBean directly handles the generation of the primary key using an Oracle sequence.

This example is shipped "pre-built"; you can either run it as shipped, or build the example and run it to test that you are able to successfully build and run EJBeans.

These three sections cover what to do:

Build the example
Set your environment
Run the example

Build the example

Set up your development environment as described in Setting your development environment.

We provide separate build scripts for Windows NT and UNIX:

build.cmd for Windows NT
build.sh for UNIX

The "build" scripts build individual examples, such as this entry for Windows:

$ build sequence oracle

To build under Microsoft's JDK for Java, use

$ build sequence oracle -ms

These scripts will build the example and place the files in the correct locations:

Client files: in /myserver/clientclasses
EJBean: in /myserver/ejb_sequence_oracle.jar

Set your environment

Set the JDBC persistence. The Persistence in the deployment descriptor is already set to "jdbc" for database persistence.
With database persistence, each instance of an EJBean is written to a row in a table. The tables used (emp and the sequence used ejbSequence) must be created and exist in the database before the example is run. The table is a standard table included in the Oracle databases; you will have to create the sequence.
You'll need to:
1. Create the sequence in your database using an appropriate SQL statement such as
```
"create sequence ejbSequence start with 8001"
```
2. You'll need to setup a connection pool in the weblogic.properties file:
```
    weblogic.jdbc.connectionPool.oraclePool=\
         url=jdbc:weblogic:oracle,\
         driver=weblogic.jdbc.oci.Driver,\
         loginDelaySecs=1,\
         initialCapacity=2,\
         maxCapacity=10,\
         capacityIncrement=2,\
         props=user=SCOTT;password=TIGER;server=DEMO
```
  You'll need to adjust the server name to the name of your Oracle instance.
  If you need more information about how to use connection pools, read Using WebLogic JDBC: Using connection pools.
3. You'll need to add an access control list (ACL) for users of the pool:
```
  # Add an ACL for the connection pool:
  weblogic.allow.reserve.weblogic.jdbc.connectionPool.oraclePool=guest
```
Deploy the EJBean by adding its .ser file to the "weblogic.ejb.deploy" property in the weblogic.properties file. We provide a commented-out version that begins with "weblogic.ejb.deploy" that you can use. You'll need to adjust the property depending on which EJBeans you're building and are deploying, or if the location of the files differs from the installed location.
Note: If you're running under the Microsoft SDK for Java, you'll also need to add the path to the .jar to the CLASSPATH for your WebLogic Server.
Run the example
1. Start the WebLogic Server. You can check that the EJBean has been deployed correctly either by checking the server command line window, or by opening the Console and examining "EJB" under the "Distributed objects"; you should see oracle.OracleHome deployed, and can monitor its activity.
2. Run the client in a separate command line window. Set up your client as described in Setting your development environment, and then run the client by entering:
```
$ java examples.ejb.sequence.oracle.Client
```
  If you're not running the WebLogic Server with its default settings, you will have to run the client using:
```
$ java examples.ejb.sequence.oracle.Client "t3://WebLogicURL:Port"
```
  where:
  
  WebLogicURL
  Domain address of the WebLogic Server
  Port
  Port that is listening for connections (weblogic.system.ListenPort)
  
  Parameters are optional, but if any are supplied, they are interpreted in this order:
  
  Parameters:
  url - URL such as "t3://localhost:7001" of Server
  user - User name, default null
  password - User password, default null
3. If you're running the Client example, you should get output similar to this from the client application:
```
Beginning sequence.oracle.Client...

Employee No. 8001 created with an opening balance of $3000.0
Employee No. 8002 created with an opening balance of $6000.0

Removing employee records created...

End sequence.oracle.Client...
```
4. If you run this again, you'll see the next set of Oracles are properly numbered:
```
Beginning sequence.oracle.Client...

Employee No. 8003 created with an opening balance of $3000.0
Employee No. 8004 created with an opening balance of $6000.0

Removing employee records created...

End sequence.oracle.Client...
```
5. You can also try shutting down the server and restarting; the numbering will start at the beginning of the next range of IDs.
there's more
Read more about EJB in the Developers Guide, Using WebLogic Enterprise JavaBeans.
Read more about using the EJB Deployment Wizard in the Administrators Guide, Using the WebLogic EJB Deployment Wizard.
Copyright © 1997-1999 BEA WebXpress. All rights reserved.
Last updated 1/2/1999