SpringBoot整合RabbitMQ消息中间件及多种设计模式

最新推荐文章于 2022-06-22 16:18:42 发布
最新推荐文章于 2022-06-22 16:18:42 发布
阅读量273 收藏
点赞数
分类专栏： SpringCloud微服务 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46146718/article/details/115371552
版权

SpringBoot整合RabbitMQ消息中间件及多种设计模式

1、介绍与安装下载

1.1、不同MQ特点

不同MQ特点

1.2、下载

步骤一
步骤二
下载

1.3、打开网址

RabbitMQ成功运行本地打开网址
账号密码都：guest
运行成功的样子

2、使用可视化配置

2.1、创建交换机

创建交换机

2.2、创建队列

队列要绑定交换机
创建队列
删除队列
删除队列

2.3、来宾用户详情

来宾用户

2.4、创建来宾用户

创建来宾用户

2.5、用户与虚拟主机进行绑定

绑定

代表可访问的虚拟主机

2.6、创建虚拟主机

创建虚拟主机
通信端口

3、五种常用的模式

3.1、导入依赖

        <!--    导入rabbitmq依赖-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.7.2</version>
        </dependency>

3.2、连接工具类

public class RabbitMqUtils {

    private static ConnectionFactory factory;

    static {
        factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/ems");
        factory.setUsername("ems");
        factory.setPassword("ems");
    }

    /**
     * 定义提供连接对象的方法
     * @return
     */
    public static Connection getConnection() {
        try {
            Connection connection = factory.newConnection();
            return connection;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 关闭连接   注意：一般消费者不用关闭连接 只用于生产者关闭连接
     *
     * @param channel
     * @param connection
     */
    public static void closeConnection(Channel channel, Connection connection) {
        try {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.3、第一种模式（HelloWorld）

图解

    //生产消息
    public void testSendMessage() throws IOException, TimeoutException {
        /*
        //创建连接mq的连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接rabbitmq主机
        connectionFactory.setHost("127.0.0.1");
        //设置端口号
        connectionFactory.setPort(5672);
        //设置连接那个虚拟主机
        connectionFactory.setVirtualHost("/ems");
        //设置访问虚拟主机的用户名和密码
        connectionFactory.setUsername("ems");
        connectionFactory.setPassword("ems");
        //获取连接对象
        Connection connection = connectionFactory.newConnection();
        */

        //通过工具类获取连接对象
        Connection connection = RabbitMqUtils.getConnection();
        //获取连接中通道
        Channel channel = connection.createChannel();

        //通道绑定对应消息队列(通道中存放的是消息)
        //参数1：队列名称，如果队列不存在则自动创建
        //参数2：用来定义队列特征是否要持久化
        //参数3：是否独占队列(true 就只能被当前连接使用)
        //参数4：是否在消费完成后自动删除队列
        //参数5：额外附加参数
        channel.queueDeclare("hello", false, false, false, null);

        //发布消息
        //参数1:交换机名称
        //参数2:队列的名称
        //参数3:传递消息额外设置
        //参数4:发布消息时的具体内容
        channel.basicPublish("", "hello", null, "hello rabbitmq".getBytes());

        /*channel.close();
        connection.close();*/
        //使用工具类关闭
        RabbitMqUtils.closeConnection(channel,connection);
    }

	//消费者
    public static void main(String[] args) throws IOException, TimeoutException {
        /*
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/ems");
        connectionFactory.setUsername("ems");
        connectionFactory.setPassword("ems");
        Connection connection = connectionFactory.newConnection();
        */
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();
        //生产者和消费者的参数要严格对应上
        channel.queueDeclare("hello", false, false, false, null);
        //消费消息
        //参数1：消费那个队列的消息，消息名称
        //参数2：开始消息的自动确认机制
        //参数3：消费时的回调接口
        channel.basicConsume("hello", true, new DefaultConsumer(channel) {
            //最后一个参数：消息队列中取出的消息
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("new String(body) = " + new String(body));
            }
        });
        //为了保持运行不能关闭
        //channel.close();
        //connection.close();
    }

3.4、第二种模式（work quene）

Work queues，也被称为（Task queues)，任务模型。当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。此时就可以使用work模型:让多个消费者绑定到一个队列，共同消费队列中的消息。队列中的消息一旦消费，就会消失，因此任务是不会被重复执行的。
图解

  1. 开发生产者
    public static void main(String[] args) throws IOException {
        //获取连接
        Connection connection = RabbitMqUtils.getConnection();
        //获取通道对象
        Channel channel = connection.createChannel();

        //通过通道声明队列
        channel.queueDeclare("work", true, false, false, null);

        for (int i = 0; i < 10; i++) {
            //生产消息
            channel.basicPublish("", "work", null, (i+"hello work quene").getBytes());
        }

        //关闭资源
        RabbitMqUtils.closeConnection(channel, connection);


    }
  1. 开发消费者-1
    public static void main(String[] args) throws IOException {
        //获取连接
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare("work", true, false, false, null);

        channel.basicConsume("work", true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者-1：" + new String(body));
            }
        });
    }
  1. 开发消费者-2
    public static void main(String[] args) throws IOException {
        //获取连接
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare("work", true, false, false, null);

        channel.basicConsume("work", true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者-2：" + new String(body));
            }
        });
    }
  1. 测试结果
    结果一
    结果二

