基于activeMQ broker cluster 集群 的高可用 多协议 物联网消息的架构设计

最新推荐文章于 2021-05-14 03:08:14 发布
最新推荐文章于 2021-05-14 03:08:14 发布
阅读量366 收藏 2
点赞数
分类专栏： activeMQ 文章标签： 嵌入式 网络 开发工具
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/annan211/article/details/84911570
版权
[size=large]
activeMQ是一款功能十分强大的消息中间件。
支持包括MQTT NIO 在内的多种协议，而且是jms的完美实现。当有数以百万计的终端设备需要连接到服务器时，适当处理和架构就可以对外提供功能强劲的服务能力。

首先需要解决activeMQ 单节点服务性能问题，切不可直接使用默认配置上生产。
可以自己百度 或者 参照 日志
http://m.blog.csdn.net/truong/article/details/73718621
http://blog.csdn.net/yinwenjie/article/details/50955502
http://blog.csdn.net/yinwenjie/article/details/50991443
http://blog.csdn.net/yinwenjie/article/details/51064242

单节点完成 则进行 集群搭建 一样参照博文
http://www.cnblogs.com/leihenqianshang/articles/5623858.html

搭建完成之后，高性能的服务架构已经出来了。这时候需要写一些测试代码。

[/size]

[size=large]
1 先写针对客户端和消费端都基于activeMQ API 的情况。生产者代码如下：
[/size] 


package com.sunshine.mq;
import javax.jms.Connection;  
import javax.jms.DeliveryMode;  
import javax.jms.JMSException;  
import javax.jms.MessageProducer;  
import javax.jms.Session;  
import javax.jms.TextMessage;  
import javax.jms.Topic;  

import org.apache.activemq.ActiveMQConnectionFactory;  

public class Producer {  

    public static void main(String[] args) throws JMSException {  
        // 连接到ActiveMQ服务器  
        //ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.15:61616)");
        //这里可以使用 failover 机制 进行多节点配置 达到高可用和后端负载均衡  
    	ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.15:1883)");
        Connection connection = factory.createConnection();  
        connection.start();  
        Session session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);  
        // 创建主题  
        Topic topic = session.createTopic("VirtualTopic.virtual-T.100990");  
        MessageProducer producer = session.createProducer(topic);  
        // NON_PERSISTENT 非持久化 PERSISTENT 持久化,发送消息时用使用持久模式  
        //producer.setDeliveryMode(DeliveryMode.PERSISTENT);  
        TextMessage message = session.createTextMessage();
        for(int i = 0;i<10;i++){
        	 message.setText("topic 消息。"+i);  
             message.setStringProperty("property", "消息Property");  
             // 发布主题消息  
             producer.send(message);  
             System.out.println("Sent message: " + message.getText()); 
        }

        session.close();  
        connection.close();  
    }  
}


[size=large]
我们需要多个消费者来消费消息以达到 分布式部署的目的
消费者1
[/size] 


package com.sunshine.mq;
import javax.jms.Connection;  
import javax.jms.JMSException;  
import javax.jms.Message;  
import javax.jms.MessageConsumer;  
import javax.jms.MessageListener;  
import javax.jms.Queue;  
import javax.jms.Session;  
import javax.jms.TextMessage;  



import org.apache.activemq.ActiveMQConnectionFactory;  

public class ConsumerA {  

    public static void main(String[] args) throws JMSException, InterruptedException {  
        // 连接到ActiveMQ服务器  
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:1888,tcp://172.16.7.18:1889)");
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.15:1887)");
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:61616,tcp://172.16.7.18:61616)");
    	ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:1883,tcp://172.16.7.18:1883)");
        Connection connection = factory.createConnection();  
        connection.start();  
        Session session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);  
        // 创建主题   
        Queue topicA = session.createQueue("Consumer.GG.VirtualTopic.virtual-T.*");  
        // 消费者A组创建订阅  
        MessageConsumer consumerA1 = session.createConsumer(topicA);
        Integer count = 0;
        while(true){
        	Message message = consumerA1.receive();
        	count++;
        	TextMessage msg = (TextMessage)message;
			final String messageText = msg.getText();
        	System.out.println(messageText +",消费消息总数为:"+count);
        }
        /**consumerA1.setMessageListener(new MessageListener() {  
            // 订阅接收方法  
            public void onMessage(Message message) {  
                TextMessage tm = (TextMessage) message;  
                try {  
                    System.out.println("A 收到消息: " + tm.getText()+":"+tm.getStringProperty("property"));  
                } catch (JMSException e) {  
                    e.printStackTrace();  
                }  
            }  
        });**/  

        //session.close();  
        //connection.close();  
    }  
}


