Travel Agent Example

The end user’s Web browser submits a request in JSON format; the AJAX Endpoint receives the message, then passes it to the next message processor in the flow.

The TravelAgentRequest flow must, eventually, pass the message to the ConfirmReservations Flow flow via the request-response HTTP Endpoint. Because the Reservations flow only accepts XML messages, the TravelAgentRequest flow must first transform the data format of the message payload from JSON to XML. To perform the transformation, this flow uses an Anypoint DataMapper.

This flow next employs an XSLT Transformer to wrap the message in a SOAP envelope. Then, it uses the HTTP endpoint to push the message to the Reservations flow for processing.

The Reservations flow completes its processing tasks, then passes the message back to the TravelAgentRequest flow in SOAP XML format. The TravelAgentRequest flow unwraps the envelope, passes the message through another DataMapper to transform the payload from XML back to JSON, and displays it to the end user.

The message source — an HTTP inbound endpoint — receives, then directs messages to a SOAP Component configured as a JAX-WS service. Mule unmarshalls the SOAP envelope into JAXB-annotated Java objects; Mule references these objects as parameters. From this point in the Reservations flow and beyond, the data format of message payloads is Java. (Note that Mule does not change the content of a message’s payload, only its format.)

This flow invokes several subflows in the Travel Agent application to book reservations and charge a commission.

Using a Flow Reference Component, the Reservations flow invokes its first subflow to reserve seats on flights. The Reserve flight component sends the message to the ReserveFlight subflow to process, then enriches the message payload with the processing result.

Throughout this flow, Mule uses Message Enrichers to enrich message payloads with data (i.e. add to the payload), rather than changing payload contents. Mule enriches a message’s payload so that other message processors in the application can access the original payload.

The Reservations flow uses a second flow reference component to invoke the GetBestHotelRoom subflow. This subflow identifies the least expensive hotel room available for the traveller’s stay. Then Mule, once again, enriches the message payload with the result of the subflow’s processing.

Next, the Reservations flow passes the message through a Message Filter to confirm that the preceding subflow identified a room. The message filter examines the message payload to determine whether Mule should process the message further.

Using another flow reference component, the Reservations flow invokes a third subflow to determine the commission rate. The Get commission rate component sends the message to the GetCommissionRate subflow to process, then enriches the message payload with the processing result.

Next, the Session Variable Transformer adds the flight and hotel costs, then appends the total travel cost to the message as a session variable.

Then, the VM Endpoint invokes the ConfirmReservations Flow flow to confirm all reservations and process the charges on a credit card.

The last element in the flow, the Create TravelResponse Expression Transformer, prepares a response to return to the SOAP component. Mule uses expressions to define the contents of the response (see image below); in this case, the expressions defines two:

Finally, the response moves from the Create TravelResponse transformer through the SOAP component and HTTP endpoint to the TravelAgentRequest flow. The TravelAgentRequest flow sends the response to the end user.

This subflow calls a Web service to reserve seats on flights.

Mule first uses an expression transformer to extract the following information from the Mule message payload:

The transformer includes the above-listed information in a request it creates for the airlines’ Web service. The SOAP component in this flow — a JAX-WS client — sends the request to the Web service through the request-response HTTP endpoint.

The airlines’ Web service completes the reservation, then returns a response. The Reservations flow enriches the Mule message payload with the Web service’s response (seat reservations).

This subflow calls a Web service to acquire a list of hotel rooms available for the traveller.

Like the ReserveFlight subflow, this flow uses three building blocks to prepare and send a request to a SOAP Web service — this time, a hotels’ Web service.

The transformer uses expressions to extract the following data from the Mule message payload:

The transformer includes the above-listed information in a request it creates for the hotels’ Web service. The SOAP component sends the request through the request-response HTTP endpoint to the Web service.

The hotels’ Web service completes the reservation, then returns a response. The GetBestHotelRoom flow enriches the Mule message payload with the Web service’s response (a list of available rooms).

Notice that, unlike the Reservations flow, both the ReserveFlight and GetAvailableRooms subflows act as clients of RESTful Web services; in other words, they consume Web services from other providers.

This subflow determines which room, in the list of available hotel rooms, costs the least.

First, this subflow uses a flow reference component to invoke the GetAvailableRooms subflow; then, it enriches the Mule message payload with the list of available hotel rooms.

Mule then subjects the message to a Variable Transformer which collaborates with a Foreach iterative processor to identify the least expensive room on the list.

The variable transformer consults the Double to set a variable on the message that represents the lowest price of an available hotel room; this is “the price to beat”. Foreach then processes each item in the collection — that is to say, each room in the list of available rooms — to determine if any of those rooms can “beat the lowest price”.

Finally, the transformer at the end of this subflow uses expressions (see below) to provide the best hotel room’s data to the Reservations flow. In some cases, the result of foreach’s processing is null — perhaps there were no rooms available at all, or none of the available rooms matched the end user’s room. In such cases, the lowestPriceRoom transformer provides a NOT FOUND result to the Reservations flow.

