mq安装教程

bubbleJessica

已于 2024-05-19 14:32:46 修改

阅读量836

点赞数 20

分类专栏：中间件文章标签： java 开发语言

于 2024-05-09 01:10:08 首次发布

本文链接：https://blog.csdn.net/bubblejessica/article/details/138588899

版权

中间件专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一：从本地加载

docker load -i mq.tar

二：安装MQ

执行下面的命令来运行MQ容器：

docker run \
-e RABBITMQ_DEFAULT_USER=itcast \
-e RABBITMQ_DEFAULT_PASS=123321 \
--name mq \
--hostname mq1 \
-p 15672:15672 \
-p 5672:5672 \
-d \
rabbitmq:3.8-management

三：查看mq状态

docker ps

四：之前启动过想重新运行（二换成四）

docker start mq

通过自己虚拟机ip+端口号即可访问RabbitMQ官网

详细操作

public class PublisherTest {
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.101.130");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.发送消息
        String message = "hello, rabbitmq!";
        channel.basicPublish("", queueName, null, message.getBytes());
        System.out.println("发送消息成功：【" + message + "】");

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

    }
}

建立连接执行完之后，mq界面就显示如下：

创建通道后如图

创建队列和发送消息后界面如图

public class ConsumerTest {

    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.101.130");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }
}

建立连接执行完之后，mq界面就显示如下：

创建通道后如图

创建队列和接收消息后界面如图

Spring AMQP应用间消息通信协议

官方地址

入门案例

步骤一：引入依赖

<!--AMQP依赖，包含RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

步骤二：在发布者中配置mq地址信息

spring:
  rabbitmq:
    host: 192.168.101.130 # rabbitMQ的ip地址
    port: 5672 # 端口
    username: itcast
    password: 123321
    virtual-host: /

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendMessage2SimpleQueue(){
        String queueName="simple.queue";
        String message="hello.spring amqp!";
        rabbitTemplate.convertAndSend(queueName,message);
    }
}

步骤三：在消费者中配置mq地址信息

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:23
 * @description
 */
@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueue(String msg) {
        System.out.println("消费者接收到simple.queue的消息：【" + msg + "】");
    }
}

消息消费掉确实没了

WorkQueue

生产者

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendMessage2WorkQueue() throws InterruptedException {
        String queueName = "simple.queue";
        String message = "hello.message__";
        for (int i = 1; i <= 50; i++) {
            rabbitTemplate.convertAndSend(queueName, message + i);
            Thread.sleep(20);
        }

    }
}

消费者

@Component
public class SpringRabbitListener {

    /*
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueue(String msg) {
        System.out.println("消费者接收到simple.queue的消息：【" + msg + "】");
    }
    */

    @RabbitListener(queues = "simple.queue")
    public void listenWorkQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
        Thread.sleep(20);
    }

    @RabbitListener(queues = "simple.queue")
    public void listenWorkQueue2(String msg) throws InterruptedException {
        System.err.println("消费者2接收到消息：【" + msg + "】" + LocalTime.now());
        Thread.sleep(200);
    }
}

为了保证能者多劳，需要再配置文件设置prefetch参数

spring:
  rabbitmq:
    host: 192.168.101.130 # rabbitMQ的ip地址
    port: 5672 # 端口
    username: itcast
    password: 123321
    virtual-host: /
    listener:
      simple:
        prefetch: 1

上面两种队列SimpleQueue和WorkQueue都是每条消息只被一个消费者接收

三种交换机

FanoutExchange

消费者配置

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:48
 * @description
 */
@Configuration
public class FanoutConfig {
    // itcast.fanout
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("itcast.fanout");
    }

    // fanout.queue1
    @Bean
    public Queue fanoutQueue1() {
        return new Queue("fanout.queue1");
    }

    // 绑定队列1到交换机
    @Bean
    public Binding fanoutBinding1(Queue fanoutQueue1, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }

    // fanout.queue2
    @Bean
    public Queue fanoutQueue2() {
        return new Queue("fanout.queue2");
    }

    // 绑定队列2到交换机
    @Bean
    public Binding fanoutBinding2(Queue fanoutQueue2, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
}

监听器

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:23
 * @description
 */
@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "fanout.queue1")
    public void listenFanoutQueue1(String msg) {
        System.out.println("消费者接收到fanout.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(queues = "fanout.queue2")
    public void listenFanoutQueue2(String msg) {
        System.out.println("消费者接收到fanout.queue2的消息：【" + msg + "】");
    }
}

启动完看到mq界面有itcast.fanout

生产者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:14
 * @description
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendFanoutExchange() {
        // 交换机名称
        String exchangeName = "itcast.fanout";
        // 消息
        String message = "hello,every one!";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "", message);
    }
}

DirectExchange

消费者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:23
 * @description
 */
@Component
public class SpringRabbitListener {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","blue"}
    ))
    public void listenDirectQueue1(String msg){
        System.out.println("消费者接收到direct.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name = "itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","yellow"}
    ))
    public void listenDirectQueue2(String msg){
        System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
    }
}

生产者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:14
 * @description
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    
    @Test
    public void testSendDirectExchange() {
        // 交换机名称
        String exchangeName = "itcast.direct";
        // 消息
        String message = "hello,red!";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "red", message);
    }
}

TopicExchange

通配符#代表0~多个，*代表一个

消费者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:23
 * @description
 */
@Component
public class SpringRabbitListener {


    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
            key = "china.#"
    ))
    public void listenTopicQueue1(String msg) {
        System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
            key = "#.news"
    ))
    public void listenTopicQueue2(String msg) {
        System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
    }
}

生产者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:14
 * @description
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendTopicExchange() {
        // 交换机名称
        String exchangeName = "itcast.topic";
        // 消息
        String message = "今天天气不错，我的心情好极了！";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "china.weather", message);
    }
}

消息转换器

消费者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:48
 * @description
 */
@Configuration
public class FanoutConfig {
    
    @Bean
    public Queue objectQueue() {
        return new Queue("object.queue");
    }
}

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:23
 * @description
 */
@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "object.queue")
    public void listenObjectQueue(Map<String,Object> msg){
        System.out.println("消费者接收到object.queue的消息：【" + msg + "】");
    }

}

生产者

/**
 * @version 1.0
 * @Author 胡胡
 * @Date 2024/5/8 23:14
 * @description
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendObjectQueue() {
        Map<String, Object> msg = new HashMap<String, Object>();
        msg.put("name", "杨紫");
        msg.put("age", 21);
        rabbitTemplate.convertAndSend("object.queue", msg);
    }
}

java序列化意味着把对象给序列化，性能差安全低，数据长度太长，传输速度太慢，占用额外内存

引入依赖

<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
</dependency>

生产者消费者主程序配置转换器

@Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }

mq安装教程

一：从本地加载

二：安装MQ

三：查看mq状态

四：之前启动过想重新运行（二换成四）

详细操作

建立连接执行完之后，mq界面就显示如下：

创建通道后如图

创建队列和发送消息后界面如图

建立连接执行完之后，mq界面就显示如下：

创建通道后如图

创建队列和接收消息后界面如图

Spring AMQP应用间消息通信协议

入门案例

步骤一：引入依赖

步骤二：在发布者中配置mq地址信息

步骤三： 在消费者中配置mq地址信息

WorkQueue

三种交换机

FanoutExchange

消费者配置

监听器

生产者

DirectExchange

消费者

生产者

TopicExchange

消费者

生产者

消息转换器

消费者

生产者

引入依赖

生产者消费者主程序配置转换器

步骤三：在消费者中配置mq地址信息