rabbitmq入门（一）

漫漫人生路^_^

已于 2022-07-21 13:01:13 修改

阅读量337

点赞数

分类专栏：黑马程序员rabbitmq 文章标签： rabbitmq

于 2022-07-17 20:16:31 首次发布

本文为博主原创文章，未经博主允许不得转载

本文链接：https://blog.csdn.net/qq_46198929/article/details/125836088

版权

黑马程序员rabbitmq 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

在这里插入图片描述

1. 安装依赖环境

在线安装依赖环境：

yum install build-essential openssl openssl-devel unixODBC unixODBC-devel make gcc gcc-c++ kernel-devel m4 ncurses-devel tk tc xz

2. 安装Erlang

上传


# 安装
rpm -ivh erlang-18.3-1.el7.centos.x86_64.rpm

3.安装Socat

rpm -ivh socat-1.7.3.2-1.1.el7.x86_64.rpm

4.安装rabbitmq

rpm -ivh rabbitmq-server-3.6.5-1.noarch.rpm

5.命令

//开始
systemctl start rabbitmq-server
//停止
systemctl stop rabbitmq-server
//重启
systemctl restart rabbitmq-server
//查看状态
systemctl status rabbitmq-server

6. 开启管理界面及配置

# 开启管理界面
rabbitmq-plugins enable rabbitmq_management
# 修改默认配置信息
vim /usr/lib/rabbitmq/lib/rabbitmq_server-3.6.5/ebin/rabbit.app 
# 比如修改密码、配置等等，例如：loopback_users 中的 <<"guest">>,只保留guest

7.登录（http://192.168.57.128:15672/）

192.168.57.128为连接的主机号
初始用户和密码均为guest
在这里插入图片描述

8.Config file not found 的处理

在这里插入图片描述
（1）cp ./rabbitmq.config.example /etc/rabbitmq/rabbitmq.config
（2）浏览器页面登出再重新登录
（3）[root@java rabbitmq-server-3.6.5]# systemctl restart rabbitmq-server
（4）刷新rabbitmq管理控制台

在这里插入图片描述

9.生产者

新建空项目rabbitmq,创建两个module(maven ）
添加依赖

<dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.6.0</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>1.7.25</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.5</version>
        </dependency>

package com.itheima.producer;

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

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Producer_Helloworld {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.57.129");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

        //3.创建连接
        Connection connection=factory.newConnection();
        //4.创建Channel
        Channel channel=connection.createChannel();
        //5.创建队列Queue
        /*
        queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        参数：1. queue 队列名称
             2.durable 是否持久化，当mq重启后，还在
             3. exclusive 是否独占，只能有一个消费者监听这队列
                当Connection关闭时，是否删除队列
             4.autoDelete:是否自动删除 当没有Consumer时，自动删除掉
             5.arguments: 参数
         */
        //如果没有一个名叫hello_world的队列，则会创建该队列，如果有则不会创建
        channel.queueDeclare("hello_world",true,false,false,null);
        //6.发送消息
        /*
        basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
        1. exchange:交换机名称。简单模式下交换机会使用默认的
        2. routingKey：路由名称
        3.props：配置信息
        4.body:发送消息数据
         */
        String body="hello rabbitmq";

        channel.basicPublish("","hello_world",null,body.getBytes());

        //7.释放资源
        
        channel.close();
        connection.close();

        
    }
}

在这里插入图片描述

10.消费者