[size=large]消费者2 [/size] 


package com.sunshine.mq;
import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

public class ConsumerB {  

    public static void main(String[] args) throws JMSException, InterruptedException {  
        // 连接到ActiveMQ服务器  
        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(nio://172.16.7.17:1888,nio://172.16.7.18:1889)");
//    	ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:61616,tcp://172.16.7.18:61616)");
        Connection connection = factory.createConnection();  
        connection.start(); 
        Session session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);  
        // 创建主题   
        Queue topicA = session.createQueue("Consumer.GG.VirtualTopic.virtual-T.*");  
        // 消费者A组创建订阅  
        MessageConsumer consumerA1 = session.createConsumer(topicA);
        Integer count = 0;
        while(true){
        	Message message = consumerA1.receive();
        	count++;
        	TextMessage msg = (TextMessage)message;
			final String messageText = msg.getText();
        	System.out.println(messageText +",消费消息总数为:"+count);

        }
        /**consumerA1.setMessageListener(new MessageListener() {  
            // 订阅接收方法  
            public void onMessage(Message message) {  
                TextMessage tm = (TextMessage) message;  
                try {  
                    System.out.println("B 收到消息: " + tm.getText()+":"+tm.getStringProperty("property"));  
                } catch (JMSException e) {  
                    e.printStackTrace();  
                }  
            }  
        });**/  
        //session.close();  
        //connection.close();  
    }  
}


[size=large]消费者3[/size] 


package com.sunshine.mq;
import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

public class ConsumerC {  

