Read more about the release here:
http://blog.shhmooze.com/2011/09/19/show-some-android-love-at-your-next-conference-or-meetup/

And download the app here:
https://market.android.com/details?id=com.shhmooze.UI

[2011-08-19 10:06:06 - App] Android Launch!
[2011-08-19 10:06:06 - App] adb is running normally.
[2011-08-19 10:06:06 - App] Could not find App.apk!

After a few hours of banging my head against the wall I remembered that before I powered down my laptop the previous day I’d updated the Android SDK using the SDK and AVD Manager.  After a little investigation it turns out the version of Eclipse I’m using(Ganymede – 3.4) is not compatible with the latest version of the SDK(r12.) The quick solution: update my Eclipse install, problem solved.

I wish I’d done this sooner, the Latest Eclipse version(Indigo) is very nice indeed!

I can’t believe I hadn’t used these before, I actually think working with a compiled statement is much nicer than working with the  standard SQL insert/update methods but there are a couple of points to remember.

• They only work for INSERTS, UPDATES, DELETES or single long or string SELECTS.
• They are not syncronized, so if using multiple threads you must roll your own syncronization.

SQLiteDatabase db = DBHelper.getWritableDatabase();
mInsertAttributeStatement = db.compileStatement("INSERT INTO UserProfileAttributes (UserId, AttributeKey, AttributeValue) VALUES (?,?,?)");

mInsertAttributeStatement.bindLong(1, userId);
mInsertAttributeStatement.bindString(2, key);
mInsertAttributeStatement.bindString(3, value);
mInsertAttributeStatement.execute();

I experimented and found a couple of small tweaks that make a huge difference, this first is wrapping the batch of writes in a transaction. The code looks like this:

	        db.beginTransaction();
		for (IRemoteUser user : users) {
			saveUser(user);
		}
		db.setTransactionSuccessful();
		db.endTransaction();

As you can see this is pretty simple, start a transaction, write the objects to the db(in this case I’m doing this in a child method) and then commit the transaction.

The  (very tasty)drink is called Elixir of Love and  the flavour is based on Rose and Hibiscus. We are going for an old-school look with a modern twist.

So first step was to find a model for the label, we wanted a classic looking girl, preferably an actual old photo.  After lots of trawling we found this lovely 1800′s photo of a perfect lady from Graphics Fairy.  As a side note, I discovered while doing this that pretty much any picture/painting/photo produced before the 1920′s is fair game to do whatever you want with(with a few caveats.)

As we had a rose drink, we wanted some roses on the label so again we went trawling for vintage rose pictures. There are a surprising number of websites giving away free scanned old-school images but most of ours came from the Graphics Fairy. I used the roses and photos to create this concept poster.

And then with a little tweaking and re-creating in illustrator I produced this final bottle label.

1.) Publish/Subscribe

My first example is Publish/Subscribe. What I’m going to do is use and existing Publisher(Producer) from my last .net article  and write a Subscriber(Consumer) on Android. If you are not a .net person then you can use the Publisher from the example on the RabbitMQ website.

Ok so first we need to create and Android project. Open up eclipse and go File -> New -> Android Project

#

Use the settings/names I have here. Give the package name something unique to you though We won’t create a test project right now so hit “Finish”

Next we want to write our message consumer. We’re going to follow a similar pattern to my .net example and crate a base class that consumers and producers can inherit from.

First of all we need to include the RabbitMQ Java Client Library. If you don’t have it already get the latest version from here .  Unzip this and find the following three files:

• rabbitmq-client.jar
• commons-io-1.2.jar
• commons-io-1.2

Create a folder in the root of your Android project called lib , copy and paste the jars in to the new folder. The RabbitMQ client usage should be obvious but you may wonder what the other two files are used for. The RabbitMQ client uses Java API’s not included in the Android SDK Java API. These two files add the missing API’s for the RabbitMQ client to use. If you didn’t add these files you wouldn’t notice anything until runtime  when the connection to the broker would silently fail . If you then looked through the debug logcat output you would see something like this:

WARN/System.err(9557): Caused by: java.lang.NoClassDefFoundError: com.rabbitmq.client.impl.TruncatedInputStream

