首页手记 MQ项目开发资料：新手入门指南

MQ项目开发资料：新手入门指南

标签：

Java 微服务

概述

本文提供了MQ项目开发的相关资料，涵盖MQ的基本概念、开发环境搭建、基础教程、进阶技巧以及常见问题解决方案。文章详细介绍了MQ的启动与停止、消息发送与接收、消息确认与事务处理等内容，帮助开发者更好地理解和开发MQ项目。

MQ简介与基本概念

什么是MQ

消息队列（Message Queue，简称MQ）是一种中间件技术，用于在分布式系统中异步传递数据。它允许多个应用程序通过非直接连接来通信，实现了模块间解耦，简化了系统架构。消息队列支持在完全不同的环境中进行通信，例如支持跨网络、跨进程、甚至跨平台的通信。它对于构建大规模的分布式系统尤其重要，能够处理大量的并发请求和消息。

MQ的基本功能与特点

异步通信：通过事件驱动的模式，发送方发送消息后立即返回，接收方在准备好接收时进行处理。
解耦：消息队列能够将发送方和接收方解耦，使得发送方无需关心接收方的状态。
削峰填谷：在高峰期业务量大时，消息队列可以处理大量的请求，然后慢慢消费，实现削峰填谷的效果。
可靠传输：通过消息确认机制确保消息的可靠传输。
持久化：消息可以持久化存储，保证消息不丢失。
负载均衡：可以将消息分摊到多个消息队列中，以实现负载均衡。

MQ的工作原理简述

消息队列的工作流程包括以下步骤：

发送方发送消息：应用程序将消息发送到消息队列。
消息存储：消息被存储在队列中，直到被接收方消费。
消息消费：接收方从队列中获取消息并进行处理。
消息确认：接收方通过确认消息来通知发送方消息已被处理。

消息队列通常具有以下组件：

消息生产者：负责发送消息到消息队列。
消息队列：负责存储消息。
消息消费者：负责从消息队列中获取消息并进行处理。
消息中间件：负责管理消息队列，包括消息的存储、转发和确认等操作。

MQ项目开发环境搭建

开发工具与环境要求

为了开发MQ项目，需要安装并配置以下几个工具：

MQ中间件：选择一个消息队列中间件，例如Apache Kafka、RabbitMQ、ActiveMQ等。
开发环境：安装开发工具，如Java开发工具（IDEA、Eclipse）或Python开发环境（PyCharm、VS Code）。
依赖库：根据选择的中间件，安装相应的客户端库和SDK。

例如，对于RabbitMQ，可以使用Java的AMQP客户端库rabbitmq-client。以下是安装此库的方法：

mvn install:install-file -Dfile=/path/to/amqp-client.jar -DgroupId=com.rabbitmq -DartifactId=amqp-client -Dversion=3.8.5 -Dpackaging=jar

对于其他开发环境，如C#，可以使用.NET的RabbitMQ.Client库。以下是安装此库的方法：

dotnet add package RabbitMQ.Client

MQ服务器安装与配置

安装步骤

下载：从官方网站下载MQ的安装包。
解压：将安装包解压到指定目录。
配置：编辑配置文件，配置服务器端口、连接数等参数。

例如，安装RabbitMQ时，可以使用以下命令：

# 下载RabbitMQ
wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.9.19/rabbitmq-server-generic-unix-3.9.19.tar.xz
# 解压
tar -xvf rabbitmq-server-generic-unix-3.9.19.tar.xz
cd rabbitmq_server-3.9.19
# 启动RabbitMQ服务器
./sbin/rabbitmq-server

对于其他中间件，如Apache Kafka，可以使用以下命令：

# 下载Kafka
wget http://mirror.beyondhosting.net/apache/kafka/2.8.0/kafka_2.13-2.8.0.tgz
# 解压
tar -xvf kafka_2.13-2.8.0.tgz
cd kafka_2.13-2.8.0
# 启动Kafka服务器
bin/zookeeper-server-start.sh config/zookeeper.properties
bin/kafka-server-start.sh config/server.properties

对于ActiveMQ，可以使用以下命令：

# 下载ActiveMQ
wget http://archive.apache.org/dist/activemq/5.15.10/apache-activemq-5.15.10-bin.tar.gz
# 解压
tar -xvf apache-activemq-5.15.10-bin.tar.gz
cd apache-activemq-5.15.10
# 启动ActiveMQ服务器
bin/macosx/activemq start

配置步骤

修改rabbitmq.conf文件来配置RabbitMQ服务器：

# 设置监听地址和端口
network_tick_timeout = 120
network_recovery_interval = 60
listeners.tcp.default = 5672

对于其他中间件，如Apache Kafka和ActiveMQ，配置文件路径和内容可能会有所不同，请参考其官方文档进行配置。

开发环境设置与调试

开发工具配置

在IDE中配置MQ客户端库，例如在Eclipse中配置RabbitMQ客户端库：

