Meldingsbekreftelser og varighet
Sørg for pålitelige meldinger ved å implementere manuelle bekreftelser og gjøre meldinger og køer varige. Hindre datatap ved feil hos konsumenten eller meldingsformidleren.
Meldingsbekreftelser og varighet er en gratis leksjon i RabbitMQ-meldinger og asynkrone systemer på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i RabbitMQ-meldinger og asynkrone systemer, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i RabbitMQ-meldinger og asynkrone systemer inneholder totalt 4 leksjoner.
Introduksjon til pålitelighet
I distribuerte systemer er det avgjørende å sørge for at meldinger behandles pålitelig. Hva skjer hvis en server krasjer? Eller hvis en meldingskonsument svikter midt i behandlingen?
I denne leksjonen utforsker vi to viktige mekanismer i RabbitMQ som hindrer datatap og sikrer pålitelighet: meldingsbekreftelser og persistens for både meldinger og køer.
Hva er meldingsbekreftelser?
Når en konsument mottar en melding, må den informere RabbitMQ om at meldingen er behandlet. Denne bekreftelsen kalles en bekreftelse (eller «ack»).
- Uten ack: Hvis en konsument krasjer før behandlingen er ferdig, går meldingen tapt.
- Med ack: Hvis en konsument krasjer, vet RabbitMQ at meldingen ikke ble bekreftet, og kan levere den på nytt til en annen konsument.
Automatiske og manuelle bekreftelser
RabbitMQ støtter to moduser for bekreftelser:
- Automatisk (auto-ack): RabbitMQ regner meldingen som bekreftet så snart den er levert til konsumenten. Dette er enkelt, men risikabelt, fordi meldinger kan gå tapt hvis konsumenten krasjer rett etter mottak, men før behandlingen starter.
- Manuell (eksplisitt ack): Konsumenten sender eksplisitt en bekreftelse tilbake til RabbitMQ *etter* at meldingen er behandlet. Dette er den anbefalte fremgangsmåten for pålitelig behandling.
Implementere manuelle bekreftelser
La oss se hvordan du implementerer manuelle bekreftelser i en Java-konsument. Vi bruker channel.basicAck() etter at meldingsbehandlingen er fullført.
Prøv å kjøre dette eksempelet. Konsumenten bekrefter meldingen etter en kort forsinkelse.
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
public class ConsumerAck {
private final static String QUEUE_NAME = "ack_queue";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
// Declare a non-durable queue
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
// Set prefetch count to 1 for fair dispatch (covered in Work Queues)
channel.basicQos(1);
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
System.out.println(" [x] Received '" + message + "'");
try {
Thread.sleep(1000); // Simulate work
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
System.out.println(" [x] Done and Acknowledged");
};
// false means manual acknowledgement
channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> {});
// Producer to send a message (for testing)
Channel producerChannel = connection.createChannel();
producerChannel.queueDeclare(QUEUE_NAME, false, false, false, null);
producerChannel.basicPublish("", QUEUE_NAME, null, "Hello Ack!".getBytes("UTF-8"));
System.out.println(" [x] Sent 'Hello Ack!'");
}
}Håndtere mislykket meldingsbehandling
Hva skjer hvis en konsument ikke klarer å behandle en melding? I stedet for å bekrefte den kan du avvise den negativt:
channel.basicNack(deliveryTag, multiple, requeue): Avviser én eller flere meldinger.channel.basicReject(deliveryTag, requeue): Avviser én enkelt melding.
Parameteren requeue er avgjørende. Hvis den er true, sendes meldingen tilbake til køen for behandling av en annen konsument. Hvis den er false, forkastes den eller sendes til en Dead Letter Exchange (DLX), som vi skal se på i en senere leksjon.
Hva er meldingspersistens?
Bekreftelser håndterer feil hos konsumenter, men hva med selve RabbitMQ-brokerens feil? Hva skjer med meldingene i køene hvis serveren krasjer eller starter på nytt?
Meldingspersistens sørger for at meldinger lagres på disk og overlever en omstart av brokeren. Det betyr at viktige meldinger ikke går tapt, selv om RabbitMQ-serveren uventet går ned.
Gjøre meldinger persistente
For å gjøre en melding persistent må du merke den som «persistent» når du publiserer den. Dette forteller RabbitMQ at meldingen skal skrives til disk.
Til dette bruker vi MessageProperties.PERSISTENT_TEXT_PLAIN.
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;
public class ProducerPersistent {
private final static String QUEUE_NAME = "persistent_queue";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
try (Connection connection = factory.newConnection();
Channel channel = connection.createChannel()) {
// Declare a durable queue first!
channel.queueDeclare(QUEUE_NAME, true, false, false, null);
String message = "Hello Persistent Message!";
channel.basicPublish(
"",
QUEUE_NAME,
MessageProperties.PERSISTENT_TEXT_PLAIN, // Mark message as persistent
message.getBytes("UTF-8")
);
System.out.println(" [x] Sent '" + message + "'");
}
}
}Hva er køpersistens?
Akkurat som meldinger kan også selve køene være persistente. Hvis en kø ikke er persistent, går den tapt når RabbitMQ-brokeren starter på nytt. Alle meldingene i den (selv persistente meldinger!) går også tapt.
For å oppnå reell pålitelighet må derfor både køen og meldingene i den være persistente.
Deklarere en persistent kø
For å gjøre en kø persistent setter du ganske enkelt parameteren durable til true når du deklarerer den. Dette må gjøres av både produsenten og konsumenten når de deklarerer køen.
Kjør dette eksempelet. Det deklarerer en persistent kø og sender en persistent melding.
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;
public class ProducerDurable {
private final static String DURABLE_QUEUE = "my_durable_queue";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
try (Connection connection = factory.newConnection();
Channel channel = connection.createChannel()) {
// Declare a durable queue (durable = true)
channel.queueDeclare(
DURABLE_QUEUE,
true, // durable
false, // exclusive
false, // autoDelete
null // arguments
);
String message = "Hello from a durable queue!";
channel.basicPublish(
"",
DURABLE_QUEUE,
MessageProperties.PERSISTENT_TEXT_PLAIN, // Persistent message
message.getBytes("UTF-8")
);
System.out.println(" [x] Sent '" + message + "' to durable queue.");
}
}
}Rask sjekk av pålitelighet
Hvilken kombinasjon av funksjoner kreves vanligvis for å sikre maksimal meldingspålitelighet (slik at meldinger ikke går tapt selv om en konsument eller broker svikter)?
Oppsummering og neste steg
Du har lært hvordan du kan gjøre RabbitMQ-meldinger mer pålitelige!
- Manuelle bekreftelser bekrefter at meldinger er behandlet, og hindrer tap hvis en konsument svikter.
- Meldingspersistens (persistente meldinger) sørger for at meldinger overlever omstarter av brokeren.
- Køpersistens sørger for at selve kødefinisjonen overlever omstarter av brokeren.
Ved å kombinere disse funksjonene kan du bygge robuste systemer der meldinger sjelden går tapt. Deretter skal du utforske avanserte rutingsmønstre med ulike typer exchanges!
Lær deg RabbitMQ-meldinger og asynkrone systemer med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 11
- Leksjoner
- 44
Ofte stilte spørsmål
Er leksjonen «Meldingsbekreftelser og varighet» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien RabbitMQ-meldinger og asynkrone systemer, inkludert «Meldingsbekreftelser og varighet», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i RabbitMQ-meldinger og asynkrone systemer inneholder totalt 4 leksjoner.
Hva lærer jeg i «Meldingsbekreftelser og varighet»?
Sørg for pålitelige meldinger ved å implementere manuelle bekreftelser og gjøre meldinger og køer varige. Hindre datatap ved feil hos konsumenten eller meldingsformidleren. Du øver på RabbitMQ-meldinger og asynkrone systemer med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med RabbitMQ-meldinger og asynkrone systemer?
Ingen tidligere erfaring er nødvendig. RabbitMQ-meldinger og asynkrone systemer på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.
Hvor lang tid tar leksjonen «Meldingsbekreftelser og varighet»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne RabbitMQ-meldinger og asynkrone systemer-leksjonen?
Ja. Alle RabbitMQ-meldinger og asynkrone systemer-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Hello World: Enkel kø
- Arbeidskøer: Rettferdig fordeling
- Meldingsbekreftelser og varighet
- Publisering/abonnement med fanout-exchanges