Now we need to reference the jar files in the project, go Project -> Properties -> Java Build Path. Click the “Add Jar” button and navigate to the lib folder and select the three jar files and click ok.

Ok now to the base class. Add a new class IConnectToRabbitMQ as follows

/**
 * Base class for objects that connect to a RabbitMQ Broker
 */
public abstract class IConnectToRabbitMQ {
	  public String mServer;
      public String mExchange;

      protected Channel mModel = null;
      protected Connection  mConnection;

      protected boolean Running ;

      protected  String MyExchangeType ;

      /**
       *
       * @param server The server address
       * @param exchange The named exchange
       * @param exchangeType The exchange type name
       */
      public IConnectToRabbitMQ(String server, String exchange, String exchangeType)
      {
    	  mServer = server;
    	  mExchange = exchange;
          MyExchangeType = exchangeType;
      }

      public void Dispose()
      {
          Running = false;

			try {
				if (mConnection!=null)
					mConnection.close();
				if (mModel != null)
					mModel.abort();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

      }

      /**
       * Connect to the broker and create the exchange
       * @return success
       */
      public boolean connectToRabbitMQ()
      {
    	  if(mModel!= null && mModel.isOpen() )//already declared
    		  return true;
          try
          {
        	  ConnectionFactory connectionFactory = new ConnectionFactory();
              connectionFactory.setHost(mServer);
              mConnection = connectionFactory.newConnection();
              mModel = mConnection.createChannel();
              mModel.exchangeDeclare(mExchange, MyExchangeType, true);

              return true;
          }
          catch (Exception e)
          {
        	  e.printStackTrace();
              return false;
          }
      }
}

You should be able to see the similarities here to the .net example. What I’ve tried to do is keep the Android and .net code as similar as possible as I switch between the two quite often.  Here is a summary of the main differences

The use of a concrete Chanel and Connection

//Java

protected Channel mModel = null;

protected Connection  mConnection;

Instead of a IModel and IConnection

//.net

protected IModel Model { get; set; }

protected IConnection Connection { get; set; }

The Connection and Model initialisation code is also slightly different

//Java

connectionFactory.setHost(mServer);

mConnection = connectionFactory.newConnection()

mModel = mConnection.createChannel();

As opposed to in .net

//.net

connectionFactory.HostName = Server;

Connection = connectionFactory.CreateConnection();

Model = Connection.CreateModel();

Now we need to write our Consumer that will inherit from this base class. There are a few more differences here when compared to .net but the basic pattern is exactly the same.

/**
 *Consumes messages from a RabbitMQ broker
 *
 */
public class MessageConsumer extends  IConnectToRabbitMQ{

	public MessageConsumer(String server, String exchange, String exchangeType) {
		super(server, exchange, exchangeType);
	}

	//The Queue name for this consumer
    private String mQueue;
    private QueueingConsumer MySubscription;

    //last message to post back
    private byte[] mLastMessage;

    // An interface to be implemented by an object that is interested in messages(listener)
    public interface OnReceiveMessageHandler{
    	public void onReceiveMessage(byte[] message);
    };

    //A reference to the listener, we can only have one at a time(for now)
    private OnReceiveMessageHandler mOnReceiveMessageHandler;

    /**
     *
     * Set the callback for received messages
     * @param handler The callback
     */
    public void setOnReceiveMessageHandler(OnReceiveMessageHandler handler){
    	mOnReceiveMessageHandler = handler;
    };

    private Handler mMessageHandler = new Handler();
    private Handler mConsumeHandler = new Handler();

    // Create runnable for posting back to main thread
    final Runnable mReturnMessage = new Runnable() {
        public void run() {
        	mOnReceiveMessageHandler.onReceiveMessage(mLastMessage);
        }
    };

    final Runnable mConsumeRunner = new Runnable() {
        public void run() {
        	Consume();
        }
    };

    /**
     * Create Exchange and then start consuming. A binding needs to be added before any messages will be delivered
     */
    @Override
    public boolean connectToRabbitMQ()
    {
       if(super.connectToRabbitMQ())
       {

           try {
        	   mQueue = mModel.queueDeclare().getQueue();
        	   MySubscription = new QueueingConsumer(mModel);
        	   mModel.basicConsume(mQueue, false, MySubscription);
			} catch (IOException e) {
				e.printStackTrace();
				return false;
			}
			 if (MyExchangeType == "fanout")
	               AddBinding("");//fanout has default binding

	        Running = true;
			mConsumeHandler.post(mConsumeRunner);

           return true;
       }
       return false;
    }

