How do I get multiple clients to listen to the same consumer?

Question

For instance, Producer A delivers a message on a queue/channel to Consumer A. Let's say it's a sports score.

How can I get multiple clients (desktops, mobile devices, etc) to listen in or connect to consumer A? What would be the best option for doing this?

I'm asking the question agnostic to the underlying message broker.

Answer 1

you can use pub/sub JMS, if you are using the web/servlet container.

or now a days you can see the web-sockets, this can provide you full-duplex communication.. search for web-sockets on internet..

Answer 2

Kafka has a concept of consumer group, if you have a topic A and 3 consumers A1, B1, C1 and you want to create copies of message delivered to topic A being sent to A1, B1 and C1 then start three consumers with 3 different consumer groups.

Take a look at Kafka Article on javaworld for details on consumer group

Answer 3

Producer A delivers a message on a queue/channel to Consumer A

In Apache Kafka we are talking about a "topic".

My question is more along the lines of "if a taxi cab application had to send a message to all taxi drivers (the same message), let's say 10,000 in a given city, would all taxi drivers be subscribing to the same consumer?

Let's say we are talking about an Android app that all taxi drivers are using.

My assumptions:

1. What I mean by a "consumer" in my answer is a server/node that consumes messages of a specific queue/topic from some message broker e.g. from RabbitMQ or Apache Kafka.

2. Each message consumed contains a Business Message that should be delivered to all 10 000 drivers e.g. "There is a police control in the city center".

3. I assume that Business Messages are being sent several times a day, so when a driver is offline for a day then he will receive a couple of messages after he logs in.

4. I assume that every driver (client) has an unique ID.

5. I assume that communication is made over a HTTP e.g. every client (every app in 10k taxis) is making a HTTP request e.g. every 30 seconds to the server to check if there are some new messages. An ID of the client is provided in the request (some authentication is a must too, but this is not relevant here). So in case there are 10k clients then there is about 333 request every second on average to the server if all drivers are online.

Possible solution:

1. Server consumes all messages and keeps them in some fast storage e.g. memcached or redis.

2. At the same time, server keeps information for all 10k drivers about what is the last message that the particular driver has received. This should be stored in some fast storage too, as above.

Possible scenario:

So let's say there ware 20 messages within last 24 hours, each message has an ID from 1 to 20.

1. Client with ID = 517 is making a HTTP request to server.com/message/517.
2. Server is checking in cache what is the last message that was delivered to driver 517. Let's say the last message for him was a message 18.
3. Server is sending a driver messages: 19th and 20th.
4. Server is storing in cache that the last message for driver 517 is 20. 5. After e.g. 30 seconds next request is being made from the same client but zero messages is being sent back as a driver has received all messages already.

sum up

To sum up you need to store in the machine:

1. Progress/position for each of 10k drivers.
2. 20 messages.

Is this an answer you ware looking for?