2.2. More Complex Examples

2.2.1. Other JOnAS Examples

The following examples are located under $JONAS_ROOT/examples/src:

• The eb example ($JONAS_ROOT/examples/src/eb/) uses Entity beans. (See Section 2.2.2 An Example With Database Access.)

  The two beans share the same interface (Account): one uses bean-managed persistence (explicit persistence), the other uses container-managed persistence (implicit persistence).

  This is a good example for understanding what must be done, or not done, for persistence, based on the chosen mode of persistence. It provides both a CMP 1.1 and a CMP 2.0 implementation.

• The lb example ($JONAS_ROOT/examples/src/lb/) uses Entity beans with local interfaces.

  A Session Bean, Manager, locally manages an Entity Bean, Manac, which represents an account.

  This is a good example for understanding what must be done for a local client collocated with an Entity Bean providing local interfaces.

• The jms directory ($JONAS_ROOT/examples/src/jms/) contains a stateful Session Bean with methods performing JMS operations and a pure JMS client message receptor.

  A complete description of this example is in Section 26.6 A JMS EJB Example.

• The mailsb directory ($JONAS_ROOT/examples/src/mailsb/) contains a SessionMailer and MimePartDSMailer Stateful Session beans with methods providing a way for building and sending mail.

• The mdb/samplemdb directory ($JONAS_ROOT/examples/src/mdb/samplemdb/) contains a Message Driven Bean that listens to a topic and an MdbClient, which is a pure JMS client, that sends 10 messages on the corresponding topic.

  This is a very good example for understanding how to write and use message-driven beans.

• The mdb/sampleappli directory ($JONAS_ROOT/examples/src/mdb/sampleappli/) contains the following:

  • Two Message-Driven beans, one listening to a topic (StockHandlerBean) the other listening to a queue (OrderBean)

  • An Entity Bean with container-managed persistence (StockBean) and a stateless Session Bean for creating the table used in the database.

  SampleAppliClient sends several messages on the topic. Upon receipt of a message, the StockHandlerBean updates the database via the StockBean and sends a message to the queue inside a global transaction. All of the EJBs are involved in transactions that may commit or rollback.

• Alarm (http://jonas.objectweb.org/current/examples/alarm/) is an application that watches alarm messages generated asynchronously through JMS. It utilizes the different techniques used in JOnAS:

  • An Entity Bean for AlarmRecord, persistent in a database

  • A Session Bean to allow clients to visualize Alarms received

  • A Message Driven Bean to catch Alarms

  • JMS to use a topic where Alarms are sent and received

  • Tomcat (for JSP pages and servlets)

  • Security.

• Earsample (http://jonas.objectweb.org/current/examples/earsample/) contains a complete J2EE application. This sample is a simple stateful Session Bean that has synchronization and security.

  This bean is accessed from a servlet in which the user is authenticated and JOnAS controls access to the methods of the bean. The servlet performs a variety of lookups (resource-ref, resource-env-ref, env-entry, ejb-ref, and ejb-local-ref) in the java:comp/env environment to illustrate how the uniform naming works in the servlets.

• The CMP2 directory (http://jonas.objectweb.org/current/examples/cmp2/) contains an example illustrating most of the concepts of CMP 2.0.

• jaasclient (http://jonas.objectweb.org/current/examples/jaasclient/) contains an example of a JAAS login module that illustrates the different methods for authentication.

  There are different callback handlers that demonstrate how to enter identification at a command line prompt, either with a dialog or without a prompt (where the client uses its own login/password).

Each directory contains a README that explains how to build and run each example.

2.2.2. An Example With Database Access

The eb example contains two Entity beans that manage Account objects.

The two beans share the same interface (Account); one with bean-managed persistence (BMP, explicit persistence), the other with container-managed persistence (CMP, implicit persistence). The default CMP implementation is CMP 1.1. A CMP 2.0 implementation is also provided and its use is described in the README.

Before running this example, perform the steps in:

• Section 2.2.2.1 Configuring Database Access

• Section 2.2.2.2 Creating the Table in the Database

• Section 2.2.2.3 Configuring the Classpath

jonas.service.dbm.datasources    Oracle1

sqlplus user/passwd

SQL> @Account.sql

SQL> quit