    /**
     * Add a binding between this consumers Queue and the Exchange with routingKey
     * @param routingKey the binding key eg GOOG
     */
    public void AddBinding(String routingKey)
    {
        try {
			mModel.queueBind(mQueue, mExchange, routingKey);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }

    /**
     * Remove binding between this consumers Queue and the Exchange with routingKey
     * @param routingKey the binding key eg GOOG
     */
    public void RemoveBinding(String routingKey)
    {
        try {
			mModel.queueUnbind(mQueue, mExchange, routingKey);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }

    private void Consume()
    {
    	Thread thread = new Thread()
    	{

    		 @Override
    		    public void run() {
    			 while(Running){
			    	QueueingConsumer.Delivery delivery;
				    try {
				        delivery = MySubscription.nextDelivery();
			        	mLastMessage = delivery.getBody();
			        	mMessageHandler.post(mReturnMessage);
			    	    try {
							mModel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
						} catch (IOException e) {
							e.printStackTrace();
						}
				    } catch (InterruptedException ie) {
				    	ie.printStackTrace();
				    }
    			 }
    		 }
    	};
    	thread.start();

    }

    public void dispose(){
    	Running = false;
    }
}

Ok, lets look at the Android specific bits here.  The first code of interest is this

    // An interface to be implemented by an object that is interested in messages(listener)
    public interface OnReceiveMessageHandler{
    	public void onReceiveMessage(byte[] message);
    };

    //A reference to the listener, we can only have one at a time(for now)
    private OnReceiveMessageHandler mOnReceiveMessageHandler;

    /**
     *
     * Set the callback for received messages
     * @param handler The callback
     */
    public void setOnReceiveMessageHandler(OnReceiveMessageHandler handler){
    	mOnReceiveMessageHandler = handler;
    };

What we are doing here is declaring an interface OnReceiveMessageHandler{} that a message listener will implement. We want to have one listener at a time which we keep a reference to in  mOnReceiveMessageHandler. We can set the listener by using the method setOnReceiveMessageHandler(OnReceiveMessageHandler handler) . This is a standard Android pattern and is used throughout the SDK for onClick listeners etc.

Next we have

private Handler mMessageHandler = new Handler();
private Handler mConsumeHandler = new Handler();

Here we are declaring two Handler. A handler is a special object in Android that is used to safely pass data between processes (Threads) and to execute Runnables. It’s vaguely like a delegate in .net

Next we have two Runnable.

// Create runnable for posting back to main thread
    final Runnable mReturnMessage = new Runnable() {
        public void run() {
        	mOnReceiveMessageHandler.onReceiveMessage(mLastMessage);
        }
    };

    final Runnable mConsumeRunner = new Runnable() {
        public void run() {
        	Consume();
        }
    };

A runnable is a block of work that can be passed to a new Thread for execution. We will be using our Handlers to run(or post) these Runnables . This is slightly confusing but a very important concept to get a grasp of if you plan to do anything but trivial Android development.

Now within the connectToRabbitMq()  method we have this:

</pre>
mConsumeHandler.post(mConsumeRunner);

This is posting the  mConsumeRunner runnable to the mConsumeHandler for execution on a new Thread. mConsumeHandler will call the run() method of the mConsumeRunner. This in turn calls the Consume() method which spawns a new blocking message-listening/de-queuing thread.

When we have a new message we then call

mMessageHandler.post(mReturnMessage);

This invokes the mReturnMessage runnable which in turn calls the mOnReceiveMessageHandler.onReceiveMessage(mLastMessage)  listener/handler, phew

If this is looking confusing then please read more about Runnables, Threads and Handlers. It is very important.

We now have our consuming code, lets use it. We need to output the messages somewhere so we need a TextView to display it. In the project folder structure open /res/layout/ there should be a file in there called main.xml. Open this file up and make sure it looks like this:

<?xml version="1.0" encoding="utf-8"?>
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    >
<TextView
	android:id="@+id/output"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/hello"
    />
</ScrollView>

What we have here is a root ScrollView containing one TextView with an ID of output.

Next open up the ActivityHome.java file we created with the project. Make it look like this.

public class ActivityHome extends Activity {
	private MessageConsumer mConsumer;
	private TextView mOutput;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        //The output TextView we'll use to display messages
        mOutput =  (TextView) findViewById(R.id.output);

        //Create the consumer
        mConsumer = new MessageConsumer("192.168.1.67",
        		"logs",
        		"fanout");

        //Connect to broker
        mConsumer.connectToRabbitMQ();

        //register for messages
        mConsumer.setOnReceiveMessageHandler(new OnReceiveMessageHandler(){

			public void onReceiveMessage(byte[] message) {
				String text = "";
				try {
					text = new String(message, "UTF8");
				} catch (UnsupportedEncodingException e) {
					e.printStackTrace();
				}

				mOutput.append("\n"+text);
			}
        });

    }

    @Override
	protected void onResume() {
		super.onPause();
		mConsumer.connectToRabbitMQ();
	}

	@Override
	protected void onPause() {
		super.onPause();
		mConsumer.dispose();
	}
}

This should all be fairly self explanatory. We get a reference to our output view, create the and connect the consumer. When creating the consumer you must use the IP of your rabbitMQ broker machine(in may case “192.168.1.67″) on your local network not “localhost”.  We then listen for messages with a new setOnReceiveMessageHandler.

We are stopping the Consumer onPause. This is very good practise as it stops us draining the device battery and data allowance.

Now we need to test it!

If we ran this now it wouldn’t work. We need to tell the Android system this app is allowed to access the internet(and in turn the broker). In the root of the project open AndroidManifest.xml. Just before the closing /manifest tag, add this permission.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.atplatforms.rabbitmq"
      android:versionCode="1"
      android:versionName="1.0">
     ......
    <uses-permission android:name="android.permission.INTERNET"></uses-permission>
</manifest>

Hit Run -> Run. The app will start in the emulator or you connected Android device.

Then startup the .net Form app from the last .net example.

Start up a consumer and send a message. You should get the same message on both the Consumer running on your desktop machine and on your Android device. Nice

Take a moment to consider this. What we have here is very cool, we can send a message to all connected consumers without ever knowing they are there or how many there are.  We are sending messages cross language , platform and OS with very little work. We could use this exact same code to send these messages to thousands of Android hansets with no problem if we wanted to.

In the next example I’ll start to get a little more complex sending some more interesting messages using both .net and Android, I’ll also be looking at routing. [Code available soon]

3.) Publish/Subscribe

The original article (in Java) is here:http://www.rabbitmq.com/tutorials/tutorial-three-java.html

I’m going to take a slightly different approach to my previous two examples and split the Producer and Consumer into two different Windows Forms. This will allow us to run as many Consumers as we like  and so demonstrate Pub/Sub effectively.

First up is the Producer.

Create a new Form and add the Input TextBox and Button as in the first two examples. Also and a new Button “Start New Consumer” .

Next create the consumer. We only need to output messages so we only need one RichTextBox

In the previous two examples we had pretty much duplicate constructors for both Consumers and Producers. We will now fix this by creating a base class that these can both inherit from. Create a new class called IConnectToRabbitMQ.

public abstract class IConnectToRabbitMQ : IDisposable
    {
        protected IModel Model { get; set; }
        protected IConnection Connection { get; set; }
        public string Server { get; set; }
        public string ExchangeName{ get; set; }
        public string ExchangeTypeName { get; set; }

