【昕宝爸爸小模块】日志系列之什么是分布式日志系统

在这里插入图片描述

➡️博客首页       https://blog.csdn.net/Java_Yangxiaoyuan


       欢迎优秀的你👍点赞、🗂️收藏、加❤️关注哦。


       本文章CSDN首发，欢迎转载，要注明出处哦！


       先感谢优秀的你能认真的看完本文，有问题欢迎评论区交流，都会认真回复！


日志系列之什么是分布式日志系统？

  • 一、✅什么是分布式日志系统？
    • 1.1 ✅分布式日志系统和消息队列有什么区别和联系
    • 1.2 ✅哪些场景下需要使用分布式日志系统和消息队列
    • 1.3 ✅实际项目的开发过程中到底如何做选择
    • 1.4 ✅分布式日志系统和消息队列如何实现异步通信和解耦呢
    • 1.5 ✅分布式日志系统和消息队列的优缺点是什么
    • 1.6 ✅分布式日志系统和消息队列如何实现性能和吞吐量呢
      • 1.6.1🟢分布式日志系统
      • 1.6.2🟢消息队列
    • 1.7 ✅如何保证消息的可靠传输
      • 1.7.1 🟢添加依赖
      • 1.7.2 🟢创建生产者
      • 1.7.3 🟢创建消费者
  • 二、✅扩展知识仓
    • 2.1✅ELK


一、✅什么是分布式日志系统？


现在，很多应用都是集群部署的，一次请求会因为负载均衡而被路由到不同的服务器上面，这就导致一个应用的日志会分散在不同的服务器上面。


当我们要向通过日志做数据分析，问题排查的时候，就需要分别到每台机器上去查看日志，这样就太麻烦了。


于是就有了分布式日志系统，他可以做分布式系统中的日志的统一收集、存储及管理。并且提供好的可用性、扩展性。


在这里插入图片描述

一个好的分布式日志系统，应该具备数据采集、数据加工、查询分析、监控报警、日志审计等功能。有了分布式日志系统，我们就可以做集中化的日志管理， (准)实时性的做日志查询及分析，快速的做问题排查，更好的做数据分析及挖掘。


比较主流的这类日志管理系统有ELK、Graylog、Apache Flume，还有很多类似的云产品，如阿里云的SLS。


一般来说，如果资金够就上SLS，不够就自建ELK。


实现分布式日志系统需要使用分布式系统的一些基本概念和技术，例如消息传递、数据复制和分布式一致性协议。在Java中实现分布式日志系统可以使用一些现有的框架和库，例如Apache Kafka或Logstash。


看一个Demo：


import java.util.Properties;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.TimeUnit;  
import org.apache.kafka.clients.producer.*;  

