Home | Download | PDF | API | FAQ | Search | Feedback | History

> ## An Application Example That Deploys a Message-Driven Bean on Two Java EE Servers

> This section, like the preceding one, explains how to write, compile, package, deploy, and run a pair of Java EE modules that use the JMS API and run on two Java EE servers. The modules are slightly more complex than the ones in the first example.

> The modules use the following components:

> - An application client that is deployed on the local server. It uses two connection factories--one ordinary one and one that is configured to communicate with the remote server--to create two publishers and two subscribers and to publish and to consume messages.
> - A message-driven bean that is deployed twice: once on the local server, and once on the remote one. It processes the messages and sends replies.

> In this section, the term local server means the server on which both the application client and the message-driven bean are deployed (`earth` in the preceding example). The term remote server means the server on which only the message-driven bean is deployed (`jupiter` in the preceding example).

> The section covers the following topics:

> - Overview of the Modules
> - Writing the Module Components
> - Creating and Packaging the Modules
> - Deploying the Modules
> - Running the Application Client

> You will find the source files for this section in `<``INSTALL``>/javaeetutorial5/examples/jms/sendremote/`. Path names in this section are relative to this directory.

> ### Overview of the Modules

> This pair of modules is somewhat similar to the modules in An Application Example That Consumes Messages from a Remote Java EE Server in that the only components are a client and a message-driven bean. However, the modules here use these components in more complex ways. One module consists of the application client. The other module contains only the message-driven bean and is deployed twice, once on each server.

> The basic steps of the modules are as follows.

> 1. You start two Java EE servers, one on each system.
> 2. On the local server (`earth`), you create two connection factories: one local and one that communicates with the remote server (`jupiter`). On the remote server, you create a connection factory that has the same name.
> 3. The application client looks up the two connection factories--the local one and the one that communicates with the remote server--to create two connections, sessions, publishers, and subscribers. The subscribers use a message listener.
> 4. Each publisher publishes five messages.
> 5. Each of the local and the remote message-driven beans receives five messages and sends replies.
> 6. The client's message listener consumes the replies.

> Figure 33-4 illustrates the structure of this application. M1 represents the first message sent using the local connection factory, and RM1 represents the first reply message sent by the local MDB. M2 represents the first message sent using the remote connection factory, and RM2 represents the first reply message sent by the remote MDB.

> Figure 33-4 A Java EE Application That Sends Messages to Two Servers

> ### Writing the Module Components

> Writing the components of the modules involves two tasks:

> - Coding the Application Client: MultiAppServerClient.java
> - Coding the Message-Driven Bean: ReplyMsgBean.java

> #### Coding the Application Client: MultiAppServerClient.java

> The application client class, `multiclient/src/java/MultiAppServerClient.java`, does the following.

> 1. It injects resources for two connection factories and a topic.
> 2. For each connection factory, it creates a connection, a publisher session, a publisher, a subscriber session, a subscriber, and a temporary topic for replies.
> 3. Each subscriber sets its message listener, `ReplyListener`, and starts the connection.
> 4. Each publisher publishes five messages and creates a list of the messages the listener should expect.
> 5. When each reply arrives, the message listener displays its contents and removes it from the list of expected messages.
> 6. When all the messages have arrived, the client exits.

> #### Coding the Message-Driven Bean: ReplyMsgBean.java

> The message-driven bean class, `replybean/src/ReplyMsgBean.java`, does the following:

> 1. Uses the `@MessageDriven` annotation:

> `@MessageDriven(mappedName="jms/Topic")`

> 2. Injects resources for the `MessageDrivenContext` and for a connection factory. It does not need a destination resource because it uses the value of the incoming message's `JMSReplyTo` header as the destination.
> 3. Uses a `@PostConstruct` callback method to create the connection, and a `@PreDestroy` callback method to close the connection.

> The `onMessage` method of the message-driven bean class does the following:

> 1. Casts the incoming message to a `TextMessage` and displays the text
> 2. Creates a connection, a session, and a publisher for the reply message
> 3. Publishes the message to the reply topic
> 4. Closes the connection

> On both servers, the bean will consume messages from the topic `jms/Topic`.

> ### Creating and Packaging the Modules

> This example uses the connection factory named `jms/ConnectionFactory` and the topic named `jms/Topic`. These objects must exist on both the local and the remote servers.

> This example uses an additional connection factory, `jms/JupiterConnectionFactory`, which communicates with the remote system; you created it in Creating Administered Objects for Multiple Systems (page 1063). This connection factory must exist on the local server.

> The `build.xml` file for the `multiclient` module contains targets that you can use to create these resources if you deleted them previously.

> The Application Server must be running on both systems. You package, deploy, and run the module from the local system.