新建项目：在Eclipse中新建Java项目。
添加库文件：右键项目，选择Build Path -> Configure Build Path，在Libraries标签页点击Add Jars，添加RabbitMQ客户端库。

调试配置

编写Java代码时，可以通过IDE调试功能来测试代码。

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

public class MQExample {
    private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            String message = "Hello, RabbitMQ!";
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

MQ项目开发基础教程

MQ项目的启动与停止

启动MQ服务器

启动MQ服务器的命令依赖于具体的中间件。例如，启动RabbitMQ服务器：

# 启动RabbitMQ服务器
./sbin/rabbitmq-server

对于其他中间件，如Apache Kafka和ActiveMQ，启动命令有所不同，请参考其官方文档进行配置。

停止MQ服务器

停止MQ服务器的方法如下：

# 停止RabbitMQ服务器
./sbin/rabbitmqctl stop

对于其他中间件，如Apache Kafka和ActiveMQ，停止命令有所不同，请参考其官方文档进行配置。

停止RabbitMQ服务器的Java代码示例

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

public class RabbitMQStop {
    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare("test_queue", false, false, false, null);
            channel.queueDelete("test_queue");
        }
    }
}

基本消息的发送与接收

发送消息

发送消息的基本步骤如下：

建立连接：创建连接工厂，设置主机地址。
创建信道：通过连接创建信道。
声明队列：创建消息队列。
发送消息：将消息发送到队列。

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

public class MQSender {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (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(" [x] Sent '" + message + "'");
        }
    }
}

接收消息

接收消息的基本步骤如下：

建立连接：创建连接工厂，设置主机地址。
创建信道：通过连接创建信道。
声明队列：创建消息队列。
接收消息：从队列中接收消息。

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.DeliverCallback;

public class MQReceiver {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            DeliverCallback callback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            };
            channel.basicConsume(QUEUE_NAME, true, callback, consumerTag -> {});
        }
    }
}

消息队列与主题的创建与管理

创建消息队列

创建消息队列的基本步骤如下：

建立连接：创建连接工厂，设置主机地址。
创建信道：通过连接创建信道。
声明队列：创建一个消息队列。

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

public class QueueCreator {
    private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            System.out.println("Queue created: " + QUEUE_NAME);
        }
    }
}

管理消息队列

管理消息队列可以包括删除队列、查看队列状态等操作。

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

public class QueueManager {
    private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            channel.queueDelete(QUEUE_NAME);
            System.out.println("Queue deleted: " + QUEUE_NAME);
        }
    }
}

MQ项目开发进阶技巧

消息确认与事务处理

消息确认

消息确认是确保消息可靠传输的一种机制，接收方在处理完消息后，通过确认消息来通知发送方。如果接收方出现错误，可以通过重新发送消息来确保消息的可靠传输。

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.DeliverCallback;

public class MQReceiverWithAck {
    private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            DeliverCallback callback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
                // 模拟处理时间
                Thread.sleep(1000);
                System.out.println(" [x] Done");
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            };
            channel.basicConsume(QUEUE_NAME, false, callback, consumerTag -> {});
        }
    }
}

事务处理

事务处理可以确保一组操作要么全部完成，要么全部不完成。在发送方和接收方之间，可以使用事务来确保消息的一致性。

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

public class MQSenderWithTx {
    private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.txSelect();
            String message = "Hello, RabbitMQ!";
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
            channel.txCommit();
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

消息过滤与路由配置

消息过滤

消息过滤可以通过设置不同的过滤规则来决定哪些消息被接收。例如，可以基于消息的内容或消息的属性来过滤消息。

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.DeliverCallback;

public class MQReceiverWithFilter {
    private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            DeliverCallback callback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                if (message.contains("filter")) {
                    System.out.println(" [x] Received '" + message + "'");
                }
            };
            channel.basicConsume(QUEUE_NAME, true, callback, consumerTag -> {});
        }
    }
}

路由配置

路由配置可以将消息发送到不同的队列，例如可以通过交换机（Exchange）来实现消息的路由。

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

public class MQSenderWithRouting {
    private final static String EXCHANGE_NAME = "test_exchange";
    private final static String ROUTING_KEY = "key2";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            String message = "Hello, Routing!";
            channel.exchangeDeclare(EXCHANGE_NAME, "direct");
            channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

安全性设置与权限管理

安全性设置

安全性设置包括设置用户和权限，以及设置消息队列的安全访问规则。

# 添加用户并设置密码
rabbitmqctl add_user myuser mypassword
rabbitmqctl set_user_password myuser mypassword

# 设置用户权限
rabbitmqctl set_permissions -p / myuser ".*" ".*" ".*"

权限管理

权限管理包括设置队列的读写权限，以及设置消息的访问控制。

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

public class MQPermissionManager {
    private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            // 设置权限
            channel.queueBind(QUEUE_NAME, "exchange_name", "routing_key");
            System.out.println("Permissions set for queue: " + QUEUE_NAME);
        }
    }
}