/**
*    一个分布式日志系统的Demo、包括日志的收集、处理、存储和检索功能
*    
*/  
public class DistributedLogSystem {  
    public static void main(String[] args) {  
        // 创建日志收集器线程池  
        ExecutorService collectorPool = Executors.newFixedThreadPool(10);  
  
        // 创建Kafka生产者配置  
        Properties props = new Properties();  
        props.put("bootstrap.servers", "localhost:9092");  
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");  
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");  
  
        // 创建Kafka生产者  
        Producer<String, String> producer = new KafkaProducer<>(props);  
  
        // 启动日志收集器线程  
        for (int i = 0; i < 10; i++) {  
            final int threadId = i;  
            collectorPool.submit(() -> {  
                try {  
                    // 模拟日志收集逻辑  
                    for (int j = 0; j < 1000; j++) {  
                        String topic = "logs";  
                        String message = "Log message " + threadId + "_" + j;  
                        ProducerRecord<String, String> record = new ProducerRecord<>(topic, message);  
                        producer.send(record);  
                    }  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
            });  
        }  
  
        // 关闭日志收集器线程池和Kafka生产者  
        collectorPool.shutdown();  
        try {  
            if (!collectorPool.awaitTermination(60, TimeUnit.SECONDS)) {  
                collectorPool.shutdownNow();  
            }  
            producer.close();  
        } catch (InterruptedException e) {  
            collectorPool.shutdownNow();  
            producer.close();  
            Thread.currentThread().interrupt();  
        }  
    }  
}

上面这个Demo中，首先创建了一个线程池用于日志收集器线程，然后创建了一个Kafka生产者对象。接着，使用线程池启动了10个日志收集器线程，每个线程模拟日志收集逻辑，并将收集到的日志消息发送到Kafka中。最后，关闭了日志收集器线程池和Kafka生产者对象。


1.1 ✅分布式日志系统和消息队列有什么区别和联系


分布式日志系统和消息队列在实现和应用上有一些区别和联系。


首先，分布式日志系统主要用于记录、存储和分析系统的日志信息，以帮助开发人员监控系统状态、排查问题等。而消息队列则是一种更为通用的技术，主要用于在不同的服务或应用之间传递消息，实现异步通信和数据交换。


其次，分布式日志系统通常将日志数据存储在分布式文件系统中，如HDFS、ELK等，以实现数据的可靠存储和高效查询。而消息队列则可以使用各种消息中间件，如RabbitMQ、Kafka等，以提供更为灵活的消息传递和消费机制。


此外，分布式日志系统和消息队列在应用场景上也有所不同。分布式日志系统主要用于系统监控和诊断，而消息队列则广泛应用于异步通信、任务调度、事件驱动架构等领域。


尽管两者有所区别，但它们之间也存在一定的联系。在实际应用中，可以将分布式日志系统中的日志数据发送到消息队列中，以便于其他服务或应用进行进一步的处理和分析。同时，也可以使用消息队列来实现分布式系统中的异步通信和数据交换，提高系统的灵活性和可扩展性。


总之，分布式日志系统和消息队列都是分布式系统中重要的组成部分，它们各自具有不同的功能和特点，但在实际应用中可以相互配合使用，以实现更为高效和可靠的分布式系统。


看一个简单的Demo来帮助理解：


实现：如何使用分布式日志系统（如Apache Kafka）来收集和存储日志数据。


首先，我们需要引入Apache Kafka的相关依赖。在Maven项目中，可以在pom.xml文件中添加以下依赖：


<dependencies>
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>2.8.0</version>
    </dependency>
</dependencies>

接下来，我们可以创建一个Kafka生产者类，用于将日志数据发送到Kafka集群：


import org.apache.kafka.clients.producer.*;

import java.util.Properties;

public class KafkaProducerExample {
    public static void main(String[] args) {
        // 设置Kafka生产者配置属性
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092"); // Kafka集群地址
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); // 键序列化器
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); // 值序列化器

        // 创建Kafka生产者实例
        Producer<String, String> producer = new KafkaProducer<>(props);

        // 发送日志数据到Kafka集群
        String topic = "my-log-topic"; // 日志主题名称
        String logData = "This is a log message"; // 日志数据内容
        ProducerRecord<String, String> record = new ProducerRecord<>(topic, logData);
        producer.send(record);

        // 关闭Kafka生产者实例
        producer.close();
    }
}

上面的代码中，我们首先创建了一个Kafka生产者实例，并设置了相关的配置属性，包括Kafka集群地址、键序列化器和值序列化器。然后，我们创建了一个 ProducerRecord 对象，用于表示要发送到Kafka集群的日志数据。最后，我们调用 producer.send() 方法将日志数据发送到指定的Kafka主题中。在完成日志数据的发送后，我们关闭了Kafka生产者实例。


当然了，这只是一个简单的示例，实际应用中还需要考虑更多的问题，如日志数据的格式化、异常处理、数据压缩等。同时，还需要配合其他工具和框架（如ELK Stack）来实现更为完整和高效的分布式日志系统。


1.2 ✅哪些场景下需要使用分布式日志系统和消息队列


分布式日志系统和消息队列在许多场景中都有广泛的应用，以下是一些常见的应用场景：


  1. 故障诊断与排查：当分布式系统出现故障时，通过分析日志可以更快地定位问题的原因和位置，从而加快故障排查和修复的速度。
  2. 性能调优与优化：通过收集系统中的各个节点的日志信息，可以了解系统的整体性能，发现潜在的性能瓶颈，并进行相应的优化。
  3. 事件追踪与监控：通过分布式日志系统，可以实时追踪系统中的各种事件，如用户行为、系统操作等，并进行实时监控和报警。
  4. 异步通信与解耦：消息队列可以作为分布式系统中的异步通信机制，解耦各个服务之间的直接依赖关系，提高系统的可扩展性和容错性。
  5. 数据分片与迁移：在分布式系统中，可以通过分布式日志系统进行数据分片和迁移，提高系统的可扩展性和数据一致性。
  6. 审计与日志分析：分布式日志系统可以用于审计和日志分析，帮助开发人员了解系统的运行状态和用户行为，以便进行更好的数据分析和挖掘。