总结:默认情况下，RabbitNQ将按顺序将每个消息发送给下一个使用者。平均而言，每个消费者都会收到相同数量的消息。这种分发消息的方式称为循环。

3.4.1、消息确认机制和能者多劳的实现

public class Customer1 {
    public static void main(String[] args) throws IOException {
        //获取连接
        Connection connection = RabbitMqUtils.getConnection();
        final Channel channel = connection.createChannel();
        //每一次只消费一个消息
        channel.basicQos(1);

        channel.queueDeclare("work", true, false, false, null);
        //参数1：队列名称，参数2：消息自动确认 true 消费者自动向rabbitmq确认消息消费 false 不会自动确认消息(即使被消费了但是队列中没被消费)
        channel.basicConsume("work", false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者-1：" + new String(body));
                //手动确认  参数1：手动确认消息标识    参数2：false每次确认一个
                //参数1：确认队列中那个具体消息，参数2：是否开启多个消息同时确定
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }
}

public class Customer2 {
    public static void main(String[] args) throws IOException {
        //获取连接
        Connection connection = RabbitMqUtils.getConnection();
        final Channel channel = connection.createChannel();
        channel.basicQos(1);
        channel.queueDeclare("work", true, false, false, null);

        channel.basicConsume("work", false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者-2：" + new String(body));
                //手动确认  参数1：手动确认消息标识    参数2：false每次确认一个
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }
}

结果一
结果二

3.5、第三种模式（fanout）

fanout扇出也称广播
图解

在广播模式下，消息发送流程是这样的:
可以有多个消费者
每个消费者有自己的queue (队列)
每个队列都要绑定到Exchange (交换机)
生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定。
交换机把消息发送给绑定过的所有队列
队列的消费者都能拿到消息。实现一条消息被多个消费者消费

  1. 开发生产者
public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();
        //将通道声名指定交换机    //参数1：交换机名称，参数2：交换机类型   fannout 广播类型
        channel.exchangeDeclare("logs","fanout");

        //发送消息,交换机名称，路由key此时没任何意义，持久化特性
        channel.basicPublish("logs","",null,"fanout type message".getBytes());

        RabbitMqUtils.closeConnection(channel,connection);
    }
}
  1. 消费者1、2、3
public class Customer1 {
    public static void main(String[] args) throws IOException {
        //获取链接对象
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();

        //通道绑定交换机
        channel.exchangeDeclare("logs", "fanout");

        //临时队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定交换机和队列
        channel.queueBind(queueName, "logs", "");

        //消费信息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1：" + new String(body));
            }
        });
    }
}

效果截图

3.6、第四种模式（Routing）