package com.itheima.consumer;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_Helloworld {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.57.129");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

        //3.创建连接
        Connection connection=factory.newConnection();
        //4.创建Channel
        Channel channel=connection.createChannel();
        //5.创建队列Queue
        /*
        queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        参数：1. queue 队列名称
             2.durable 是否持久化，当mq重启后，还在
             3. exclusive 是否独占，只能有一个消费者监听这队列
                当Connection关闭时，是否删除队列
             4.autoDelete:是否自动删除 当没有Consumer时，自动删除掉
             5.arguments: 参数
         */
        //如果没有一个名叫hello_world的队列，则会创建该队列，如果有则不会创建
        channel.queueDeclare("hello_world",true,false,false,null);
        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        1.queue:队列名称
        2.autoAck:是否自动确认
        3.callback:回调对象
         */
        //接收消息
        DefaultConsumer consumer= new DefaultConsumer(channel){
            /*
            1.consumerTag:标识
            2.envelope：获取一些信息，交换机，路由key
            3.properties:配置信息
            4.body:数据
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumerTag:"+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);
                System.out.println("body:"+new String(body));
            }

        };
        channel.basicConsume("hello_world",true,  consumer);


    }
}

11.工作队列模式

在这里插入图片描述

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

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Producer_workQueues {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.174.128");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

        //3.创建连接
        Connection connection=factory.newConnection();
        //4.创建Channel
        Channel channel=connection.createChannel();
        //5.创建队列Queue
        /*
        queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        参数：1. queue 队列名称
             2.durable 是否持久化，当mq重启后，还在
             3. exclusive 是否独占，只能有一个消费者监听这队列
                当Connection关闭时，是否删除队列
             4.autoDelete:是否自动删除 当没有Consumer时，自动删除掉
             5.arguments: 参数
         */
        //如果没有一个名叫hello_world的队列，则会创建该队列，如果有则不会创建
        channel.queueDeclare("work_queues",true,false,false,null);
        //6.发送消息
        /*
        basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
        1. exchange:交换机名称。简单模式下交换机会使用默认的
        2. routingKey：路由名称
        3.props：配置信息
        4.body:发送消息数据
         */
        for(int i=1;i<=10;i++){
            String body="hello rabbitmq"+i;
            channel.basicPublish("","work_queues",null,body.getBytes());
        }



        //7.释放资源
        /*


        channel.close();
        connection.close();

         */


    }
}

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_WorkQueues1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.174.128");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

        //3.创建连接
        Connection connection=factory.newConnection();
        //4.创建Channel
        Channel channel=connection.createChannel();
        //5.创建队列Queue
        /*
        queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        参数：1. queue 队列名称
             2.durable 是否持久化，当mq重启后，还在
             3. exclusive 是否独占，只能有一个消费者监听这队列
                当Connection关闭时，是否删除队列
             4.autoDelete:是否自动删除 当没有Consumer时，自动删除掉
             5.arguments: 参数
         */
        //如果没有一个名叫hello_world的队列，则会创建该队列，如果有则不会创建
        channel.queueDeclare("work_queues",true,false,false,null);
        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        1.queue:队列名称
        2.autoAck:是否自动确认
        3.callback:回调对象
         */
        //接收消息
        DefaultConsumer consumer= new DefaultConsumer(channel){
            /*
            1.consumerTag:标识
            2.envelope：获取一些信息，交换机，路由key
            3.properties:配置信息
            4.body:数据
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                /*
                System.out.println("consumerTag:"+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);

                 */
                System.out.println("body:"+new String(body));
            }

        };
        channel.basicConsume("work_queues",true,  consumer);


    }
}

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_WorkQueues2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.174.128");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

        //3.创建连接
        Connection connection=factory.newConnection();
        //4.创建Channel
        Channel channel=connection.createChannel();
        //5.创建队列Queue
        /*
        queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
        参数：1. queue 队列名称
             2.durable 是否持久化，当mq重启后，还在
             3. exclusive 是否独占，只能有一个消费者监听这队列
                当Connection关闭时，是否删除队列
             4.autoDelete:是否自动删除 当没有Consumer时，自动删除掉
             5.arguments: 参数
         */
        //如果没有一个名叫hello_world的队列，则会创建该队列，如果有则不会创建
        channel.queueDeclare("work_queues",true,false,false,null);
        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        1.queue:队列名称
        2.autoAck:是否自动确认
        3.callback:回调对象
         */
        //接收消息
        DefaultConsumer consumer= new DefaultConsumer(channel){
            /*
            1.consumerTag:标识
            2.envelope：获取一些信息，交换机，路由key
            3.properties:配置信息
            4.body:数据
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                /*
                System.out.println("consumerTag:"+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);

                 */
                System.out.println("body:"+new String(body));
            }

        };
        channel.basicConsume("work_queues",true,  consumer);


    }
}