分布式日志系统和消息队列在分布式系统中有着广泛的应用场景，它们能够提供可靠的数据存储和传输机制，实现高效的监控、追踪、分析和优化等功能。


1.3 ✅实际项目的开发过程中到底如何做选择


在选择分布式日志系统和消息队列时，需要综合考虑以下几个因素：


  1. 需求与功能：根据实际项目的需求和功能要求，选择能够满足需求的分布式日志系统和消息队列。例如，如果需要实时监控和报警，那么选择具有实时处理能力的分布式日志系统可能更为合适；如果需要异步通信和数据交换，那么消息队列可能更适合。
  2. 性能与效率：分布式日志系统和消息队列的性能和效率对于整个分布式系统的性能有着重要的影响。在选择时，需要权衡各个系统的性能指标和效率，并考虑系统规模和数据量的增长趋势。
  3. 易用性与可维护性：选择易于使用和易于维护的分布式日志系统和消息队列可以提高开发效率和系统稳定性。此外，还需要考虑系统的文档支持、社区活跃度等因素。
  4. 成本与开放性：在选择分布式日志系统和消息队列时，需要考虑成本和开放性。一些开源项目可以降低成本，同时具有较好的开放性，方便进行二次开发和定制化。
  5. 集成与兼容性：在实际项目中，可能需要将分布式日志系统和消息队列与其他系统进行集成和配合使用。因此，需要考虑各个系统的集成能力和兼容性，以便更好地实现系统之间的交互和数据传输。

综上所述，选择合适的分布式日志系统和消息队列需要根据实际项目的需求、功能、性能、易用性、成本、开放性、集成和兼容性等多个因素进行综合考虑。在评估各个因素的基础上，可以选择一种或多种适合系统的工具和技术，以满足项目的实际需求和提高整体性能。


1.4 ✅分布式日志系统和消息队列如何实现异步通信和解耦呢


分布式日志系统和消息队列可以通过以下方式实现异步通信和解耦：


  1. 分层和分割：通过分层和分割的方式，将系统中的各个组件或服务分离部署，各自专注于自己的业务，建立起各自的集群。这样可以实现系统的扩展性和维护性，同时解耦各个组件之间的直接依赖关系。
  2. 使用消息队列：消息队列可以作为系统中的中介，将各个组件或服务之间的通信解耦。消息生产者将消息发送到消息队列中，消息消费者从消息队列中订阅并处理消息。这种方式可以实现异步通信，提高系统的响应性能和吞吐量。
  3. 定义清晰的消息格式和协议：为了确保不同组件之间的通信能够顺利进行，需要定义清晰的消息格式和通信协议。这样可以使消息生产者和消费者都能理解并正确处理消息。
  4. 使用合适的消息队列系统：根据需求选择适合的消息队列系统，如RabbitMQ、Kafka、ActiveMQ等。考虑因素包括性能、可靠性、可扩展性和支持的功能。
  5. 实现消息确认机制：在消息队列中，确保消息的可靠传输至关重要。消息生产者发送消息后，可以等待消息队列返回确认信息，以确保消息已被接收并正确处理。消费者在处理完消息后发送确认消息给消息队列，以通知消息已经成功处理。
  6. 错误处理和重试机制：当消息处理失败时，可以实现错误处理和重试机制。将失败的消息放回消息队列，让消费者重新处理或延迟处理。这样可以提高系统的可靠性和容错能力。
  7. 监控和日志记录：对消息队列的状态进行监控，并记录关键指标和日志信息。这样可以帮助识别潜在的问题、优化系统性能，并进行故障排查。

分布式日志系统和消息队列通过分层和分割、使用消息队列、定义清晰的消息格式和协议、使用合适的消息队列系统、实现消息确认机制、错误处理和重试机制以及监控和日志记录等方式实现异步通信和解耦。这样可以提高系统的扩展性、维护性、可靠性和性能，降低系统间的耦合性，并方便进行数据分析和挖掘等操作。


一个简单的Demo：


import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

/**
* 如何使用消息队列实现异步通信和解耦：
*/
public class MessageProducer {
    private JmsTemplate jmsTemplate;

    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }

    public void sendMessage(String destination, String message) {
        jmsTemplate.send(destination, new MessageCreator() {
            @Override
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(message);
            }
        });
    }
}