3.6.1、Routing之订阅模型-Direct（直连）

在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

在Direct模型下:

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey(路由key)
  • 消息的发送方在向Exchange发送消息时，也必须指定消息的 RoutingKey 。
  • Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routing key与消息的Routing key完全一致，才会接收到消息
    流程
    图解
    图解
  • P:生产者，向Exchange发送消息，发送消息时，会指定一个routing key。
  • X: Exchange (交换机)，接收生产者的消息，然后把消息递交给与routing key完全匹配的队列
  • c1∶消费者，其所在队列指定了需要routing key 为error的消息
  • C2∶消费者，其所在队列指定了需要routing key为info、error、warning 的消息
  1. 开发生产者
public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();
        String exchangeName = "logs_direct";
        //通过通道声名交换机 参数1：交换机名称   参数2：direct  路由模式
        channel.exchangeDeclare(exchangeName, "direct");
        //发送信息
        String routingkey = "error";
        channel.basicPublish(exchangeName, routingkey, null, ("这是direct模型发布的基于route key:[" + routingkey + "]").getBytes());
        //关闭资源
        RabbitMqUtils.closeConnection(channel, connection);
    }
}
  1. 消费者1
public class Customer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();

        String exchangeName = "logs_direct";

        //通道声明交换机以及交换的类型
        channel.exchangeDeclare(exchangeName, "direct");

        //创建一个临时队列
        String queueName = channel.queueDeclare().getQueue();

        //基于route key绑定队列和交换机，队列的名字，交换机，路由key
        channel.queueBind(queueName, exchangeName, "error");

        //获取消费的消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1:" + new String(body));
            }
        });
    }
}
  1. 消费者2
public class Customer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();

        String exchangeName="logs_direct";

        //通道声明交换机以及交换的类型
        channel.exchangeDeclare(exchangeName, "direct");

        //创建一个临时队列
        String queueName = channel.queueDeclare().getQueue();

        //基于route key绑定队列和交换机，队列的名字，交换机，路由key
        channel.queueBind(queueName, exchangeName, "info");
        channel.queueBind(queueName, exchangeName, "error");
        channel.queueBind(queueName, exchangeName, "warning");

        //获取消费的消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2:" + new String(body));
            }
        });
    }
}

结果截图
结果
结果

3.7、第五种模式（Topic）

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key的时候使用通配符!这种模型Routingkey一般都是由一个或多个单词组成，多个单词之间以""分割，例如: item.insert

图解

#统配符
	* (star) can substitute for exactly one word.匹配不多不少恰好1个词
	# (hash) can substitute for zero or more words.匹配一个或多个词
#如:
	audit.#		匹配audit.irs.corporate或者audit.irs等
	audit.		只能匹配audit.irs
  1. 生产者
public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();
        //声明交换机以及交换机类型 topic
        channel.exchangeDeclare("topics","topic");
        //发布消息
        String routekey ="user";
        channel.basicPublish("topics",routekey,null,("这里是topic动态路由模型,routekey:["+routekey+"]").getBytes());

        //关闭资源
        RabbitMqUtils.closeConnection(channel,connection);
    }
}
  1. 消费者1
public class Customer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();

        //声明交换机以及类型
        channel.exchangeDeclare("topics","topic");
        //创建一个临时队列
        String queue = channel.queueDeclare().getQueue();
        //绑定队列和交换机，动态通配符形式route key
        channel.queueBind(queue,"topics","*.user.*");

        //消费消息
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1："+new String(body));
            }
        });
    }
}
  1. 消费者2
public class Customer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMqUtils.getConnection();
        Channel channel = connection.createChannel();

        //声明交换机以及类型
        channel.exchangeDeclare("topics","topic");
        //创建一个临时队列
        String queue = channel.queueDeclare().getQueue();
        //绑定队列和交换机，动态通配符形式route key
        channel.queueBind(queue,"topics","#.user.#");

        //消费消息
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1："+new String(body));
            }
        });
    }
}

结果截图
结果截图

4、SpringBoot整合RabbitMQ