12.订阅模式

在这里插入图片描述

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

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Producer_PubSub {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.174.128");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

        //3.创建连接
        Connection connection=factory.newConnection();
        //4.创建Channel
        Channel channel=connection.createChannel();
        /*
        exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments);
        1.exchange:交换机名称
        2.type:交换机类型
        DIRECT（”direct“）定向
        3.durable:是否持久化
        4.autoDelete:自动删除
        5.internal:内部使用
        6.arguments:参数
        */
        String exchangeName="test_fanout";

        //5.创建交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
        //6.创建队列
        String queueName1="test_fanout_queue1";
        String queueName2="test_fanout_queue2";

        channel.queueDeclare(queueName1,true,false,false,null);
        channel.queueDeclare(queueName2,true,false,false,null);
        //7.绑定队列和交换机
        /*
        queueBind(String queue, String exchange, String routingKey)
        1.queue:队列名称
        2.exchange：交换机名称
        3.routingKey:路由键，绑定规则
        如果交换机的类型为fanout,routingKey设置为”“
         */
        channel.queueBind(queueName1,exchangeName,"");
        channel.queueBind(queueName2,exchangeName,"");
        //8.发送消息
        String body="日志信息";
        channel.basicPublish(exchangeName,"",null,body.getBytes());
        //9.释放资源
        channel.close();
        connection.close();
    }
}

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_PubSub1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.174.128");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

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

        String queueName1="test_fanout_queue1";
        String queueName2="test_fanout_queue2";
        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        1.queue:队列名称
        2.autoAck:是否自动确认
        3.callback:回调对象
         */

        //接收消息


        DefaultConsumer consumer= new DefaultConsumer(channel){
            /*
            1.consumerTag:标识
            2.envelope：获取一些信息，交换机，路由key
            3.properties:配置信息
            4.body:数据
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                /*
                System.out.println("consumerTag:"+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);

                 */
                System.out.println("body:"+new String(body));
                System.out.println("将日志信息打印到控制台");
            }

        };
        channel.basicConsume(queueName1,true,  consumer);


    }
}

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_PubSub2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.174.128");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

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

        String queueName1="test_fanout_queue1";
        String queueName2="test_fanout_queue2";
        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        1.queue:队列名称
        2.autoAck:是否自动确认
        3.callback:回调对象
         */
        //接收消息
        DefaultConsumer consumer= new DefaultConsumer(channel){
            /*
            1.consumerTag:标识
            2.envelope：获取一些信息，交换机，路由key
            3.properties:配置信息
            4.body:数据
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                /*
                System.out.println("consumerTag:"+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);

                 */
                System.out.println("body:"+new String(body));
                System.out.println("将日志信息保存数据库");
            }

        };
        channel.basicConsume(queueName2,true,  consumer);


    }
}

13.路由模式

