RabbitMQ / AMQP: jedna kolejka, wielu konsumentów dla tej samej wiadomości?

Po prostu przeczytaj rabbitmq tutorial. Publikujesz wiadomość do exchange, a nie do kolejki; jest ona następnie kierowana do odpowiednich kolejek. W Twoim przypadku powinieneś powiązać osobną kolejkę dla każdego konsumenta. W ten sposób mogą konsumować wiadomości całkowicie niezależnie.

Ostatnie kilka odpowiedzi jest prawie poprawnych - mam mnóstwo aplikacji, które generują wiadomości, które muszą skończyć się z różnymi konsumentami, więc proces jest bardzo prosty.

Jeśli chcesz, aby wielu konsumentów miało tę samą wiadomość, wykonaj następującą procedurę.

Utwórz wiele kolejek, po jednej dla każdej aplikacji, która ma odbierać wiadomość, we właściwościach każdej kolejki "bind" znacznik trasowania z AMQ.wymiana bezpośrednia. Zmień aplikację publikowania, aby wysłać do amq.Kieruj i używaj znacznika routingu (nie Kolejka). AMQP skopiuje wiadomość do każdej kolejki z tym samym powiązaniem. Działa jak urok :)

Przykład: Powiedzmy, że generuję ciąg JSON, publikuję go do "amq.direct " exchange using the routing tag "new-sales-order", I have a queue for my order_printer app that prints order, I have a queue for my billing system that will send a copy of the order and invoice the client and I have a web archive system where I archive orders for historic / compliance reasons i mam interfejs internetowy klienta, gdzie zamówienia są śledzone, gdy inne informacje pojawiają się o zamówieniu.

Więc moje kolejki to: order_printer, order_billing, order_archive i order_tracking Wszystkie mają przypisany do nich znacznik "new-sales-order", wszystkie 4 otrzymają dane JSON.

Jest to idealny sposób na wysyłanie danych bez wiedzy aplikacji publikującej lub dbania o aplikacje odbierające.

Wzór wysyłania jest relacją jeden do jednego. Jeśli chcesz "wysłać" do więcej niż jednego odbiornika, powinieneś używać wzoru pub / sub. Zobacz http://www.rabbitmq.com/tutorials/tutorial-three-python.html Po Więcej Szczegółów.

Tak każdy konsument może otrzymywać te same wiadomości. Zobacz też http://www.rabbitmq.com/tutorials/tutorial-three-python.html http://www.rabbitmq.com/tutorials/tutorial-four-python.html http://www.rabbitmq.com/tutorials/tutorial-five-python.html

Dla różnych sposobów przesyłania wiadomości. Wiem, że są dla Pythona i Javy, ale dobrze jest zrozumieć zasady, zdecydować, co robisz, a następnie znaleźć, jak to zrobić w JS. To brzmi jak chcesz zrobić simple fanout (tutorial 3 ), który wysyła wiadomości do wszystkich kolejek podłączonych do exchange.

Różnica w tym, co robisz i co chcesz zrobić, polega na tym, że zamierzasz skonfigurować i wymienić lub wpisać fanout. Fanout excahnges wysyła wszystkie wiadomości do wszystkich podłączonych kolejek. Każda kolejka będzie miała konsumenta, który będzie miał dostęp do wszystkich wiadomości oddzielnie.

Tak jest to często robione, jest to jedna z cech AMPQ.

RabbitMQ / AMQP: pojedyncza Kolejka, wielu konsumentów dla tej samej wiadomości i odświeżania strony.