在上面的代码中，我们使用了Spring框架的JmsTemplate类来简化消息队列的操作。通过注入JmsTemplate实例，我们可以方便地发送消息到指定的消息队列。sendMessage()方法接收目标队列的名称和要发送的消息内容作为参数，然后使用JmsTemplate的send()方法将消息发送到指定的队列中。这种方式可以实现异步通信，将发送消息的操作与消息队列解耦，提高系统的灵活性和可扩展性。


需要注意：在实际应用中，还需要根据具体的业务需求和场景来选择合适的消息队列系统，并根据具体的消息格式和协议进行相应的处理和解析。此外，还需要考虑消息的可靠传输、错误处理和重试机制、监控和日志记录等方面的实现。


1.5 ✅分布式日志系统和消息队列的优缺点是什么


分布式日志系统和消息队列是两种不同的技术，它们各自有不同的优缺点。


分布式日志系统的优点：

  1. 可靠性：分布式日志系统通常提供数据持久化和备份功能，确保数据不会因为单点故障而丢失。
  2. 可扩展性：分布式日志系统通常设计为可扩展的，可以轻松地添加更多的日志采集节点来处理更多的日志数据。
  3. 灵活性：分布式日志系统通常支持多种数据格式和协议，可以根据需要定制和解析日志数据。
  4. 分析能力：分布式日志系统通常提供强大的查询和数据分析功能，可以帮助开发人员和运维人员快速定位问题。

分布式日志系统的缺点：

  1. 复杂性：分布式日志系统通常涉及多个节点和组件，部署和维护相对复杂。
  2. 性能瓶颈：如果日志数据量非常大，分布式日志系统可能会成为性能瓶颈，需要优化系统配置或增加硬件资源。
  3. 成本：分布式日志系统的实现和维护需要一定的成本，尤其是在大规模生产环境中。

消息队列的优点：

  1. 异步通信：消息队列支持异步通信，生产者和消费者可以在不同时间处理消息，提高了系统的响应速度和吞吐量。
  2. 解耦：消息队列将生产者和消费者解耦，使它们可以独立扩展和维护，降低了系统的复杂性。
  3. 可扩展性：消息队列能够处理高并发的消息传递，可以根据需求灵活地扩展机器和队列。
  4. 灵活性：消息队列支持多种消息格式和协议，可以根据需要定制和发送消息。

消息队列的缺点：

  1. 复杂性：消息队列涉及多个组件和交互，部署和维护相对复杂。
  2. 性能问题：如果消息量非常大，消息队列可能会成为性能瓶颈，需要优化系统配置或增加硬件资源。
  3. 可靠性问题：如果消息队列的管理和存储机制不完善，可能会出现消息丢失或重复消费的情况。

1.6 ✅分布式日志系统和消息队列如何实现性能和吞吐量呢


分布式日志系统和消息队列在实现高性能和高吞吐量方面，通常采用一系列的设计和优化策略。以下是这些策略的一些关键点：


1.6.1🟢分布式日志系统

  1. 并行处理：通过分布式架构，日志可以在多个节点上并行处理。每个节点负责处理一部分日志数据，从而提高整体处理性能。

  2. 负载均衡：在日志数据进入系统时，使用负载均衡器将数据分发到不同的处理节点上，确保每个节点的负载相对均衡，避免单点压力过大。

  3. 数据压缩：在存储和传输日志数据之前，对数据进行压缩，可以减少网络带宽和存储空间的消耗，从而提高性能。

  4. 索引优化：为日志数据建立高效的索引结构，可以加快查询速度，提高分析性能。

  5. 异步写入：采用异步写入机制，将日志数据先写入内存缓冲区，再批量写入磁盘或远程存储，减少I/O操作的延迟。

  6. 数据分区：将日志数据分区存储，使得每个分区可以独立地进行读写操作，提高并发处理能力。

  7. 资源隔离：为日志系统分配独立的计算、网络和存储资源，避免与其他系统争抢资源导致性能下降。