在这里插入图片描述

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

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Producer_Routing {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.86.128");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

        //3.创建连接
        Connection connection=factory.newConnection();
        //4.创建Channel
        Channel channel=connection.createChannel();
        /*
        exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments);
        1.exchange:交换机名称
        2.type:交换机类型
        DIRECT（”direct“）定向
        3.durable:是否持久化
        4.autoDelete:自动删除
        5.internal:内部使用
        6.arguments:参数
        */
        String exchangeName="test_direct";

        //5.创建交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT,true,false,false,null);
        //6.创建队列
        String queueName1="test_direct_queue1";
        String queueName2="test_direct_queue2";

        channel.queueDeclare(queueName1,true,false,false,null);
        channel.queueDeclare(queueName2,true,false,false,null);
        //7.绑定队列和交换机
        /*
        queueBind(String queue, String exchange, String routingKey)
        1.queue:队列名称
        2.exchange：交换机名称
        3.routingKey:路由键，绑定规则
        如果交换机的类型为fanout,routingKey设置为”“
         */
        channel.queueBind(queueName1,exchangeName,"error");
        channel.queueBind(queueName2,exchangeName,"info");
        channel.queueBind(queueName2,exchangeName,"error");
        channel.queueBind(queueName2,exchangeName,"warning");
        //8.发送消息
        String body="日志信息：张三调用了delete方法。。。级别error";
        channel.basicPublish(exchangeName,"warning",null,body.getBytes());
        //9.释放资源
        channel.close();
        connection.close();
    }
}

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_Routing1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.86.128");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

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

        String queueName1="test_direct_queue1";
        String queueName2="test_direct_queue2";
        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        1.queue:队列名称
        2.autoAck:是否自动确认
        3.callback:回调对象
         */

        //接收消息


        DefaultConsumer consumer= new DefaultConsumer(channel){
            /*
            1.consumerTag:标识
            2.envelope：获取一些信息，交换机，路由key
            3.properties:配置信息
            4.body:数据
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                /*
                System.out.println("consumerTag:"+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);

                 */
                System.out.println("body:"+new String(body));
                System.out.println("将日志信息打印到控制台");
            }

        };
        channel.basicConsume(queueName2,true,  consumer);


    }
}

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_Routing2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.86.128");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

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

        String queueName1="test_direct_queue1";
        String queueName2="test_direct_queue2";
        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        1.queue:队列名称
        2.autoAck:是否自动确认
        3.callback:回调对象
         */

        //接收消息


        DefaultConsumer consumer= new DefaultConsumer(channel){
            /*
            1.consumerTag:标识
            2.envelope：获取一些信息，交换机，路由key
            3.properties:配置信息
            4.body:数据
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                /*
                System.out.println("consumerTag:"+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);

                 */
                System.out.println("body:"+new String(body));
                System.out.println("将日志信息存取到数据库");
            }

        };
        channel.basicConsume(queueName1,true,  consumer);


    }
}

14.通配符模式

在这里插入图片描述

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

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Producer_Topics {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.86.128");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

        //3.创建连接
        Connection connection=factory.newConnection();
        //4.创建Channel
        Channel channel=connection.createChannel();
        /*
        exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments);
        1.exchange:交换机名称
        2.type:交换机类型
        DIRECT（”direct“）定向
        3.durable:是否持久化
        4.autoDelete:自动删除
        5.internal:内部使用
        6.arguments:参数
        */
        String exchangeName="test_topic";

        //5.创建交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,false,null);
        //6.创建队列
        String queueName1="test_topic_queue1";
        String queueName2="test_topic_queue2";

        channel.queueDeclare(queueName1,true,false,false,null);
        channel.queueDeclare(queueName2,true,false,false,null);
        //7.绑定队列和交换机
        /*
        queueBind(String queue, String exchange, String routingKey)
        1.queue:队列名称
        2.exchange：交换机名称
        3.routingKey:路由键，绑定规则
        如果交换机的类型为fanout,routingKey设置为”“
         */
        //routing key 系统的名称.日志的级别
        //
        channel.queueBind(queueName1,exchangeName,"#.error");
        channel.queueBind(queueName1,exchangeName,"order.*");
        channel.queueBind(queueName2,exchangeName,"*.*");

        //8.发送消息
        String body="日志信息";
        channel.basicPublish(exchangeName,"good.error",null,body.getBytes());
        //9.释放资源
        channel.close();
        connection.close();
    }
}

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_Topic1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.86.128");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

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

        String queueName1="test_topic_queue1";
        String queueName2="test_topic_queue2";
        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        1.queue:队列名称
        2.autoAck:是否自动确认
        3.callback:回调对象
         */

        //接收消息


        DefaultConsumer consumer= new DefaultConsumer(channel){
            /*
            1.consumerTag:标识
            2.envelope：获取一些信息，交换机，路由key
            3.properties:配置信息
            4.body:数据
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                /*
                System.out.println("consumerTag:"+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);

                 */
                System.out.println("body:"+new String(body));
                System.out.println("将日志信息存储到数据库");
            }

        };
        channel.basicConsume(queueName1,true,  consumer);


    }
}

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_Topic2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.86.128");//ip:默认值 localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值 /
        factory.setUsername("heima");
        factory.setPassword("heima");

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

        String queueName1="test_topic_queue1";
        String queueName2="test_topic_queue2";
        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        1.queue:队列名称
        2.autoAck:是否自动确认
        3.callback:回调对象
         */

        //接收消息


        DefaultConsumer consumer= new DefaultConsumer(channel){
            /*
            1.consumerTag:标识
            2.envelope：获取一些信息，交换机，路由key
            3.properties:配置信息
            4.body:数据
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                /*
                System.out.println("consumerTag:"+consumerTag);
                System.out.println("Exchange:"+envelope.getExchange());
                System.out.println("RoutingKey:"+envelope.getRoutingKey());
                System.out.println("properties:"+properties);

                 */
                System.out.println("body:"+new String(body));
                System.out.println("将日志信息打印控制台");
            }

        };
        channel.basicConsume(queueName2,true,  consumer);


    }
}