常见问题与解决方案

常见错误代码及解决方法

MQ中间件在运行过程中可能会出现各种错误，常见的错误代码和解决方法如下：

403 Forbidden：权限不足。需要检查用户的权限配置，确保用户有访问队列的权限。
404 Not Found：队列不存在。需要检查队列名称是否正确，以及队列是否已经创建。
500 Internal Server Error：服务器内部错误。需要检查服务器日志，查找具体的错误原因。

# 查看RabbitMQ服务器日志
rabbitmqctl status
rabbitmqctl list_queues
rabbitmqctl list_exchanges

性能优化与资源管理

性能优化

性能优化包括以下几个方面：

优化队列设置：合理设置队列的持久化、自动删除等属性。
优化消息处理：优化消息处理逻辑，减少消息处理时间。
优化连接配置：合理设置连接池大小、连接超时时间等参数。

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

public class MQPerformanceOptimizer {
    private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);
            System.out.println("Queue optimized: " + QUEUE_NAME);
        }
    }
}

资源管理

资源管理包括以下几个方面：

监控资源使用情况：监控CPU、内存等资源使用情况。
合理分配资源：根据业务需求合理分配资源，避免资源浪费。
资源回收：合理设置资源回收策略，避免资源泄露。

# 监控RabbitMQ资源使用情况
rabbitmqctl top

日志分析与故障排查

日志分析

日志分析可以帮助我们了解MQ系统的运行情况，发现潜在的问题。

# 查看RabbitMQ日志文件
tail -f /var/log/rabbitmq/rabbit@localhost.log

故障排查

故障排查包括以下几个方面：

查看日志文件：查看系统日志文件，查找错误信息。
检查配置文件：检查配置文件，确保配置正确。
重启服务：尝试重启MQ服务，解决一些临时性的问题。

# 重启RabbitMQ服务
rabbitmqctl stop
rabbitmqctl start

开发实践与项目案例

实际项目中的MQ应用案例

在实际项目中，MQ经常用于以下几个场景：

异步通信：例如在电商平台中，订单创建后，可以通过MQ异步通知库存系统更新库存。
削峰填谷：在节假日高峰时期，可以通过MQ实现削峰填谷，保证系统稳定运行。
数据同步：例如在多个数据库之间进行数据同步时，可以通过MQ实现数据的实时同步。

异步通信案例

以下是一个电商平台订单创建的异步通信示例：

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

public class OrderCreation {
    private final static String QUEUE_NAME = "order_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            String message = "Create new order";
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.DeliverCallback;

public class InventoryUpdate {
    private final static String QUEUE_NAME = "order_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            DeliverCallback callback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
                // 更新库存
            };
            channel.basicConsume(QUEUE_NAME, true, callback, consumerTag -> {});
        }
    }
}

削峰填谷案例

削峰填谷可以通过MQ实现，在节假日高峰时期，系统可以将大量请求缓存到MQ中，然后慢慢处理，保证系统稳定运行。

数据同步案例

数据同步可以通过MQ实现，在多个数据库之间进行数据同步时，可以通过MQ实现数据的实时同步。

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

public class DataSync {
    private final static String QUEUE_NAME = "sync_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            String message = "Sync data";
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.DeliverCallback;

public class DatabaseSync {
    private final static String QUEUE_NAME = "sync_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            DeliverCallback callback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
                // 同步数据到数据库
            };
            channel.basicConsume(QUEUE_NAME, true, callback, consumerTag -> {});
        }
    }
}

MQ与其他系统的集成实例

MQ可以与各种系统集成，例如数据库、web服务等。以下是一个MQ与数据库集成的示例：

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

public class DataSync {
    private final static String QUEUE_NAME = "sync_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            String message = "Sync data";
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.DeliverCallback;

public class DatabaseSync {
    private final static String QUEUE_NAME = "sync_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            DeliverCallback callback = (consumerTag, delivery) -> {
                String message = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
                // 同步数据到数据库
            };
            channel.basicConsume(QUEUE_NAME, true, callback, consumerTag -> {});
        }
    }
}

开发过程中的注意事项与经验分享

注意事项

异步处理：确保消息的异步处理逻辑正确，避免阻塞。
错误处理：合理处理错误，避免消息丢失或重复。
性能优化：合理配置队列和消息处理逻辑，提高系统性能。

经验分享

单元测试：编写单元测试，确保消息发送和接收的正确性。
日志记录：合理记录日志，便于日后的调试和分析。
监控与报警：设置监控和报警机制，及时发现并解决问题。

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

public class MQTesting {
    private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            String message = "Test message";
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

通过以上详细的指南，您可以更好地理解和开发MQ项目。希望这些示例和建议能够帮助您在开发过程中取得成功。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕森卡

手记
篇

粉丝

121

获赞与收藏

529

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19487 316

Java 并发原理入门教程

26个小节 39343 571

Java 入门教程

50个小节 344658 3187

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空