1.6.2🟢消息队列

  1. 异步处理：消息队列本身就是异步通信的模式，生产者和消费者可以并行工作，从而提高整体吞吐量。

  2. 持久化与非持久化：根据需求选择消息的持久化级别。非持久化消息可以提高性能，但可能会丢失；持久化消息虽然性能略低，但保证了消息的可靠性。

  3. 批量处理：生产者和消费者都可以批量发送和接收消息，减少网络交互次数，提高性能。

  4. 并发控制：通过控制生产者和消费者的并发数，可以优化系统的吞吐量。

  5. 内存优化：合理利用内存缓存机制，减少磁盘I/O操作，提高消息处理速度。

  6. 数据分区与分片：将消息数据分区或分片存储，使得每个分区或分片可以独立处理，提高并发性能。

  7. 负载均衡与集群：通过集群和负载均衡技术，将消息分发到多个消息代理上，实现水平扩展，提高吞吐量。

  8. 流量控制：实施流量控制机制，防止生产者发送过多的消息导致消费者处理不过来，造成资源浪费或系统崩溃。


综上所述，分布式日志系统和消息队列通过并行处理、负载均衡、数据压缩、异步操作、资源隔离等一系列策略和技术，可以有效地实现高性能和高吞吐量。这些策略需要根据具体的业务需求和系统环境进行定制和优化。


来看一个简单的Demo：


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
* 如何使用RabbitMQ实现异步通信和解耦，以及如何通过一些优化策略提高性能和吞吐量
* @author xinbaobaba
*/
public class MessageProducer {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂并设置参数
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setUsername("guest");
        factory.setPassword("guest");

        // 创建连接
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 声明一个队列，如果不存在则创建
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 发送消息到队列中
        String message = "Hello World!";
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
        System.out.println("Sent message: " + message);

        // 关闭连接和通道
        channel.close();
        connection.close();
    }
}

在上面的代码中，我们使用了RabbitMQ作为消息队列系统。通过创建ConnectionFactory实例并设置相关参数，我们可以连接到RabbitMQ服务器。然后，我们创建Connection和Channel实例，用于发送和接收消息。在发送消息时，我们声明一个队列（如果不存在则创建），并使用basicPublish()方法将消息发送到队列中。最后，我们关闭连接和通道。


为了提高性能和吞吐量，我们可以采取以下优化策略：


  1. 批量发送消息：我们可以将多个消息批量发送到队列中，而不是一个一个地发送，从而减少网络交互的次数。在发送消息时，我们可以使用basicPublish()方法的批量发送参数。
  2. 持久化队列和消息：为了确保消息的可靠传输，我们可以将队列和消息都设置为持久化。这样即使RabbitMQ服务器重启或发生故障，队列和消息也不会丢失。在声明队列和发送消息时，我们可以使用相应的持久化参数。
  3. 并发处理：我们可以使用多线程或多进程来并发处理消息。这样可以充分利用系统的计算资源，提高处理速度和吞吐量。在接收消息时，我们可以使用多个消费者实例并行地从队列中获取和处理消息。
  4. 异步处理：我们可以使用异步处理模式来提高性能和吞吐量。在发送和接收消息时，我们可以使用异步方法，避免阻塞主线程。这样可以使应用程序更加高效地处理其他任务。

1.7 ✅如何保证消息的可靠传输


保证消息的可靠传输是在分布式系统和消息队列中非常重要的一个方面。以下是几种常用的策略和技术，可以确保消息的可靠传输：


  1. 消息确认机制：

    • 在生产者发送消息后，消息队列系统应该提供一个确认机制来通知生产者消息是否成功发送。
    • 对于消费者，一旦消息被成功处理，它应该发送一个确认信号给消息队列系统，表明该消息已经被成功处理。

  2. 持久化：

    • 将消息队列中的消息持久化到磁盘或其他持久化存储介质中，以防止因系统崩溃或其他故障导致的消息丢失。
    • 配置队列和消息的持久化选项，确保在消息代理重启后，消息不会丢失。

  3. 重试机制：

    • 如果消息发送或处理失败，应该有一个重试机制来重新发送或处理消息。
    • 重试机制应该有最大重试次数和重试间隔的配置，以避免无限循环和系统资源的浪费。

  4. 死信队列：

    • 配置死信队列来捕获那些无法被正常处理或消费的消息。
    • 死信队列允许系统管理员后续对这些异常消息进行处理或分析。

  5. 事务性消息：

    • 使用事务性消息来确保消息的发送和接收是原子操作。
    • 如果事务失败，消息将回滚到之前的状态，确保数据的一致性。

  6. 消息顺序性保证：

    • 在某些场景中，消息的顺序性很重要。可以通过在消息中添加序列号或使用专门保证顺序性的消息队列来确保消息的顺序性。

  7. 幂等性处理：

    • 设计消息处理逻辑为幂等的，意味着无论消息被处理多少次，结果都是一致的。
    • 这可以防止因重复消费消息而导致的系统状态不一致。

  8. 网络可靠性：

    • 使用可靠的网络协议（如TCP）来传输消息，以减少消息在网络传输过程中丢失的可能性。

  9. 监控和告警：

    • 对消息队列系统进行监控，并设置告警机制来及时通知管理员任何可能的问题或故障。

  10. 备份和恢复策略：

    • 定期对消息队列系统进行备份，并制定恢复策略来应对可能的灾难性事件。