    public static void main(String[] args) throws JMSException, InterruptedException {  
        // 连接到ActiveMQ服务器  
        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(nio://172.16.7.17:1888,nio://172.16.7.18:1889)");
//    	ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:61616,tcp://172.16.7.18:61616)");
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(mqtt://172.16.7.17:1883,mqtt://172.16.7.18:1883)");
        Connection connection = factory.createConnection();  
        connection.start(); 
        Session session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);  
        // 创建主题   
        Queue topicA = session.createQueue("Consumer.GG.VirtualTopic.virtual-T.*");  
        // 消费者A组创建订阅  
        MessageConsumer consumerA1 = session.createConsumer(topicA);
        Integer count = 0;
        while(true){
        	Message message = consumerA1.receive();
        	count++;
        	TextMessage msg = (TextMessage)message;
			final String messageText = msg.getText();
        	System.out.println(messageText +",消费消息总数为:"+count);

        }
        /**consumerA1.setMessageListener(new MessageListener() {  
            // 订阅接收方法  
            public void onMessage(Message message) {  
                TextMessage tm = (TextMessage) message;  
                try {  
                    System.out.println("B 收到消息: " + tm.getText()+":"+tm.getStringProperty("property"));  
                } catch (JMSException e) {  
                    e.printStackTrace();  
                }  
            }  
        });**/  
        //session.close();  
        //connection.close();  
    }  
}


[size=large]
测试的结果是 生产者生成的消息会负载到不同的消费者客户端，各个消费者客户端消费了不同的消息。这里不管生产者生产的消息是走队列还是走topic 其结果都是实现了消息的路由。

假设出现一种情况，设备端只支持MQTT协议，使用了MQTTClient 发送消息或者只想走MQTT，那么针对这个架构该如何应对呢？道理是一样的，由于linux-c或者C++ 客户端开发人员的尿性，所以 生产者模拟程序
[/size] 


package com.sunshine.mqtt;

import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttCallback;
import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.MqttTopic;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;


public class MyMqttClient {
	private String host="tcp://172.16.7.15:1887";
	private String userName="admin";
	private String passWord = "activemq.123";
	private MqttConnectOptions options;
	private MqttClient client;
	private MqttMessage message ;
	private String[] myTopics={"test_result/20179112982783"};
	private int[] myQos={2};
	private MqttTopic topic;
	private String myTopic = "test/20179112982783";
	public MyMqttClient(){
		try {
			client=new MqttClient(host,"test99990000",new MemoryPersistence());
			options = new MqttConnectOptions(); 
			options.setCleanSession(false); 
			options.setUserName(userName); 
			options.setPassword(passWord.toCharArray()); 
			options.setConnectionTimeout(10); 
			options.setKeepAliveInterval(20);
			client.setCallback(new MqttCallback(){

				@Override
				public void connectionLost(Throwable cause) {

				}

				@Override
				public void messageArrived(String topicName, MqttMessage message)
						throws Exception {
					System.out.println("topicName is :"+topicName);
					System.out.println("Message is:"+message.toString());
				}

				@Override
				public void deliveryComplete(IMqttDeliveryToken token) {

				}});

			client.connect(options);
			client.subscribe(myTopics,myQos);

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void sendMessage(String topicT,String messageTest){
		try {
			message = new MqttMessage();
			message.setQos(0);
			message.setRetained(true);
			message.setPayload(messageTest.getBytes());
			topic = client.getTopic(topicT);
			MqttDeliveryToken token = topic.publish(message);
			token.waitForCompletion();
			System.out.println(" 发送消息:"+messageTest);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}




package com.sunshine.mqtt;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.junit.Test;


public class MyMqttTest {

	@Test
	public void testMQTT(){
		MyMqtt mqtt = new MyMqtt();
		mqtt.sendMessage("我向客户端发送了一条消息");
	}

	@Test
	public void testMQTTClient(){
		MyMqttClient client=new MyMqttClient();
		//client.sendMessage("我向服务端发送了一条消息,我的SN是 20179112982783");
	}

	@Test
	public void testIotConnect() throws InterruptedException{
		MyMqttClient client=new MyMqttClient();
		for(int i=0;i<10;i++){
			client.sendMessage("VirtualTopic/100990"+i,"mqtt-msg:"+i+">"+("100990"+i));
		}
	}
}




[size=large]三个消费者[/size] 


package com.sunshine.mq;
import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.TopicConnectionFactory;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQBytesMessage;

public class ConsumerTopicA {  

    public static void main(String[] args) throws JMSException, InterruptedException {  
        // 连接到ActiveMQ服务器  
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:1888,tcp://172.16.7.18:1889)");
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.15:1887)");
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:61616,tcp://172.16.7.18:61616)");
    	//ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:1883,tcp://172.16.7.18:1883)");
    	ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin", "failover:(tcp://172.16.7.17:1888,tcp://172.16.7.18:1889)");
        Connection connection = factory.createConnection();
        connection.start();  
        Session session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);  
        // 创建主题   
        Queue topicA = session.createQueue("Consumer.GG.VirtualTopic.*");  
        // 消费者A组创建订阅  
        MessageConsumer consumerA1 = session.createConsumer(topicA);
        Integer count = 0;
        while(true){
        	//在实际生产过程中不建议使用receive 会造成阻塞并损耗大量资源 建议直接使用spring jms 监听器
        	ActiveMQBytesMessage message = (ActiveMQBytesMessage) consumerA1.receive();
        	count++;
//        	TextMessage msg = (TextMessage)message;
//			String messageText = msg.getText();
        	System.out.println(new String(message.getMessage().getContent().getData()) +",消费消息总数为:"+count);
        }
        /**consumerA1.setMessageListener(new MessageListener() {  
            // 订阅接收方法  
            public void onMessage(Message message) {  
                TextMessage tm = (TextMessage) message;  
                try {  
                    System.out.println("A 收到消息: " + tm.getText()+":"+tm.getStringProperty("property"));  
                } catch (JMSException e) {  
                    e.printStackTrace();  
                }  
            }  
        });**/  

        //session.close();  
        //connection.close();  
    }  
}  





package com.sunshine.mq;
import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.TopicConnectionFactory;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQBytesMessage;

public class ConsumerTopicB {  

    public static void main(String[] args) throws JMSException, InterruptedException {  
        // 连接到ActiveMQ服务器  
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:1888,tcp://172.16.7.18:1889)");
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.15:1887)");
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:61616,tcp://172.16.7.18:61616)");
    	//ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:1883,tcp://172.16.7.18:1883)");
    	ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin", "failover:(tcp://172.16.7.17:1888,tcp://172.16.7.18:1889)");
        Connection connection = factory.createConnection();
        connection.start();  
        Session session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);  
        // 创建主题   
        Queue topicA = session.createQueue("Consumer.GG.VirtualTopic.*");  
        // 消费者A组创建订阅  
        MessageConsumer consumerA1 = session.createConsumer(topicA);
        Integer count = 0;
        while(true){
        	ActiveMQBytesMessage message = (ActiveMQBytesMessage) consumerA1.receive();
        	count++;
//        	TextMessage msg = (TextMessage)message;
//			String messageText = msg.getText();
        	System.out.println(new String(message.getMessage().getContent().getData()) +",消费消息总数为:"+count);
        }
        /**consumerA1.setMessageListener(new MessageListener() {  
            // 订阅接收方法  
            public void onMessage(Message message) {  
                TextMessage tm = (TextMessage) message;  
                try {  
                    System.out.println("A 收到消息: " + tm.getText()+":"+tm.getStringProperty("property"));  
                } catch (JMSException e) {  
                    e.printStackTrace();  
                }  
            }  
        });**/  

        //session.close();  
        //connection.close();  
    }  
}  



package com.sunshine.mq;
import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.TopicConnectionFactory;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQBytesMessage;

public class ConsumerTopicC {  

    public static void main(String[] args) throws JMSException, InterruptedException {  
        // 连接到ActiveMQ服务器  
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:1888,tcp://172.16.7.18:1889)");
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.15:1887)");
//        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:61616,tcp://172.16.7.18:61616)");
    	//ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin","failover:(tcp://172.16.7.17:1883,tcp://172.16.7.18:1883)");
    	ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("admin", "admin", "failover:(tcp://172.16.7.17:1888,tcp://172.16.7.18:1889)");
        Connection connection = factory.createConnection();
        connection.start();  
        Session session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);  
        // 创建主题   
        Queue topicA = session.createQueue("Consumer.GG.VirtualTopic.*");  
        // 消费者A组创建订阅  
        MessageConsumer consumerA1 = session.createConsumer(topicA);
        Integer count = 0;
        while(true){
        	ActiveMQBytesMessage message = (ActiveMQBytesMessage) consumerA1.receive();
        	count++;
//        	TextMessage msg = (TextMessage)message;
//			String messageText = msg.getText();
        	System.out.println(new String(message.getMessage().getContent().getData()) +",消费消息总数为:"+count);
        }
        /**consumerA1.setMessageListener(new MessageListener() {  
            // 订阅接收方法  
            public void onMessage(Message message) {  
                TextMessage tm = (TextMessage) message;  
                try {  
                    System.out.println("A 收到消息: " + tm.getText()+":"+tm.getStringProperty("property"));  
                } catch (JMSException e) {  
                    e.printStackTrace();  
                }  
            }  
        });**/  

        //session.close();  
        //connection.close();  
    }  
}



[size=large]
此时客户端只支持单个broker地址，可以通过一些策略分配给客户端相对比较空闲的broker
[/size]
annan211
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
(3) ActiveMQ -- Cluster
icekingson的专栏
08-30 1283
ActiveMQ cluster (ActiveMQ有强大而灵活的集群功能) ActiveMQ 可以做Broker的集群，也可以做master-slave方式的集群。 Broker cluster Broker的集群能在多个broker之前fail-over和load-balance， 但是在某个节点出故障时，可能导致消息丢失。broker cluser的方式，在一个
ActiveMQ集群的简单介绍
qf2019的博客
09-02 1035
1.为什么使用集群？ 实现高可用，以排除单点故障引起的服务中断。 实现负载均衡，以提升效率为更多的客户提供服务。 2.ActiveMQ集群部署方式 ActiveMQ集群的部署方式主要有下面2种： Broker Clusters模式：实现负载均衡，多个broker之间同步消息，已达到服务器负载的可能。 Master Slave模式：实现高可用，当主服务器宕机时，备用服务器可以立即补充，以保证服务的继续。 失效转移连接 该策略用于控制消费者的访问，这是我们在编写代码的时候要使用的连接方式。一个消费者连接到多个b
Apache ActiveMQ实战(2)-集群
weixin_30379531的博客
07-09 490
ActiveMQ的集群内嵌代理所引发的问题：消息过载管理混乱如何解决这些问题——集群的两种方式：Master slaveBroker clustersActiveMQ的集群有两种方式：MASTER/SLAVE模式Cluster模式Pure Master SlavePure master slave的工作方式：当master broker失效的时候。Slave broker 做出了两种不同的相...
activemq cluster
neutrojan的专栏
05-13 4223
ActiveMQ集群         ActiveMQ具有强大和灵活的集群功能，但在使用的过程中会发现很多的缺点，ActiveMQ的集群方式主要由两种：Master-Slave和Broker Cluster。 1、Master-Slave         Master-Slave方式中，只能是Master提供服务，Slave是实时地备份Master的数据，以保证消息的可靠性。当Master失
ActiveMQ 笔记（七）ActiveMQ的多节点集群
喜欢历史的码农
01-02 3224
一、Activemq 的集群思想 1、使用Activemq集群的原因 面试题: 引入消息中间件后如何保证其高可用 2、集群实现思路 基于zookeeper和LevelDB搭建ActiveMQ集群。集群仅提供主备方式的高可用集群功能，避免单点故障。 3、集群方案（共有三种） 主要是基于zookeeper+replicated-leveldb-store的主从集群 基于shareFil...
基于ActiveMQ的消息中间件系统OneMM逻辑与物理架构设计详解
02-26
比如一个应用遇到的问题可能与系统、网络、应用、架构、数据等各个层面的问题有关，只有耐心发现并处理好每一个相关层面的问题，才能最终形成一款好的互联网应用。维基百科对消息中间件的定义是“Message-...
基于ActiveMQ的消息中间件系统逻辑与物理架构设计具体解释
02-25
维基百科对消息中间件的定义是“Message-orientedMiddlewareissoftwareinfrastructurefocusedonsendingandreceivingmessagesbetweendistributedsystem。”分布式系统中实现消息发送和接受的基础设施。随着企业信息化...
基于kahadb的activemq高可用集群部署配置示例
08-10
基于kahadb的activemq高可用集群部署配置示例，两个broker分别部署在两台机器上，一台机子上面，两个实例组成一个broker对外提供高可用服务，两个broker通过桥接形成集群服务
高可用之ActiveMQ高可用集群(ZooKeeper+LevelDB)安装、配置、高可用测试.docx
最新发布
11-07
高可用之ActiveMQ高可用集群(ZooKeeper+LevelDB)安装、配置、高可用测试
ActiveMQ集群架构与原理解析
Jaycrees的博客
01-19 1726
初识 JMS 与其专业术语 首先，说起ActiveMQ，就必须先聊聊JMS（Java Message Service）规范，也就是Java消息服务，它定义了Java中访问消息中间件的接口的规范。在这里注意哦，JMS只是接口，并没有给予实现，实现JMS接口的消息中间件称为 “JMS Provider”，目前知名的开源 MOM （Message Oriented Middleware，也就是消息中间...
SpringMVC+Spring+Mybatis框架整合Mqttt通信协议+ActiveMQ作为中间件进行消息的发布与订阅
06-21
单片机部分采用MQTT协议将主题消息发布到队列中，java部分也采用MQTT协议进行处理，整合MQTT协议， 具体这个资源是干什么的,请查看博客： https://blog.csdn.net/qq_34178998/article/details/93158429
ActiveMQ Cluster (ActiveMQ 集群) 配置
weixin_33713503的博客
03-03 127
构建高可用的ActiveMQ系统在生产环境中是非常重要的，对于这个apache的消息中间件实现高可用非常简单，只要在Apache ActiveMQ单点基本配置基础上做一次配置变更（如果在一台设备上部署多个AMQ，需要修改对应端口号），即可实现 AMQ实现高可用部署有三种方案： 1、Master-Slave 2、SharedFile System Master Slave 3、JDBCMaster ...
linux activemq集群,ActiveMQ高可用与集群搭建
weixin_39872123的博客
05-14 199
ActiveMQ的高可用性架构是基于Master/Slave 模型的,Master/Slave模式的搭建有好几种方式:1)Shared File System Master Slave 使用共享文件系统的方式2)JDBC Master Slave 使用数据库作为持久化存储3)基于zookeeper 方式搭建我们采取的是zookeeper的方式搭建Active高可用环境:步骤一:确保已经安装好jdk...
ActiveMQ高可用集群搭建
wolfcode_cn的博客
08-21 386
mq在分布式系统中是所有系统的消息总线,在生产环境中必须要尽量保证mq的正常运行,所以一般都会使用master-slave,保证master挂掉时slave可以顶上继续工作 . 但是仅仅是master-slave的话只能保证高可用,却无法做到负载均衡,如果mq因负载过大挂掉, master-slave也无法解决这种问题,那么就必须配置负载均衡 activemq 的master-slave部署方式...
ActiveMQ多节点集群_16
Be_nurturing的博客
07-02 342
一、Zookeeper与Replicated LevelDB集群原理 面试题：引入消息队列后，如何保证高可用性？ 基于Zookeeper和LevelDB搭建的ActiveMQ集群，集群提供主备方式的高可用集群功能，避免单点故障。 ActiveMQ官网主从介绍：http://activemq.apache.org/masterslave.html 可以看到，这里支持3种方式：共享文件系统主从、JDBC主从、可复制的LevelDB存储。 LevelDB是ActiveMQ 5.6版本之后推出的持久化引擎
activitimq集群搭建_activemq集群的搭建
weixin_39587164的博客
12-18 328
一、环境准备1、上传apache-activemq-5.11.1-bin.tar 和zookeeper-3.4.5.tar.gz Linux服务器(/usr/local/install 目录下)zookeeper-3.4.5.tar.gz 上传方式相同。二、Zookeeper方案主机IP消息端口通信端口节点目录/usr/local/software 下192.168.211.128218128...
ActiveMQ集群Master-Slave + Broker Cluster模式
weixin_33795743的博客
05-05 352
一、简介Master-Slave集群：由至少3个节点组成，一个Master节点，其他为Slave节点。只有Master节点对外提供服务，Slave节点处于等待状态。当主节点宕机后，从节点会推举出一个节点出来成为新的Master节点，继续提供服务。优点是可以解决多服务热备的高可用问题，缺点是无法解决负载均衡和分布式的问题。Broker Cluster集群：Broker-Clu...
【ActiveMQ】构建ActiveMQ集群
猫巳的博客
06-12 326
activemq v5.8.0 release ActiveMQ的集群方式综述ActiveMQ的集群方式主要由两种：Master-Slave和Broker Cluster Master-SlaveMaster-Slave方式中，只能是Master提供服务，Slave是实时地备份Master的数据，以保证消息的可靠性。当Maste...
ActiveMQ学习笔记（八）—— 主从集群
q42368773的博客
12-02 509
搭建集群环境 消息的持久化和签收机制等都是为了保证消息的可靠性，但仅保证可靠性是不够的，有时我们还需要保证高可用性，这时就需要搭建ActiveMQ集群，以避免单点故障提升可用性。官方为我们介绍了三种集群搭建的方式 Master Slave Type Requirements Pros Cons Shared File System Master Slave A sh...
activemq k8s集群
06-09
在 Kubernetes 集群中可以部署多个 ActiveMQ Broker 实例，以实现高可用性和负载均衡。可以使用 Kubernetes 的 Deployment 或者 StatefulSet 对 ActiveMQ 进行部署。 2. 部署 ActiveMQ Client 在 Kubernetes 集群...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

annan211

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

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

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

打赏作者

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

抵扣说明：

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

余额充值