Let's navigate to our source code examples folder and locate the folder Shop. Here you will find our e-commerce application; it consists of three files, namely order.js, orderService.js, and server.js.

Let's take a look at the order.js script. This is a simple object with two properties, OrderId and Status.

module.exports = function order(orderId) {
    this.OrderId = orderId;
    this.Status = "Processing";
};

Let's take a look at the orderService.js script, which contains the order processor; the following has been simplified, so check the source code for a complete listing:

module.exports = function OrderService(order) {
    this.Order = order;
    this.Checkout = function() {
console.log("INFO, Placed order " +   this.Order.OrderId);
      this.ProcessOrder();
    };
    this.ProcessOrder = function() {
      this.PaymentGateway();
      this.UpdateStatus();
      if (this.Status === 'OrderComplete') {
          this.UpdateInventory();
          this.SendEmail();
          this.UpdateReporting();
       }
       console.log('INFO, Thank you for placing your order...'),
    };
    this.PaymentGateway = function() {// see source };
    this.UpdateStatus = function() {// see source };
    this.UpdateInventory = function() {// see source };
    this.SendEmail = function() {// see source };
    this.UpdateReporting = function() {// see source };
};

Each of the preceding functions simply simulates doing actual work by printing a message.

The server.js script is our entry point and runs the order processor for a single order.

var order = require('./order'),
var orderService = require('./orderService'),
var service = new orderService(new order(1));
service.Checkout();

To run this program open a command-line console, navigate to our source code examples folder, and locate the folder Shop. Execute the following command:

  sHop> node server

The following screenshot shows the output of running our sHop application.

So how can we improve our application using messaging? The Work Queues pattern allows us to efficiently distribute time-consuming tasks among multiple workers. RabbitMQ will use a round-robin dispatch, sending each message to the next consumer in sequence.

What we need to do is split the application into two separate services: a service which simply starts the process by creating an order (producer), and a service that processes the order (consumer). Our producer application would simply add a message to a RabbitMQ queue. The message contains the order details, and then displays an order confirmation message. Our consumer service picks these messages off the queue and processes the order.

Let's review our existing sHop application and see what changes we need to make in order to implement Work Queues.

Take a look at the orderService.js script. In order to split this apart we remove the call to ProcessOrder from our Checkout method. Our producer application will call the Checkout function, and our consumer application will call the ProcessOrder function.

   this.Checkout = function() {
       console.log("INFO, Placed order " + 
      this.Order.OrderId);
      this.ProcessOrder(); //remove
    };
    this.ProcessOrder = function() {
        this.PaymentGateway();
        this.UpdateStatus();
        if (this.Status === 'OrderComplete') {
            this.UpdateInventory();
            this.SendEmail();
            this.UpdateReporting();
        }
        console.log('INFO, Thank you for placing your order...'),
    };

Let's navigate to our source code examples folder and locate the folder Work-Queues. Take a look at the producer.js script.

Take a look at the consumer.js script.

We now have multiple consumers processing messages/orders; these consumers could exist on separate servers. We can horizontally scale, adding more consumers/servers with ease of improving the performance.

Up until now we have used a Direct Exchange type; a Direct Exchange is also the default exchange. A Direct Exchange does an exact match between the routing key provided when publishing messages and the routing criteria used when a queue is bound to this exchange. The following diagram demonstrates the concept:

As you can see, a Direct Exchange can route messages to multiple queues with the same binding. From the preceding diagram we can see that the messages are routed to queues 1 and 3.