15.spring整合rabbitmq

spring-rabbitmq-producers模块

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>spring-rabbitmq-producers</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
            <version>2.1.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>



    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

rabbitmq.properties

rabbitmq.host=192.168.86.128
rabbitmq.port=5672
rabbitmq.username=heima
rabbitmq.password=heima
rabbitmq.virtual-host=/itcast

spring-rabbitmq-producer.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>
    <!--定义管理交换机、队列-->
    <rabbit:admin connection-factory="connectionFactory"/>

    <!--定义持久化队列，不存在则自动创建；不绑定到交换机则绑定到默认交换机
    默认交换机类型为direct，名字为：""，路由键为队列的名称
    -->
    <!--id:bean的名称
    name:queue的名称
    auto-declare:自动创建
    auto-delete:自动删除。最后一个消费者和该队列断开连接后，自动删除队列
    durable：是否持久化
    -->
    <rabbit:queue id="spring_queue" name="spring_queue" auto-declare="true"/>

    <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~广播；所有队列都能收到消息~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->


    <rabbit:queue id="spring_fanout_queue_1" name="spring_fanout_queue_1" auto-declare="true"/>

    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_fanout_queue_2" name="spring_fanout_queue_2" auto-declare="true"/>

    <!--定义广播类型交换机；并绑定上述两个队列-->
    <rabbit:fanout-exchange id="spring_fanout_exchange" name="spring_fanout_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding queue="spring_fanout_queue_1"/>
            <rabbit:binding queue="spring_fanout_queue_2"/>
        </rabbit:bindings>
    </rabbit:fanout-exchange>

    <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~通配符；*匹配一个单词，#匹配多个单词 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_topic_queue_star" name="spring_topic_queue_star" auto-declare="true"/>
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_topic_queue_well" name="spring_topic_queue_well" auto-declare="true"/>
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_topic_queue_well2" name="spring_topic_queue_well2" auto-declare="true"/>

    <rabbit:topic-exchange id="spring_topic_exchange" name="spring_topic_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding pattern="heima.*" queue="spring_topic_queue_star"/>
            <rabbit:binding pattern="heima.#" queue="spring_topic_queue_well"/>
            <rabbit:binding pattern="itcast.#" queue="spring_topic_queue_well2"/>
        </rabbit:bindings>
    </rabbit:topic-exchange>

    <!--定义rabbitTemplate对象操作可以在代码中方便发送消息-->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>
    <!--direct类型的交换机绑定队列 key:路由key queue:队列名称
    <rabbit:direct-exchange name="aa">

        <rabbit:bindings>
            <rabbit:binding queue="spring_queue" key=""></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-exchange>
    -->
</beans>

测试类

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
public class ProducerTest {
    @Autowired
    //1.注入RabbitTemplate

    private RabbitTemplate rabbitTemplate;

    @Test
    public void testHelloWorld(){
        //2.发送消息
        rabbitTemplate.convertAndSend("spring_queue","hello world spring");
    }

    @Test
    public void testFanout(){
        rabbitTemplate.convertAndSend("spring_fanout_exchange","","spring fanout...");
    }

    @Test
    public void testTopic(){
        rabbitTemplate.convertAndSend("spring_topic_exchange","heima.hehe.haha","spring topic...");
    }
}