导入依赖

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

配置文件

spring.application.name=rabbitmq-springboot
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=ems
spring.rabbitmq.password=ems
spring.rabbitmq.virtual-host=/ems

4.1、第一种HelloWord

RabbitTemplate 用来简化操作RabbitMQ,使用的时候直接在项目中注入即可

@Component//持久化，非独占，不是自动删除队列
@RabbitListener(queuesToDeclare = @Queue(value = "hello"))
public class HelloCustomer {

    //代表从队列中取出消息的回调方法
    @RabbitHandler
    public void receivel(String message) {
        System.out.println("message=" + message);
    }
}

测试

@SpringBootTest
class RabbitmqSpringbootApplicationTests {

	//注入rabbitTemplate
	@Autowired
	private RabbitTemplate rabbitTemplate;

	//hello world
	@Test
	void contextLoads() {
		//队列的名称，发送的消息
		rabbitTemplate.convertAndSend("hello","hello world");
	}
}

4.2、第二种Work

生产者

@SpringBootTest
class RabbitmqSpringbootApplicationTests {

    //注入rabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    //work,公平分配
    @Test
    public void testWork() {
		for (int i = 0; i < 10; i++) {
			rabbitTemplate.convertAndSend("work", "work模型");
		}
    }

}

消费者

@Component
public class WorkCustomer {
    @RabbitListener(queuesToDeclare = @Queue("work"))//可以加载类上和方法上，直接加载方法上，这个方法会处理当前rabbitlistener所监听的队列
    public void receivel(String message){
        System.out.println("message1 ="+message);
    }

    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive2(String message){
        System.out.println("message2 ="+message);
    }
}

说明:默认在Spring AMOP实现中Work这种方式就是公平调度，如果需要实现能者多劳需要额外配置

4.3、第三种Publish/Subscribe

生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定。
交换机把消息发送给绑定过的所有队列
生产者

@SpringBootTest
class RabbitmqSpringbootApplicationTests {

    //注入rabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    //fanout 广播
    @Test
    public void testFanout(){
        //交换机名字，路由key没关系
        rabbitTemplate.convertAndSend("logs","","Fanout的模型发送的消息");
    }

}

消费者

@Component
public class FanoutCustomer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,//创建临时队列
                    exchange = @Exchange(value = "logs", type = "fanout")//绑定的交换机
            )
    })
    public void receive1(String message) {
        //先创建一个临时队列绑定交换机
        System.out.println("message1 =" + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,//创建临时队列
                    exchange = @Exchange(value = "logs", type = "fanout")//绑定的交换机
            )
    })
    public void receive2(String message) {
        //先创建一个临时队列绑定交换机
        System.out.println("message2 =" + message);
    }
}

4.4、第四种Route

生产者

@SpringBootTest
class RabbitmqSpringbootApplicationTests {

    //注入rabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    //route路由模式
    @Test
    public void testRoute(){
        //交换机名字，路由的key
        rabbitTemplate.convertAndSend("directs","info","发送info的key的路由信息");
    }
}

消费者

@Component
public class RouteCustomer {
    /**
     * 先创建一个临时队列绑定交换机
     * @param message
     */
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,//创建临时队列
                    exchange = @Exchange(value = "directs", type = "direct"),//自定义交换机名称和类型，类型默认direct
                    key = {"info", "error", "warn"}
            )
    })
    public void receive1(String message) {
        System.out.println("message1 =" + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,//创建临时队列
                    exchange = @Exchange(value = "directs", type = "direct"),//自定义交换机名称和类型，类型默认direct
                    key = {"error",}
            )
    })
    public void receive2(String message) {
        System.out.println("message2 =" + message);
    }
}

效果图
效果图

4.5、第五种Route

生产者

@SpringBootTest
class RabbitmqSpringbootApplicationTests {