        public IConnectToRabbitMQ(string server, string exchange, string exchangeType)
        {
            Server = server;
            Exchange = exchange;
            ExchangeTypeName = exchangeType;
        }
        //Create the connection, Model and Exchange(if one is required)
        public virtual bool ConnectToRabbitMQ()
        {
            try
            {
                var connectionFactory = new ConnectionFactory();
                connectionFactory.HostName = Server;
                Connection = connectionFactory.CreateConnection();
                Model = Connection.CreateModel();
                bool durable = true;
                if (!String.IsNullOrEmpty(Exchange))
                    Model.ExchangeDeclare(Exchange, ExchangeTypeName, durable);
                return true;
            }
            catch (BrokerUnreachableException e)
            {
                return false;
            }
        }

        public void Dispose()
        {
            if (Connection != null)
                Connection.Close();
            if (Model != null)
                Model.Abort();
        }
    }

The class name may look a little odd to most as it begins with an “I”, this is usually the naming convention for an Interface but I’m using what I like to call Simon Says naming convention. I’ll be writing a post about this in the near future. The main gist of it, is I like to have classes tell me what they do. For example, a class which calls a remote service might inherit from a class(or interface) called ICallRemoteServices. So the full class name definition would be FooService : ICallRemoteServices. There would also be a abstract method defined that implements the action e.g CallRemoteService.  Other example are  IAmAnOrder(for a value object), ICalculateShipping, IDeliverEmail etc. This may seem a little weird but I like it .

So enough of that for now, lets go through the class. First we declare fields to hold the familiar IModel and Connection instances. Next up are fields to store the details of the Server, Exchange and ExchangeTypeName.  Exchange is the name of the exchange we want to publish/consume messages from and ExchangeTypeName  holds the type of exchange we want to use(in this example it will be “fanout”).  ExchangeType is set from a constant declared in the RabbitMQ.Client.ExchangeType  class, so for us it will be ExchangeType .Fanout(More on this later.) Next we have the  ConnectToRabbitMQ() method, this is almost exactly the same as the Constructor methods of the Producer/Consumer methods  in my  previous two examples. We have this additional block which declares the Exchange.