spring-rabbitmq-consumers模块

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>spring-rabbitmq-consumers</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
            <version>2.1.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

rabbitmq.properties

rabbitmq.host=192.168.86.128
rabbitmq.port=5672
rabbitmq.username=heima
rabbitmq.password=heima
rabbitmq.virtual-host=/itcast

spring-rabbitmq-consumer.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>

    <bean id="springQueueListener" class="com.itheima.rabbitmq.listener.SpringQueueListener"/>
    <!--
    <bean id="fanoutListener1" class="com.itheima.rabbitmq.listener.FanoutListener1"/>
    <bean id="fanoutListener2" class="com.itheima.rabbitmq.listener.FanoutListener2"/>
    <bean id="topicListenerStar" class="com.itheima.rabbitmq.listener.TopicListenerStar"/>
    <bean id="topicListenerWell" class="com.itheima.rabbitmq.listener.TopicListenerWell"/>
    <bean id="topicListenerWell2" class="com.itheima.rabbitmq.listener.TopicListenerWell2"/>
    -->
    <rabbit:listener-container connection-factory="connectionFactory" auto-declare="true">
        <rabbit:listener ref="springQueueListener" queue-names="spring_queue"/>
        <!--
        <rabbit:listener ref="fanoutListener1" queue-names="spring_fanout_queue_1"/>
        <rabbit:listener ref="fanoutListener2" queue-names="spring_fanout_queue_2"/>
        <rabbit:listener ref="topicListenerStar" queue-names="spring_topic_queue_star"/>
        <rabbit:listener ref="topicListenerWell" queue-names="spring_topic_queue_well"/>
        <rabbit:listener ref="topicListenerWell2" queue-names="spring_topic_queue_well2"/>
        -->
    </rabbit:listener-container>
</beans>

SpringQueueListener类

package com.itheima.rabbitmq.listener;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;

public class SpringQueueListener implements MessageListener {
    @Override
    public void onMessage(Message message) {
        System.out.println(new String(message.getBody()));
    }
}

测试类

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq-consumer.xml")
public class ConsumerTest {
    @Test
    public  void test1(){
        while (true){

        }
    }
}

16.springboot整合RabbitMQ

producer-springboot模块

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>producer-springboot</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
</project>

RabbitMQConfig类

package com.itheima.rabbitmq.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {
    public static final String EXCHANGE_NAME="boot_topic_exchange";
    public static final String QUEUE_NAME="boot_queue";
    //1.交换机
    @Bean("bootExchange")
    public Exchange bootExchange(){
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }
    //2.Queue队列
    @Bean("bootQueue")
    public Queue bootQueue(){
        return  QueueBuilder.durable(QUEUE_NAME).build();
    }
    //3.队列和交换机绑定关系Binding
    /*
    1.知道那个队列
    2.知道那个交换机
    3.routing key
    */
    @Bean
    public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue,@Qualifier("bootExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
    }

}

ProducerApplication

package com.itheima;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class ProducerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProducerApplication.class);
    }
}

application.yml

spring:
  rabbitmq:
    host: 192.168.86.128 #ip
    port: 5672
    username: heima
    password: heima
    virtual-host: /itcast

ProducerTest

package com.itheima;

import com.itheima.rabbitmq.config.RabbitMQConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@SpringBootTest
@RunWith(SpringRunner.class)
public class ProducerTest {
    //1.注入RabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public  void testSend(){
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME,"boot.ha","mq springboot");
    }
}

consumer-springboot模块

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>consumer-springboot</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.1.4.RELEASE</version>
            </plugin>
        </plugins>
    </build>
</project>

application.yml

spring:
  rabbitmq:
    host: 192.168.86.128 #ip
    port: 5672
    username: heima
    password: heima
    virtual-host: /itcast

RabbitmtMQListener类

package com.itheima.listener;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class RabbitmtMQListener {
    @RabbitListener(queues = "boot_queue")
    public void ListenerQueue(Message message){
        System.out.println(new String(message.getBody()));
    }
}

ConsumerSpringbootApplication类

package com.itheima;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ConsumerSpringbootApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerSpringbootApplication.class);
    }
}