rabbit.on('ready', function () {    });
    sockjs_chat.on('connection', function (conn) {

        conn.on('data', function (message) {
            try {
                var obj = JSON.parse(message.replace(/\r/g, '').replace(/\n/g, ''));

                if (obj.header == "register") {

                    // Connect to RabbitMQ
                    try {
                        conn.exchange = rabbit.exchange(exchange, { type: 'topic',
                            autoDelete: false,
                            durable: false,
                            exclusive: false,
                            confirm: true
                        });

                        conn.q = rabbit.queue('my-queue-'+obj.agentID, {
                            durable: false,
                            autoDelete: false,
                            exclusive: false
                        }, function () {
                            conn.channel = 'my-queue-'+obj.agentID;
                            conn.q.bind(conn.exchange, conn.channel);

                            conn.q.subscribe(function (message) {
                                console.log("[MSG] ---> " + JSON.stringify(message));
                                conn.write(JSON.stringify(message) + "\n");
                            }).addCallback(function(ok) {
                                ctag[conn.channel] = ok.consumerTag; });
                        });
                    } catch (err) {
                        console.log("Could not create connection to RabbitMQ. \nStack trace -->" + err.stack);
                    }

                } else if (obj.header == "typing") {

                    var reply = {
                        type: 'chatMsg',
                        msg: utils.escp(obj.msga),
                        visitorNick: obj.channel,
                        customField1: '',
                        time: utils.getDateTime(),
                        channel: obj.channel
                    };

                    conn.exchange.publish('my-queue-'+obj.agentID, reply);
                }

            } catch (err) {
                console.log("ERROR ----> " + err.stack);
            }
        });

        // When the visitor closes or reloads a page we need to unbind from RabbitMQ?
        conn.on('close', function () {
            try {

                // Close the socket
                conn.close();

                // Close RabbitMQ           
               conn.q.unsubscribe(ctag[conn.channel]);

            } catch (er) {
                console.log(":::::::: EXCEPTION SOCKJS (ON-CLOSE) ::::::::>>>>>>> " + er.stack);
            }
        });
    });

Aby uzyskać pożądane zachowanie, po prostu niech każdy konsument będzie konsumował z własnej kolejki. Będziesz musiał użyć typu non-direct exchange (temat, nagłówek, fanout), aby wysłać wiadomość do wszystkich kolejek naraz.

Jak oceniam Twój przypadek to:

• Mam kolejkę wiadomości (twoje źródło do odbierania wiadomości, nazwijmy je q111)

• Mam wielu konsumentów, którzy chciałbym robić różne rzeczy z tym samym przesłaniem.

Twój problem polega na tym, że podczas gdy 3 wiadomości są odbierane przez tę kolejkę, wiadomość 1 jest konsumowana przez konsumenta A, inni konsumenci B I C konsumują wiadomość 2 i 3. Gdzie jak jesteś w potrzebie konfiguracji gdzie rabbitmq przechodzi na tym samym kopie wszystkich tych trzech wiadomości (1,2,3) do wszystkich trzech podłączonych konsumentów (A,B,C) jednocześnie.

Chociaż w tym celu można wykonać wiele konfiguracji, prostym sposobem jest użycie następującej koncepcji dwuetapowej:

• Użyj dynamicznego rabbitmq-shovel, aby odebrać wiadomości z żądanej kolejki(q111) i opublikować je na giełdzie fanout (exchange stworzony i dedykowany wyłącznie do tego celu).
• Teraz ponownie skonfiguruj swoich konsumentów A, B&C (którzy słuchali queue (q111)), aby słuchać z tej wymiany Fanout bezpośrednio przy użyciu ekskluzywnej i anonimowej kolejki dla każdego konsumenta.

Uwaga: Podczas korzystania z tej koncepcji nie pobieraj bezpośrednio z kolejki źródeł (q111), ponieważ wiadomości już zużyte nie będą przesyłane do wymiany Fanout.

Jeśli uważasz, że to nie spełnia twoich wymagań... zapraszam do zamieszczania swoich sugestii: -)

Jeśli przypadkiem używasz biblioteki amqplib tak jak ja, mają poręczny przykład implementacji Publish/Subscribe RabbitMQ tutorial, który może Ci się przydać.

Myślę, że powinieneś sprawdzić wysyłanie wiadomości za pomocą wymiennika fan-out . W ten sposób otrzymasz tę samą wiadomość dla różnych konsumentów, pod tabelą RabbitMQ tworzy kolejki differents dla każdego z tych nowych konsumentów / subskrybentów.

To jest link do zobacz przykład samouczka w javascript https://www.rabbitmq.com/tutorials/tutorial-one-javascript.html