在Java中，使用RabbitMQ或Apache Kafka等消息队列时，可以通过配置相关参数和利用这些消息队列提供的API来实现上述的可靠传输策略。例如，在RabbitMQ中，可以设置消息的持久化属性，使用事务或确认机制，以及配置死信队列等。


老样子，使用代码段来进一步解释如何实现消息的可靠传输。以下是一个Demo：


1.7.1 🟢添加依赖


首先，确保你的项目中添加了RabbitMQ的Java客户端依赖。你可以使用Maven或Gradle来添加。


1.7.2 🟢创建生产者


import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

/**
* 如何使用RabbitMQ的Java客户端来发送和接收消息，并确保消息的可靠传输
* @author xinbaobaba
*/
public class MessageProducer {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost"); // 设置RabbitMQ服务器地址
        factory.setUsername("guest"); // 设置用户名
        factory.setPassword("guest"); // 设置密码

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            
            // 声明一个持久化队列（如果队列不存在则创建）
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);
            System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
            
            // 发送消息到队列中，持久化队列和消息都会确保消息不会丢失
            String message = "Hello World!";
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

1.7.3 🟢创建消费者


import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import java.util.concurrent.CountDownLatch;

/**
* @author xinbaobaba
*/
public class MessageConsumer {
    private final static String QUEUE_NAME = "hello";
    private static final CountDownLatch latch = new CountDownLatch(1); // 用于等待消息处理完成

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost"); // 设置RabbitMQ服务器地址
        factory.setUsername("guest"); // 设置用户名
        factory.setPassword("guest"); // 设置密码

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            
            // 声明一个持久化队列（如果队列不存在则创建）
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);
            System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
            channel.basicConsume(QUEUE_NAME, true, new DeliverCallback() { // 自动确认模式，确保消息被可靠处理
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    String message = new String(body, "UTF-8"); // 获取消息内容并打印出来
                    System.out.println(" [x] Received '" + message + "'");
                    latch.countDown(); // 减少计数，表示消息已处理完成
                }
            }, consumerTag -> { }); // 使用lambda表达式简化了DeliverCallback的实现过程，并指定消费者标签（可选）
            latch.await(); // 等待消息处理完成后再继续执行其他任务（例如关闭连接）
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 在这里你可以添加其他逻辑，例如关闭资源或执行清理操作等。
        }
    }
}

二、✅扩展知识仓


2.1✅ELK


ELK是三个开源软件的缩写，分别表示: Elasticsearch，Logstash,Kibana。


Elasticsearch是个开源分布式搜索引擎，提供分析、存储数据等功能


Logstash主要是用来日志的搜集、分析、过滤日志的工具，支持大量的数据获取方式


Kibana也是一个开源和免费的工具，Kibana可以为 Logstash 和 ElasticSearch 提供的日志分析友好的 Web 界面，可以帮助汇总、分析和搜索重要数据日志。


所以，通常是使用Logstash做日志的采集与过滤，ES做分析和查询，Kibana做图形化界面


在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/363744.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

坚持刷题 ｜ 完全二叉树的节点个数

坚持刷题 ｜ 完全二叉树的节点个数

Hello&#xff0c;大家好&#xff0c;我是阿月&#xff01;坚持刷题&#xff0c;老年痴呆追不上我&#xff0c;今天刷&#xff1a;完全二叉树的节点个数 题目 222.完全二叉树的节点个数 代码实现 class TreeNode {int val;TreeNode left, right;public TreeNode(int val) …
阅读更多...
编程实例分享，配件进销存进出库管理系统软件

编程实例分享，配件进销存进出库管理系统软件

编程实例分享&#xff0c;配件进销存进出库管理系统软件 一、前言 以下教程以 佳易王配件进出库管理系统软件V16.0为例说明 如上图&#xff0c;左侧为导航栏&#xff0c;分为 系统设置&#xff0c;用户信息设置&#xff0c;出入库开单&#xff0c;统计报表&#xff0c;财务管…
阅读更多...
C++初阶 类和对象(补充)