    //注入rabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    //topic 动态路由    订阅模式
    @Test
    public void testTopic(){
        //交换机名字，路由的key
        rabbitTemplate.convertAndSend("topics","user.save","user.save 路由消息");
        rabbitTemplate.convertAndSend("topics","user.save.delete","user.save.delete 路由消息");
        rabbitTemplate.convertAndSend("topics","order.save","order.save 路由消息");
        rabbitTemplate.convertAndSend("topics","order.save.delete","order.save.delete 路由消息");
    }
}

消费者

@Component
public class TopicCustomer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(type = "topic",name = "topics"),
                    key = {"user.save","user.*"}
            )
    })
    public void receive1(String message){
        System.out.println("message1 =" + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(type = "topic",name = "topics"),
                    key = {"order.#","produce.#","user.*"}
            )
    })
    public void receive2(String message){
        System.out.println("message2 =" + message);
    }
}

效果图
效果图

5、MQ的应用场景

5.1、异步处理

场景

5.2、应用解耦

应用解耦

5.3、流量削峰

峰值

6、集群架构

6.1、普通集群

默i认情况下:RabitK0代理操作所需的所有数据/状态都将跨所有节点复制。这方面的一个例外是消息队列，默认情况下，消息队列位于一个节点上，尽管它们可以从所有节点看到和访问

架构图（有点像主备架构）
架构图

核心解决问题:当集群中某一时刻master节点宕机，可以对Quene中信息,进行备份

集群搭建

# 1.集群规划
node1 : 10.15.0.3	mq1		master	主节点
node2 : 10.15.0.4	mq2		repl1	副本节点
node3 : 10.15.8.5	mq3		repl2	副本节点

# 2.克隆三台机器主机名和ip映射（三台机器都要）
vim /etc/hosts加入:
		10.15.8.3 mq1
		18.15.0.4 mq2
		10.15.0.5 mq3
node1 : vim letc/hostname 加入:mq1
node2 : vim /etc/hostname 加入:mq2
node3 : vim /etc/hostname 加入:mq3

# 3.三个机器安装rabbitmq,并同步cookie文件,在node1上执行:
scp /var/lib/rabbitmq/.erlang.cookie root@mq2 : / var/lib/rabbitmq/
scp /var/lib/rabbitmq/.erlang.cookie root@mq3 : / var/lib/rabbitmq/

# 4.后台启动rabbitmq所有节点执行如下命令,启动成功访问管理界面:
rabbitmq-server -detached

# 5.在node2和node3执行加入集群命令:
1.关闭		rabbitmqctl stop_app
2.加入集群	rabbitmqctl join_cluster rabbitemq1
3.启动服务	rabbitmqctl start_app

# 6.查看集群状态,任意节点执行:
rabbitmqctl cluster_status

# 7.如果出现如下显示,集群搭建成功:
Cluster status of node rabbit@mq3 ...
[ {nodes , [ idisc , [ rabbit@mq1 , rabbit@mq2 , rabbit@mq3] 》]}.
frunning_nodes , [ rabbit@mq1 , rabbitemq2 , rabbit@mq3 ]}，
{cluster_name , <<"rabbit@mq1">>},
{partitions, [ ]},
{alarms, [ {rabbit@mq1 , []} , { rabbit@mq2,[ ]} , {rabbit@mq3,[]}H]

安装rabbitmq

（修改rabbitmq.config61行取消对{handshake_timeout,10000}}的注释，去掉行结尾逗号）
# 7.执行如下命令,启动rabbitmq中的插件管理
rabbitmq-plugins enable rabbitmq_management
#8.启动RabbitMQ的服务
systemctl start 	rabbitmq-server
systemctl restart 	rabbitmq-server
systemctl stop 		rabbitmq-server

安装包
安装包
集群的搭建

6.2、镜像集群（用的多）

解决了高可用，把主队列信息同步到不同的rabbit服务器

镝像队刭列机制就是将队列在三个节点之间设置主从关系，消息会在三个节点之间进行自动同步，且如果其中一个节点不可用，并不会导致消息丢失或服务不可用的情况，提升NO集群的整体高可用性。

在这里插入图片描述

集群架构