                bool durable = true;
                if (!String.IsNullOrEmpty(ExchangeName))
                    Model.ExchangeDeclare(ExchangeName, ExchangeTypeName, durable);

We are declaring a durable exchange of the type ExchangeTypeName with the name ExchangeName.  If this exchange had already been declared by another Producer or Consumer  a new one is not created, the existing one will be used.

Now we’ll write our Producer.

public class Producer : IConnectToRabbitMQ
    {
        public Producer(string server, string exchange, string exchangeType) : base(server, exchange, exchangeType)
        {
        }

        public void SendMessage(byte[] message)
        {
            IBasicProperties basicProperties = Model.CreateBasicProperties();
            basicProperties.SetPersistent(true);
            Model.BasicPublish(ExchangeName, "", basicProperties, message);
        }
    }
}

Here we a have a nice lightweight publisher, the only difference from our previous examples is we are publishing to a named exchange called ExchangeName. We do not know about or use a Queue.

Then it’s our consumer, this is slightly more complicated.

public class Consumer : IConnectToRabbitMQ
    {
        protected bool isConsuming;
        protected string QueueName;

        // used to pass messages back to UI for processing
        public delegate void onReceiveMessage(byte[] message);
        public event onReceiveMessage onMessageReceived;

        public Consumer(string server, string exchange, string exchangeType) : base(server, exchange, exchangeType)
        {
        }

        //internal delegate to run the consuming queue on a seperate thread
        private delegate void ConsumeDelegate();

        public void StartConsuming()
        {
                Model.BasicQos(0, 1, false);
                QueueName = Model.QueueDeclare();
                Model.QueueBind(QueueName, ExchangeName, "");
                isConsuming = true;
                ConsumeDelegate c = new ConsumeDelegate(Consume);
                c.BeginInvoke(null, null);
        }

        protected Subscription mSubscription { get; set; }

        private void Consume()
        {
            bool autoAck = false;

            //create a subscription
            mSubscription = new Subscription(Model, QueueName, autoAck);

            while (isConsuming)
            {
                BasicDeliverEventArgs e = mSubscription.Next();
                byte[] body = e.Body;
                onMessageReceived(body);
                mSubscription.Ack(e);

            }
        }

        public void Dispose()
        {
            isConsuming = false;
            base.Dispose();
        }
    }

We need to store the name of our Queue that we will be binding to the exchange so we have a field QueueName for this purpose. The next code of interest is the StartConsuming() method. Most of this is familiar with this additional block:

 QueueName = Model.QueueDeclare();
 Model.QueueBind(QueueName, ExchangeName, "");
 

