В чем разница между Kafka и другими реализациями очередей?

# Kafka vs Другие реализации очередей

Kafka — это не просто очередь сообщений, это распределённая платформа потокового обработки данных. Она коренным образом отличается от классических message brokers.

Архитектурные отличия

Классические очереди (RabbitMQ, ActiveMQ)

// RabbitMQ — традиционная очередь сообщений
public class RabbitMQExample {
    public void producer(Channel channel) throws Exception {
        // Отправляем сообщение в очередь
        channel.basicPublish("", "my_queue", null, "Hello".getBytes());
    }
    
    public void consumer(Channel channel) throws Exception {
        // Consumer вытягивает сообщение
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody());
            // Обработка
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        };
        channel.basicConsume("my_queue", false, deliverCallback, consumerTag -> {});
    }
}

Принцип: одно сообщение = один консьюмер

Producer → Queue → Consumer (удаляет сообщение)
           └─→ Consumer2 (не видит сообщение)

Kafka — распределённый лог событий

// Kafka — партиционированный лог
public class KafkaExample {
    public void producer() {
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);
        // Отправляем событие в топик (это лог, не очередь!)
        producer.send(new ProducerRecord<>("my-topic", "key", "event"));
    }
    
    public void consumer() {
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Collections.singletonList("my-topic"));
        
        // Consumer читает из лога (может перечитать)
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(record.value());
            }
        }
    }
}

Принцип: одно событие = много потребителей (нет удаления)

Producer → Topic (Log) → Consumer1 (читает)
                      → Consumer2 (читает)
                      → Consumer3 (может перечитать)

Ключевые отличия

Модель потребления

RabbitMQ — одноразовое потребление

// Сообщение обрабатывается ОДНИМ потребителем
public void rabbitExample() {
    // Producer отправляет 3 сообщения
    channel.basicPublish("", "queue", null, "msg1".getBytes());
    channel.basicPublish("", "queue", null, "msg2".getBytes());
    channel.basicPublish("", "queue", null, "msg3".getBytes());
    
    // Consumer 1 забирает msg1
    // Consumer 2 забирает msg2
    // Consumer 3 забирает msg3
    // После подтверждения — сообщения удаляются навсегда
}

Kafka — многократное потребление

// События остаются в логе, разные Consumer Groups могут читать одни данные
public void kafkaExample() {
    // Producer отправляет 3 события
    producer.send(new ProducerRecord<>("events", "event1"));
    producer.send(new ProducerRecord<>("events", "event2"));
    producer.send(new ProducerRecord<>("events", "event3"));
    
    // Consumer Group A читает все события
    // Consumer Group B читает те же события
    // Consumer Group C может перечитать старые события!
    // Consumer Group D подключается и читает с начала (если нужно)
}

Партиционирование

RabbitMQ

// Придётся вручную распределять
for (int i = 0; i < messages.size(); i++) {
    String queueName = "queue_" + (i % 4);  // 4 физические очереди
    channel.basicPublish("", queueName, null, message.getBytes());
}

Kafka — встроено

// Kafka автоматически распределяет по партициям
ProducerRecord<String, String> record = 
    new ProducerRecord<>("my-topic", "key", "value");
producer.send(record);
// Ключ определяет партицию, обеспечивая порядок внутри партиции

Гарантии доставки

RabbitMQ

DeliverCallback deliverCallback = (consumerTag, delivery) -> {
    try {
        processMessage(delivery.getBody());
        // Подтверждение
        channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
    } catch (Exception e) {
        // Отклонение (может пойти в dead letter queue)
        channel.basicNack(delivery.getEnvelope().getDeliveryTag(), false, true);
    }
};

Kafka

ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
for (ConsumerRecord<String, String> record : records) {
    try {
        processMessage(record.value());
    } catch (Exception e) {
        // Просто продолжи с сохранением offset
        // Нет встроенного нак механизма (rebalancing решает)
    }
}
consumer.commitSync();  // Сохранить offset

Когда использовать Kafka

✅ Kafka идеальна для:

• Event streaming (аналитика, логирование)
• Event sourcing (audit logs, восстановление состояния)
• Stream processing (фильтрация, агрегирование в реальном времени)
• Change data capture (CDC) из БД
• Множество потребителей одних данных
• Большие объёмы (millions msg/sec)
• Воспроизведение событий

Когда использовать RabbitMQ/ActiveMQ

✅ Классические очереди идеальны для:

• Task queue (распределённые задачи)
• RPC (request-reply паттерны)
• One-to-one доставка
• Сложная маршрутизация (routing rules)
• Меньше данных, проще настройка
• Нет необходимости в воспроизведении

Практический пример

// Kafka для аналитики событий
public class OrderEventProducer {
    private KafkaProducer<String, String> producer;
    
    public void publishOrderCreated(Order order) {
        // Событие остаётся в логе навечно (retention policy)
        producer.send(
            new ProducerRecord<>("orders", 
                String.valueOf(order.getId()), 
                serializeOrder(order))
        );
    }
}

// Multiple Consumer Groups читают один лог
public class OrderAnalyticsConsumer {  // Consumer Group: analytics
    public void consume() {
        consumer.subscribe(Collections.singletonList("orders"));
        // Анализируем все ордеры в реальном времени
    }
}

public class OrderShippingConsumer {  // Consumer Group: shipping
    public void consume() {
        consumer.subscribe(Collections.singletonList("orders"));
        // Обрабатываем все ордеры для отправки
    }
}

Итоговое сравнение

RabbitMQ/ActiveMQ — это надёжная доставка сообщений, для task distribution

Kafka — это распределённое хранилище событий, для streaming analytics

Выбор зависит от use case:

• Нужна простая очередь задач? → RabbitMQ ✅
• Нужна аналитика в реальном времени? → Kafka ✅
• Нужна гибкость? → RabbitMQ ✅
• Нужна масштабируемость на петабайты? → Kafka ✅