和烨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
消息中间件设计思路
bzxxzb的博客
01-09 586
文章目录五大核心组成协议AMQPMQTTOpenMessage协议Kafka协议持久化消息分发高可用主从共享主从同步多主集群同步部署多主集群转发部署模式Master-Slave 和 Broker-Cluster 的组合高可靠 五大核心组成 协议 持久化机制 消息分发机制 高可用设计 高可靠设计 协议 三要素 语法 语义 时序（同步） 消息中间件常见协议：OpenWire、AMQP、MQTT...
一个简易的消息中间件设计
weixin_43427644的博客
05-03 805
一个简易的消息中间件设计简要介绍什么是消息中间件？消息中间件的作用消息队列观察者模式设计与实现要求模块设计事件模块介绍服务器设计客户端设计结果展示出现的问题结尾 简要介绍 本项目采用了观察者模式，实现了一个具有发布订阅的功能的消息中间件。 功能：不同的客户端用户能够订阅自己感兴趣的事件类型，在该类型的事件发生之后消息中心会自动地将事件发送给注册过此事件类型的用户，用户自动接收并消费该事件。 github项目代码地址 什么是消息中间件？ 我们要设计一个消息中间件，首先要了解它的功能和定义。 根据百度百科释义，
Java Review - Java进程内部的消息中间件_Event Bus设计模式
热门推荐
小工匠
12-19 3万+
文章目录概述 概述 在工作中，我们都会使用到MQ 比如 Apache Kafka等，某subscriber在消息中间件上注册了某个topic（主题），当有消息发送到了该topic上之后，注册在该topic上的所有subscriber都将会收到消息 。 消息中间件提供了系统之间的异步处理机制。 主业务完成后即可向用户返回成功的通知，然后提交各种消息至消息中间件，这样注册在消息中间件的其他系统就可以顺利地接收通知了，然后执行各自的业务逻辑。消息中间件主要用于解决进程之间消息异步处理的解决方案，这里，我们
java通关整理-设计模式（单例模式、代理模式、观察者模式[引出redis、消息中间件]）
享受旅行中的VIP快乐
08-18 212
网上收集整理，仅做笔记参考学习 1.单例模式 确保一个类只有一个实例，并提供该实例的全局访问点。 优点： 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。 2、避免对资源的多重占用（比如写文件操作）。 懒汉式-线程不安全 懒汉式，顾名思义就是实例在用到的时候才去创建 1、懒汉式，线程不安全 是否 Lazy 初始化：是 是否多线程安全：否 实现难度：易 描述：这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单
消息中间件[1]—基本概述
qq_42642159的博客
11-11 222
一、消息中间件(MQ)的定义 其实并没有标准定义。一般认为，消息中间件属于分布式系统中一个子系统，关注于数据的发送和接收，利用高效可靠的异步消息传递机制对分布式系统中的其余各个子系统进行集成。 二、 为什么要用消息中间件？ 假设一个电商交易的场景，用户下单之后调用库存系统减库存，然后需要调用物流系统进行发货，如果交易、库存、物流是属于一个系统的，那么就是接口调用。但是随着系统的发展，各个模块越来越庞大、业务逻辑越来越复杂，必然是要做服务化和业务拆分的。这个时候就需要考虑这些系统之间如何交互，第一反应就是R
springboot整合stream使用rabbitmq作为消息中间件
12-13
springboot整合stream使用rabbitmq作为消息中间件
Springboot+RabbitMQ 消息中间件
04-16
SpringBoot集成RabbitMQ消息中间件的使用。消息管理中心，消息提供方，消息消费方，并实现消息提供返回的ack校验以及借用redis完成消息补偿机制。
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
SpringBoot整合Rabbitmq发送接收消息实战
09-15
SpringBoot整合Rabbitmq发送接收消息实战 另外，博主发起了SpringBoot整合Rabbitmq这一系列的gitchat交流会。刚兴趣的童鞋可以进入交流：https://gitbook.cn/gitchat/activity/5b90f9214fb1bd5c9acd4338 交流QQ：...
浅谈Spring中如何使用设计模式
08-26
主要介绍了浅谈Spring中如何使用设计模式，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
设计模式之适配器模式
12-23
java 23种设计模式 适配器模式，详细源码分析请看博客： http://blog.csdn.net/github_22022001/article/details/41516545
自定义springboot组件--基于模板模式对原生springboot的rabbitmq组件进行扩展
Instanceztt的博客
06-22 615
在我们的日常开发中,消息中间件已经成为了java研发工程师的一项必备技能,本文主要是基于对springboot原生组件的扩展开发,基于模板设计模式和静态代理模式,简化了队列路由的绑定,交由公共模板进行统一的绑定,并在公用模板中保证了消息的幂等性和消息的可靠性投递,将这些类似的代码抽离出来,让开发者只专注于业务逻辑的开发.整体实现思路: 将静态代理器和初始器交由spring容器管理 将初始化容器交给spring容器管理 2.4 申明公用基础属性 2.5定义sprin
RabbitMQ的安装，Spring中经典的9种设计模式，一定要记牢
m0_63175850的博客
11-08 1116
主流的消息队列 ===================================================================== 目前市场上主流的消息队列有4种： ActiveMQ RabbitMQ RocketMQ Kafka RabbitMQ并发性能好，而且部署相对容易，是目前很多企业使用的消息队列。 安装RabbitMQ ===================================================================
MongoDb + RabbitMQ 搭建系统通知模块
weixin_43967582的博客
02-25 2435
MongoDb + RabbitMQ 搭建系统通知模块 使用springboot实现 一、选择MongoDB和RabbitMQ理由 对于公告消息，本设计是设计为 为每个用户创建一条公告信息（原因是：方便记录用户对于消息的已读和未读状态，这样设计会更符合用户需求），因此设计两个表，message(存储消息及其发送者消息) 和 message_ref（存储接收者，及已读和新接收状态） 数据库选择为MongoDB，原因是MongoDB对于海量数据以及高并发情况下的读写数据很有优势，同时他的数据存储是以文档结构存
设计模式与框架
danielinbiti的专栏
03-11 2343
  目的 创建型 结构型