C++初阶 类和对象(补充)

目录 一、友元 1.1什么是友元&#xff1f; 1.2如何使用友元&#xff1f; 1.3使用友元 1.4使用友元注意事项 二、初始化列表 2.1什么是初始化列表? 2.2为什么要有初始化列表&#xff1f; 2.3使用初始化列表 2.4注意事项 一、友元 1.1什么是友元&#xff1f; 友元是一…
阅读更多...
基于MobileNet(v1-v3)全系列不同参数量级模型开发构建果树图像病虫害识别分析系统，实验量化对比不同模型性能

基于MobileNet(v1-v3)全系列不同参数量级模型开发构建果树图像病虫害识别分析系统，实验量化对比不同模型性能

最近正好项目中在做一些识别相关的内容&#xff0c;我也陆陆续续写了一些实验性质的博文用于对自己使用过的模型进行真实数据的评测对比分析&#xff0c;感兴趣的话可以自行移步阅读即可&#xff1a; 《移动端轻量级模型开发谁更胜一筹&#xff0c;efficientnet、mobilenetv2、…
阅读更多...
高等数学：积分

高等数学：积分

本文主要参考&#xff1a; 【建议收藏】同济七版《高等数学》精讲视频 | 期末考试 | 考研零基础 | 高数小白_哔哩哔哩_bilibili 4.1.1.1 定积分引例_哔哩哔哩_bilibili 仅供本人学习使用。 积分是一个在多个领域都广泛使用的概念&#xff0c;特别是在数学和物理学中。 以下是积…
阅读更多...
PyTorch识别验证码

PyTorch识别验证码

## 一、生成测试集数据pip install captcha common.py import random import time captcha_array list("0123456789abcdefghijklmnopqrstuvwxyz") captcha_size 4from captcha.image import ImageCaptchaif __name__ __main__:for i in range(10):image ImageC…
阅读更多...
leetcode209长度最小的子数组|滑动窗口算法详细讲解学习

leetcode209长度最小的子数组|滑动窗口算法详细讲解学习

滑动窗口是一种基于双指针的一种思想&#xff0c;两个指针指向的元素之间形成一个窗口。 分类&#xff1a;窗口有两类&#xff0c;一种是固定大小类的窗口&#xff0c;一类是大小动态变化的窗口。 简而言之&#xff0c;滑动窗口算法在一个特定大小的字符串或数组上进行操作&…
阅读更多...
如何使用Cloudreve搭建私有云盘并发布公网访问无需购买域名服务器

如何使用Cloudreve搭建私有云盘并发布公网访问无需购买域名服务器

文章目录 1、前言2、本地网站搭建2.1 环境使用2.2 支持组件选择2.3 网页安装2.4 测试和使用2.5 问题解决 3、本地网页发布3.1 cpolar云端设置3.2 cpolar本地设置 4、公网访问测试5、结语 1、前言 自云存储概念兴起已经有段时间了&#xff0c;各互联网大厂也纷纷加入战局&#…
阅读更多...
飞轮储能系统的建模与MATLAB仿真（永磁同步电机作为飞轮驱动电机）

飞轮储能系统的建模与MATLAB仿真（永磁同步电机作为飞轮驱动电机）

目录 1 主要内容 电网侧控制系统 电机侧模型 模型二 2 结果分析 3 下载链接 1 主要内容 该仿真为飞轮储能系统的建模&#xff0c;包括电网侧和电机侧两部分模型&#xff0c;仿真采用永磁同步电机作为飞轮驱动电机&#xff0c;通过矢量控制的方式对其发电和电动的工况进行控…
阅读更多...
基于单片机温度控制系统的研究

基于单片机温度控制系统的研究

摘　要&#xff1a;笔者基于单片机的温度控制系统&#xff0c;从单片机选择、传感器选择、系统框架设计等方面概述了单片机的温度控制系统内涵&#xff0c;分析了其运行原理&#xff0c;列举了单片机温度控制系统设计的实操方法&#xff0c;从硬件系统、软件系统、温度检测方法…
阅读更多...
Python武器库开发-武器库篇之zip文件暴力破解(五十一)

Python武器库开发-武器库篇之zip文件暴力破解(五十一)