The following example illustrates the activity in this subflow.

Imagine the GetAvailableRooms subflow supplies the GetBestHotelRoom subflow with a collection that contains three items:

The Initialize minPrice variable consults the double to set a variable on the message equivalent to double.MAX_VALUE. Then, foreach iteratively processes each item through the message processors within its scope.

Foreach passes the result of its iterative effort — the second room item in the collection — to the lowestPriceRoom transformer. The transformer identifies the ‘lowestPriceRoom’, then hands that result to the Reservations flow.

This subflow determines the commission rate to charge for the service.

The subflow uses two building to determine the commission to charge for the Travel Agent service:

Cache passes the response — calculated from a stored value, or freshly returned from the Web service — to the Object to String transformer, which converts the payload from a Java object to a string. This transformation provides the Calculate Price session variable with data in a format it can use to perform a calculation.

This flow receives a message through a request-response VM Endpoint, then uses a flow reference component to invoke a subflow to authorize credit card payments. Once authorized to make payments, Mule passes the message to a set variable transformer. This transformer, Set Rollback = CREDIT_CARD, and the Set Rollback = FLIGHT transformer (further in the flow) collaborate with a Choice Exception Strategy to handle errors.

The variable transformers in this flow each set a variable on the message. The variable value helps the choice exception strategy determine which transaction(s) Mule must cancel when an error occurs.

The choice exception strategy catches an exception in the ConfirmReservations flow, then consults the variable on the message to decide where to route it. (Refer to image and code snippet below.)

For example, when the ConfirmHotelRoom subflow fails to confirm the reserved hotel room (perhaps the room’s availability changed at the last second), the message throws an exception, and the choice exception strategy catches it. The exception strategy consults the variable the message. It determines that because Mule has set a FLIGHT variable on the message, it must direct the message to the second catch exception strategy to cancel both transactions.

The ConfirmReservations flow is one of only two flows in the application which employ a customized exception strategy. All but one of the other flows and subflows use Mule’s implicitly-applied default exception strategy.

This subflow sends a request to a Web service to confirm flight reservations.

The ConfirmFlight subflow uses three building blocks to prepare, then send a request to the airlines’ SOAP Web service.

The Create FlightConfirmationRequest transformer uses expressions to extract the following data from the Mule message payload:

The transformer includes the above-listed information in a request it creates for the airlines’ Web service. The SOAP component in this flow — a JAX-WS client — sends the request to the Web service through the request-response HTTP endpoint.

The airlines’ Web service processes the request, then returns a confirmation response. The ConfirmReservations flow enriches the Mule message payload with the Web service’s response.

This subflow sends a request to a Web service to confirm hotel reservations.

Rather than use an expression transformer like the ConfirmFlight subflow, this subflow uses an Anypoint DataMapper transformer to prepare a request for the hotels’ SOAP Web service.

The TravelRequest to ConfirmationRequest transformer maps data from the Mule message payload to the payload of a request it is creating for the Web service. Refer to the table below to examine the data it maps.

Notice that Mule extracts all the data it needs from the same session variable. Rather than use three expressions in an expressions transformer to extract three pieces of information from the same variable, Mule uses a DataMapper to extract three pieces of information from one input argument. In such cases, Anypoint DataMapper is a more efficient transformer.

In Mule Studio, click the DataMapper transformer in the canvas to select it. Then, click the Data Mapping tab in Mule Studio’s console to see a graphical representation of the data it maps (see below).

The SOAP component in this flow sends the request to the Web service through the request-response HTTP endpoint. The hotels’ Web service processes the request, then returns a confirmation response. The ConfirmReservations flow enriches the Mule message payload with the Web service’s confirmation response.

This subflow sends a request to a Web service to pay for the trip with a credit card.

Mule uses a credit card to pay for the total cost of the hotel room and flight bookings. This subflow uses a JDBC Endpoint to retrieve credit card information from a database. Mule uses an SQL query (see image and code snippet below) to determine which credit card to use, and which data to retrieve.

The enricher adds a creditCard variable to the Mule message payload that includes the following data:

The Create PaymentRequest transformer uses expressions to extract the following data from the Mule message payload:

The transformer includes the above-listed information in a request it creates for the CreditCardService Web service. The SOAP component in this flow sends the request to the Web service through the request-response HTTP endpoint.

The credit cards’ Web service processes the payment, then returns a confirmation response. Mule enriches the message payload with the Web service’s response.

These subflows send requests to Web services to cancel the confirmed flights and the credit card payment.

Both subflows use three building blocks to prepare, then send a cancellation request to the airlines’, or the credit cards’, SOAP Web service.

Each employs:

The Web services process the requests, then return confirmation responses. The subflows notify the catch exception strategies that they have completed the cancellation activities.