SpringBoot中如何监听两个不同源的RabbitMQ消息队列
huanghaopeng62的专栏
01-19 1万+
spring-boot如何配置监听两个不同的RabbitMQ由于前段时间在公司开发过程中碰到了一个问题，需要同时监听两个不同的rabbitMq，但是之前没有同时监听两个RabbitMq的情况，因此在同事的帮助下，成功实现了监听多个MQ。下面我给大家一步一步讲解下，也为自己做个笔记； 详细步骤：1. application.properties 文件配置：” u.rabbitmq.addresses=
消息中间件MQ（二）模式、应用场景、常用协议
weixin_42480489的博客
10-06 1961
1.消息中间件模式分类 1.1 点对点 1.2发布/订阅 2消息中间件应用场景 2.1异步通信 有些业务不想也不需要立即处理消息。消息队列提供了异步处理机制，允许用户把一个消息放入队列，但并不立即处理它。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。 2.2解耦 降低工程间的强依赖程度，针对异构系统进行适配。在项目启动之初来预测将来项目会碰到什么需求，是极其困难的。通过消息系统...
消息中间件 - RabbitMQ 六种模式
DJun的博客
08-24 815
官网链接 简单模式，work模式，Publish/Subscribe发布与订阅模式，Routing路由模式，Topics主题模式，RPC远程调用模式（远程调用，不太算MQ；不作介绍）； 第一、简单模式（Simple） public class SimpleProducer { String SIMPLE_QUEUE_NAME = "hello"; public static void main(String[] args) throws Exception { Conne
springboot整合rabbitmq消息转换器
最新发布
09-20
Spring Boot整合RabbitMQ的消息转换器可以通过配置进行实现。首先，需要引入相关的依赖包，例如`spring-boot-starter-amqp`。接下来，在配置文件中配置RabbitMQ的连接信息，例如`application.properties`文件中配置...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

和烨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值