Python武器库开发-武器库篇之zip文件暴力破解(五十一) Zip文件是一种常用的存档文件格式&#xff0c;用于将多个文件和文件夹压缩成一个单独的文件。它是一种广泛接受和支持的文件格式&#xff0c;几乎所有操作系统和计算机都能够处理Zip文件。Zip文件使用一种压缩算法来减小文…
阅读更多...
sqli-labs靶场第一关详解

sqli-labs靶场第一关详解

目录 sqlilabs靶场第一关 0. sql注入解释 0.1什么是sql注入 0.2sql注入的原理 0.3sql注入方法 0.3.1 数字型注入 0.3.2 字符型注入 1.注入第一步判断请求方式、类型 1.1打开我自己本地的靶场http://sql.com/Less-1/ &#xff08;上一期靶场搭建&#xff1a;http://t.…
阅读更多...
nodejs+vue+ElementUi电商购物个性化商城推荐系统gqfe

nodejs+vue+ElementUi电商购物个性化商城推荐系统gqfe

电本电商个性化推荐系统是为了提高用户查阅信息的效率和管理人员管理信息的工作效率&#xff0c;可以快速存储大量数据&#xff0c;还有信息检索功能&#xff0c;这大大的满足了用户和管理员这二者的需求。操作简单易懂&#xff0c;合理分析各个模块的功能&#xff0c;尽可能优…
阅读更多...
git将项目的某次签入遴选（Cherry-Pick）另一个项目

git将项目的某次签入遴选（Cherry-Pick）另一个项目

需求&#xff1a;将项目Product&#xff0c;分支feature/platform&#xff0c;签入959294ce6b75ee48c5cb22c46d7398654628a896&#xff0c;遴选到项目BRP&#xff0c;分支dev 第一步&#xff1a;使用原签入生成patch文件&#xff08;git format-patch -1 <commit_hash>&a…
阅读更多...
MySQL原理（一）架构组成之物理文件组成

MySQL原理（一）架构组成之物理文件组成

目录 一、日志文件 1、错误日志 Error Log 1.1、作用&#xff1a; 1.2、开启关闭&#xff1a; 1.3、使用 2、二进制日志 Binary Log & Binary Log Index 2.1、作用&#xff1a; 2.2、开启关闭&#xff1a; 2.3、Binlog还有一些附加选项参数 &#xff08;1&#x…
阅读更多...
Linux系统-学习

Linux系统-学习

文章目录 Linux系统-学习 1、自由开源 Linux操作系统完全免费且可用作开源软件&#xff0c;通过开源方式&#xff0c;您可以轻松查看用于创建Linux内核的可用代码&#xff0c;还可以修改代码以修复任何错误等。它提供有许多编程接口&#xff0c;您甚至可以开发自己的程序并将其…
阅读更多...
2.1总结

2.1总结

还是一样水更一天&#xff0c;就随便做了几个题&#xff0c;有一个周期有点长&#xff0c;后面更一篇长的 随手刷的一道水题&#xff0c;就不往今天的行程单添了 问题&#xff1a;最大公约数 题解&#xff1a;题目太水了&#xff0c;就是求三个数&#xff0c;其中两组的最大公…
阅读更多...
rancher证书过期问题处理

rancher证书过期问题处理

问题 起初&#xff0c;打开rancher ui页面打不开&#xff0c;telnet rancher的服务端口也不通。查看rancher 控制节点&#xff0c;日志显示&#xff0c;X509&#xff1a;certificate has expired or is not ye valid。证书已过期 解决 现在网上大部分的解决方案都是针对的2…
阅读更多...
基于51单片机的加油站计费系统

基于51单片机的加油站计费系统

基于51单片机的加油站计费系统[proteus仿真] 计费检测系统这个题目算是课程设计和毕业设计中常见的题目了&#xff0c;本期是一个108基于51单片机的加油站计费系统 需要的源文件和程序的小伙伴可以关注公众号【阿目分享嵌入式】&#xff0c;赞赏任意文章 2&#xffe5;&#…
阅读更多...
《C程序设计》上机实验报告（五）之一维数组二维数组与字符数组

《C程序设计》上机实验报告（五）之一维数组二维数组与字符数组

实验内容&#xff1a; 1.运行程序 #include <stdio.h> void main( ) { int i,j,iRow0,iCol0,m; int x[3][4]{{1,11,22,33},{2,28,98,38},{3,85,20,89}}; mx[0][0]; for(i0;i<3;i) for(j0;j<4;j) if (x[i][j]>m) { mx[i][j]; iRowi…
阅读更多...
最新文章

Copyright @ 2022~2023