> To package the modules, perform these steps:

> 1. Go to the following directory:

> `<``INSTALL``>/javaeetutorial5/examples/jms/sendremote/replybean`

> 2. Type the following command:

> `ant`

> This command creates a JAR file that contains the bean class file.

> 3. Change to the directory `multiclient`:

> `cd ../multiclient`

> 4. Type the following command:

> `ant`

> This command creates a JAR file that contains the client class file and a manifest file.

> ### Deploying the Modules

> To deploy the `multiclient` module on the local server, perform the following steps:

> 1. Verify that you are still in the directory `multiclient`.
> 2. Type the following command:

> `ant deploy`

> To return a client JAR file, use the following command:

>     ant client-jar

> This command returns a JAR file named `multiclientClient.jar` in the `client-jar` directory.

> To deploy the `replybean` module on the local and remote servers, perform the following steps:

> 1. Change to the directory `replybean`:

> `cd ../replybean`

> 2. Type the following command:

> `ant deploy`

> 3. Type the following command:

> `ant deploy-remote -Dsys=``remote_system_name`

> Replace `remote_system_name` with the actual name of the remote system.

> ### Running the Application Client

> To run the client, perform these steps:

> 1. Change to the directory `multiclient`:

> `cd ../multiclient`

> 2. Type the following command:

> `ant run-client`

> On the local system, the output of the `appclient` command looks something like this:

>     running application client container.
>     Sent message: text: id=1 to local app server
>     Sent message: text: id=2 to remote app server
>     ReplyListener: Received message: id=1, text=ReplyMsgBean processed message: text: id=1
>     to local app server
>     Sent message: text: id=3 to local app server
>     ReplyListener: Received message: id=3, text=ReplyMsgBean processed message: text: id=3
>     to local app server
>     ReplyListener: Received message: id=2, text=ReplyMsgBean processed message: text: id=2
>     to remote app server
>     Sent message: text: id=4 to remote app server
>     ReplyListener: Received message: id=4, text=ReplyMsgBean processed message: text: id=4
>     to remote app server
>     Sent message: text: id=5 to local app server
>     ReplyListener: Received message: id=5, text=ReplyMsgBean processed message: text: id=5
>     to local app server
>     Sent message: text: id=6 to remote app server
>     ReplyListener: Received message: id=6, text=ReplyMsgBean processed message: text: id=6
>     to remote app server
>     Sent message: text: id=7 to local app server
>     ReplyListener: Received message: id=7, text=ReplyMsgBean processed message: text: id=7
>     to local app server
>     Sent message: text: id=8 to remote app server
>     ReplyListener: Received message: id=8, text=ReplyMsgBean processed message: text: id=8
>     to remote app server
>     Sent message: text: id=9 to local app server
>     ReplyListener: Received message: id=9, text=ReplyMsgBean processed message: text: id=9
>     to local app server
>     Sent message: text: id=10 to remote app server
>     ReplyListener: Received message: id=10, text=ReplyMsgBean processed message: text:
>     id=10 to remote app server
>     Waiting for 0 message(s) from local app server
>     Waiting for 0 message(s) from remote app server
>     Finished
>     Closing connection 1
>     Closing connection 2

> On the local system, where the message-driven bean receives the odd-numbered messages, the output in the server log looks like this (wrapped in logging information):

>     ReplyMsgBean: Received message: text: id=1 to local app server
>     ReplyMsgBean: Received message: text: id=3 to local app server
>     ReplyMsgBean: Received message: text: id=5 to local app server
>     ReplyMsgBean: Received message: text: id=7 to local app server
>     ReplyMsgBean: Received message: text: id=9 to local app server

> On the remote system, where the bean receives the even-numbered messages, the output in the server log looks like this (wrapped in logging information):

>     ReplyMsgBean: Received message: text: id=2 to remote app server
>     ReplyMsgBean: Received message: text: id=4 to remote app server
>     ReplyMsgBean: Received message: text: id=6 to remote app server
>     ReplyMsgBean: Received message: text: id=8 to remote app server
>     ReplyMsgBean: Received message: text: id=10 to remote app server

> Undeploy the modules after you finish running the client. To undeploy the `multiclient` module, perform these steps:

> 1. Verify that you are still in the directory `multiclient`.
> 2. Type the following command:

> `ant undeploy`

> To undeploy the `replybean` module, perform these steps:

> 1. Change to the directory `replybean`:

> `cd ../replybean`

> 2. Type the following command:

> `ant undeploy`

> 3. Type the following command:

> `ant undeploy-remote -Dsys=``remote_system_name`

> Replace `remote_system_name` with the actual name of the remote system.

> To remove the generated files, use the following command in both the `replybean` and `multiclient` directories:

>     ant clean