What we are doing here is asking the model to declare a temporary queue for us and give it a random unique name(stored in QueueName), we then bind this queue to the Exchange called ExchangeName. 

This a key concept to exchanges in RabbitMQ, a publisher/producer only knows about the Exchange, it will publish messages directly to the Exchange and has no concept of a queue. Each consumer knows about the Exchange but they will also have a queue that is bound to the Exchange.  The way I look at it is the one or more Producers own an Exchange(and publish to it) and each Consumer owns a Queue(which is bound to an Exchange.)

The Consume() method is very different to what we have seen before(and the Java Example). Instead of using a  QueueingBasicConsumer we are using a Subscription. Subscription is part of the RabbitMQ.Client.MessagePatterns package in the .net client Library. It give us a nice wrapper to the boilerplate message de-queuing code. More info is here.

        mSubscription = new Subscription(Model, QueueName, autoAck);
          .....
          BasicDeliverEventArgs e = mSubscription.Next();
          .....
          mSubscription.Ack(e);

Now we need to add the code for our Producer Form

       public string HOST_NAME = "localhost";
        public string EXCHANGE_NAME = "logs";

        private Producer producer;

        //delegate to show messages on the UI thread
        private delegate void showMessageDelegate(string message);

        public PubSub_Producer()
        {
            InitializeComponent();

            //Declare the producer
            producer = new Producer(HOST_NAME, EXCHANGE_NAME, ExchangeType.Fanout);

            //connect to RabbitMQ
            if(!producer.ConnectToRabbitMQ())
            {
                //Show a basic error if we fail
                MessageBox.Show("Could not connect to Broker");
            }

        }

        private int count = 0;
        private void button1_Click(object sender, EventArgs e)
        {
            string message = String.Format("{0} - {1}", count++, textBox1.Text);
            producer.SendMessage(System.Text.Encoding.UTF8.GetBytes(message));
        }

        private void button2_Click(object sender, EventArgs e)
        {
            //Open a new Consumer Form
            PubSub_Consumer consumer = new PubSub_Consumer();
            consumer.Show();
        }

This should be fairly self explanatory. The producer.ConnectToRabbitMQ() call is handled in the base IConnectToRabbitMQ class. We’ve added little error handling code just in case the broker is unavailable(if it is run rabbitmq-server -detached from the command line .) There’s also a method to handle clicks on the “Start New Consumer” Button which spawns a new Consumer Form.

Then we have our Consumer Form.

public partial class PubSub_Consumer : Form
    {
        public string HOST_NAME = "localhost";
        public string EXCHANGE_NAME = "logs";

        private Consumer consumer;
        public PubSub_Consumer()
        {
            InitializeComponent();
            //create the consumer
            consumer = new Consumer(HOST_NAME, EXCHANGE_NAME, ExchangeType.Fanout);

            //connect to RabbitMQ
            if (!consumer.ConnectToRabbitMQ())
            {
                //Show a basic error if we fail
                MessageBox.Show("Could not connect to Broker");
            }

            //Register for message event
            consumer.onMessageReceived += handleMessage;

            //Start consuming
            consumer.StartConsuming();
        }

        //delegate to post to UI thread
        private delegate void showMessageDelegate(string message);

        //Callback for message receive
        public void handleMessage(byte[] message)
        {
            showMessageDelegate s = new showMessageDelegate(richTextBox1.AppendText);
            this.Invoke(s, System.Text.Encoding.UTF8.GetString(message) + Environment.NewLine);
        }
    }

This is exactly the same as previous Consumer examples with the additional call to the base class.

Now we can run the project after making sure the correct Form is opened on starup

   [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new PubSub_Producer());
        }

Click the “Start New Consumer” Button a couple of time to get a few consumers running, then put  your message in the “Producer Input”  TextBox and hit send. You should see the message appear in all the Consumer output windows. Good stuff

Summary

What we have done here is create a Fanout Exchange named “logs”,  we’ve created some Consumers(three in my example above) each with their own unique temporary queue bound to the exchange. We have then published a message to the exchange using our Producer, the exchange then routes the message to all bound queues which in turn delivers it to the Consumers. Download the Source