/// <summary>
/// 持久化订阅主题消息
/// </summary>
/// <param name="DicTopicFilter"></param>
public void StartReciveTopicMsg(Dictionary <string, string> DicTopicFilter)
{
if (DicTopicFilter == null || DicTopicFilter.Count <= 0)
{
return;
}
//开始连接.用户名密码
connection = CreateConnection();
//如果你要持久“订阅”，则需要设置ClientId，这样程序运行当中被停止，恢复运行时，能拿到没接收到的消息！
connection.ClientId = "SmartAdapterReciveTopic";
// 启动连接
connection.Start();
// 创建一个session会话
ISession session = connection.CreateSession();
foreach (string topicName in DicTopicFilter.Keys)
{
//Create the Consumer
string filter = DicTopicFilter[topicName];
IMessageConsumer consumer;
if (string.IsNullOrWhiteSpace(filter))
{
consumer = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic(topicName), "Topic_" + topicName, null, true);
}
else
{
consumer = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic(topicName), "Topic_" + topicName, "filter = '" + filter + "'", true);
}
//接收数据
consumer.Listener += new MessageListener(consumer_Listener);
}
}
//mymq.InitQueueOrTopic(topic: false, name: "myqueue", selector: false);
//mymq.InitQueueOrTopic(topic: false, name: "seletorqueue", selector: true);
//mymq.InitQueueOrTopic(topic: true, name: "noselectortopic", selector: false);
//mymq.InitQueueOrTopic(topic: true, name: "selectortopic", selector: true);
/// <summary>
/// 初始化
/// </summary>
/// <param name="topic">选择是否是Topic</param>
/// <param name="name">队列名</param>
/// <param name="selector">是否设置过滤</param>
public bool InitQueueOrTopic(bool topic, string name, bool selector = false)
{
bool isInitSucc = true;
_eventSource = new ActiveMQEventSource();
ActiveMQMsgEventListener msgEventListener = new ActiveMQMsgEventListener(_msgHandler);
try
{
//订阅事件
msgEventListener.Subscribe(_eventSource);
this.BusinessName = name;
//通过会话创建生产者、消费者
if (topic)
{
_prod = _session.CreateProducer(new ActiveMQTopic(this.BusinessName));
if (selector)
{
_consumer = _session.CreateDurableConsumer(new ActiveMQTopic(this.BusinessName), ActiveMQConfig.CLIENT_ID, ActiveMQConfig.ACTIVEMQ_SELECTOR, false);
_consumer.Listener += new MessageListener(this.OnMessageReceived);
_hasSelector = true;
}
else
{
_consumer = _session.CreateDurableConsumer(new ActiveMQTopic(this.BusinessName), ActiveMQConfig.CLIENT_ID, null, false);
_consumer.Listener += new MessageListener(this.OnMessageReceived);
_hasSelector = false;
}
_isTopic = true;
}
else
{
_prod = _session.CreateProducer(new ActiveMQQueue(this.BusinessName));
if (selector)
{
_consumer = _session.CreateConsumer(new ActiveMQQueue(this.BusinessName), ActiveMQConfig.ACTIVEMQ_SELECTOR);
_consumer.Listener += new MessageListener(this.OnMessageReceived);
_hasSelector = true;
}
else
{
_consumer = _session.CreateConsumer(new ActiveMQQueue(this.BusinessName));
_consumer.Listener += new MessageListener(this.OnMessageReceived);
_hasSelector = false;
}
_isTopic = false;
}
//创建一个发送的消息对象
_textMessage = _prod.CreateTextMessage();
}
catch (Exception e)
{
isInitSucc = false;
//引发事件
_eventSource.RaiseErroeMsgEvent(this.BusinessName, e.Message);
}
return(isInitSucc);
}
static void Main(string[] args)
{
Uri connecturi = new Uri("tcp://localhost:61616");
Console.WriteLine("Connecting to " + connecturi);
// NOTE: ensure the nmsprovider-activemq.config file exists in the executable folder.
IConnectionFactory factory = new NMSConnectionFactory(connecturi);
using (IConnection connection = factory.CreateConnection())
{
connection.ClientId = "sample-client";
using (ISession session = connection.CreateSession())
{
// One topic for store 123 on address "orders"
ITopic ordersTopic = SessionUtil.GetTopic(session, "topic://orders");
// Instantiate consumers
using (IMessageConsumer store123Consumer = session.CreateDurableConsumer(ordersTopic, "store123", "store = 123", false))
using (IMessageConsumer store456Consumer = session.CreateDurableConsumer(ordersTopic, "store456", "store = 456", false))
using (IMessageConsumer biConsumer = session.CreateDurableConsumer(ordersTopic, "bi", null, false))
using (IMessageConsumer auditingConsumer = session.CreateDurableConsumer(ordersTopic, "auditing", null, false))
using (IMessageProducer olineOrderProducer = session.CreateProducer())
{
// Start the connection so that messages will be processed.
connection.Start();
// Set message reliability
olineOrderProducer.DeliveryMode = MsgDeliveryMode.Persistent;
// Create order with property for store 123
ITextMessage orderFor123 = session.CreateTextMessage("order placed for store 123!");
orderFor123.Properties[STORE] = 123;
ITextMessage orderFor456 = session.CreateTextMessage("order placed for store 456!");
orderFor456.Properties[STORE] = 456;
// Send a message to each store topic
olineOrderProducer.Send(ordersTopic, orderFor123);
olineOrderProducer.Send(ordersTopic, orderFor456);
// Blocking consumer, will block for up to one second
ITextMessage message = store123Consumer.Receive(TimeSpan.FromSeconds(1)) as ITextMessage;
Console.WriteLine("Store 123 Consumer received message with text: " + message.Text);
// Blocking consumer, but will not wait if no messages are immediately available
message = store456Consumer.ReceiveNoWait() as ITextMessage;
Console.WriteLine("Store 456 Consumer received message with text: " + message.Text);
// Async consumers, functions with callback
biConsumer.Listener += (IMessage asyncMessage) => {
Console.WriteLine("BI Consumer received message with text: " + (asyncMessage as ITextMessage).Text);
};
auditingConsumer.Listener += (IMessage asyncMessage) => {
Console.WriteLine("Auditing Consumer received message with text: " + (asyncMessage as ITextMessage).Text);
};
}
}
}
}
public void doTestDurableConsumerSelectorChange(bool persistent)
{
try
{
using (IConnection connection = CreateConnection(TEST_CLIENT_ID))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
ITopic topic = SessionUtil.GetTopic(session, TOPIC);
IMessageProducer producer = session.CreateProducer(topic);
IMessageConsumer consumer = session.CreateDurableConsumer(topic, CONSUMER_ID, "color='red'", false);
producer.Persistent = persistent;
// Send the messages
ITextMessage sendMessage = session.CreateTextMessage("1st");
sendMessage.Properties["color"] = "red";
producer.Send(sendMessage);
ITextMessage receiveMsg = consumer.Receive(receiveTimeout) as ITextMessage;
Assert.IsNotNull(receiveMsg, "Failed to retrieve 1st durable message.");
Assert.AreEqual("1st", receiveMsg.Text);
Assert.AreEqual(persistent, receiveMsg.NMSPersistent, "NMSPersistent does not match");
// Change the subscription.
consumer.Dispose();
consumer = session.CreateDurableConsumer(topic, CONSUMER_ID, "color='blue'", false);
sendMessage = session.CreateTextMessage("2nd");
sendMessage.Properties["color"] = "red";
producer.Send(sendMessage);
sendMessage = session.CreateTextMessage("3rd");
sendMessage.Properties["color"] = "blue";
producer.Send(sendMessage);
// Selector should skip the 2nd message.
receiveMsg = consumer.Receive(receiveTimeout) as ITextMessage;
Assert.IsNotNull(receiveMsg, "Failed to retrieve durable message.");
Assert.AreEqual("3rd", receiveMsg.Text, "Retrieved the wrong durable message.");
Assert.AreEqual(persistent, receiveMsg.NMSPersistent, "NMSPersistent does not match");
// Make sure there are no pending messages.
Assert.IsNull(consumer.ReceiveNoWait(), "Wrong number of messages in durable subscription.");
}
}
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
finally
{
UnregisterDurableConsumer(TEST_CLIENT_ID, CONSUMER_ID);
}
}
public void TestSendWhileClosed(AcknowledgementMode ackMode)
{
try
{
using (IConnection connection = CreateConnection(TEST_CLIENT_ID))
{
connection.Start();
using (ISession session = connection.CreateSession(ackMode))
{
ITopic topic = session.GetTopic(DURABLE_TOPIC);
IMessageProducer producer = session.CreateProducer(topic);
producer.DeliveryMode = MsgDeliveryMode.Persistent;
ISession consumeSession = connection.CreateSession(ackMode);
IMessageConsumer consumer = consumeSession.CreateDurableConsumer(topic, CONSUMER_ID, null, false);
Thread.Sleep(1000);
consumer.Dispose();
consumer = null;
ITextMessage message = session.CreateTextMessage("DurableTest-TestSendWhileClosed");
message.Properties.SetString("test", "test");
message.NMSType = "test";
producer.Send(message);
if (AcknowledgementMode.Transactional == ackMode)
{
session.Commit();
}
consumer = consumeSession.CreateDurableConsumer(topic, CONSUMER_ID, null, false);
ITextMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(1000)) as ITextMessage;
msg.Acknowledge();
if (AcknowledgementMode.Transactional == ackMode)
{
consumeSession.Commit();
}
Assert.IsNotNull(msg);
Assert.AreEqual(msg.Text, "DurableTest-TestSendWhileClosed");
Assert.AreEqual(msg.NMSType, "test");
Assert.AreEqual(msg.Properties.GetString("test"), "test");
}
}
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
finally
{
UnregisterDurableConsumer(TEST_CLIENT_ID, CONSUMER_ID);
}
}
/// <summary>
/// Creates the durable consumer, potentially returning a cached instance.
/// </summary>
/// <param name="destination">The destination.</param>
/// <param name="subscription">The name of the durable subscription.</param>
/// <param name="selector">The selector.</param>
/// <param name="noLocal">if set to <c>true</c> [no local].</param>
/// <returns>A message consumer</returns>
public IMessageConsumer CreateDurableConsumer(ITopic destination, string subscription, string selector, bool noLocal)
{
transactionOpen = true;
if (shouldCacheConsumers)
{
return(GetCachedConsumer(destination, selector, noLocal, subscription));
}
else
{
return(target.CreateDurableConsumer(destination, subscription, selector, noLocal));
}
}
private bool TryConnect()
{
try
{
moConnectionFactory = new NMSConnectionFactory(new Uri(msConnectUrl));
moConnection = moConnectionFactory.CreateConnection(msUser, msPassword);
moConnection.ClientId = msUser;
moConnection.ExceptionListener += new ExceptionListener(OnConnectionException);
moSession = moConnection.CreateSession(AcknowledgementMode.AutoAcknowledge);
if (!string.IsNullOrWhiteSpace(msTopic1))
{
moTopic1 = moSession.GetTopic(msTopic1);
if (mbUseDurableSubscription)
{
moConsumer1 = moSession.CreateDurableConsumer(moTopic1, msTopic1, null, false);
}
else
{
moConsumer1 = moSession.CreateConsumer(moTopic1);
}
moConsumer1.Listener += new MessageListener(OnMessageReceived1);
}
if (!string.IsNullOrWhiteSpace(msTopic2))
{
moTopic2 = moSession.GetTopic(msTopic2);
if (mbUseDurableSubscription)
{
moConsumer2 = moSession.CreateDurableConsumer(moTopic2, msTopic2, null, false);
}
else
{
moConsumer2 = moSession.CreateConsumer(moTopic2);
}
moConsumer2.Listener += new MessageListener(OnMessageReceived2);
}
LastMessageReceivedAtUtc = DateTime.UtcNow;
SpinSpreadUntilUtc = DateTime.UtcNow.AddSeconds(30);
moConnection.Start();
Interlocked.Exchange(ref miIsConnected, 1);
return(true);
}
catch (Exception oException)
{
moErrorQueue.Enqueue(new OpenRailConnectException("Connection attempt failed: " +
OpenRailException.GetShortErrorInfo(oException), oException));
Disconnect();
return(false);
}
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="topic">选择是否是Topic</param>
/// <param name="name">队列名</param>
/// <param name="selector">是否设置过滤</param>
public bool InitQueueOrTopic(bool topic, string name, bool selector = false)
{
try
{
//通过会话创建生产者、消费者
if (topic)
{
prod = session.CreateProducer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic(name));
if (selector)
{
consumer = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic(name), ClientID, Selector, false);
hasSelector = true;
}
else
{
consumer = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic(name), ClientID, null, false);
hasSelector = false;
}
isTopic = true;
}
else
{
prod = session.CreateProducer(new Apache.NMS.ActiveMQ.Commands.ActiveMQQueue(name));
if (selector)
{
consumer = session.CreateConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQQueue(name), Selector);
hasSelector = true;
}
else
{
consumer = session.CreateConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQQueue(name));
hasSelector = false;
}
isTopic = false;
}
//创建一个发送的消息对象
msg = prod.CreateTextMessage();
}
catch (System.Exception e)
{
sendSuccess = false;
receiveSuccess = false;
Console.WriteLine("Exception:{0}", e.Message);
Console.ReadLine();
throw e;
}
return(sendSuccess);
}
public void TestCreateDurableConsumer()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
string topicName = "myTopic";
ITopic topic = session.GetTopic(topicName);
string subscriptionName = "mySubscription";
testPeer.ExpectDurableSubscriberAttach(topicName, subscriptionName);
testPeer.ExpectLinkFlow();
IMessageConsumer durableConsumer = session.CreateDurableConsumer(topic, subscriptionName, null, false);
Assert.NotNull(durableConsumer, "MessageConsumer object was null");
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void Cosumer()
{
try
{
IConnectionFactory factory = new ConnectionFactory("tcp://127.0.0.1:61616");
using (IConnection connection = factory.CreateConnection())
{
connection.ClientId = "test1";
connection.Start();
using (ISession session = connection.CreateSession())
{
Console.WriteLine(11111111111);
IMessageConsumer consumer = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic("testing"), "test1", null, false);
Console.WriteLine(222222222222);
consumer.Listener += new MessageListener(Consumer_Listener);
Console.WriteLine(333333333);
Console.ReadLine();
}
Console.WriteLine("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
connection.Stop();
connection.Close();
}
}
catch
{
}
}
public void Subscribe()
{
try
{
try
{
IConnectionFactory factory;
factory = new ConnectionFactory(ConfigurationManager.AppSettings["MQ"].ToString()); // 连接MQ数据发布服务器
IConnection connection = factory.CreateConnection();
connection.Start();
session = connection.CreateSession();
consumer = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic(ConfigurationManager.AppSettings["Topic_AJ"].ToString()), "GQY_AJ", null, false);
AJCOUNT.ItemsSource = AJTJ;
consumer.Listener += new MessageListener(consumer_Listener);
}
catch (Exception e)
{
MessageBox.Show("订阅案件主题失败" + e.Message);
}
// Thread AJProcessThread = new Thread(new ThreadStart(ProcessAJ));
// AJProcessThread.Start();
Task RecalcAJ = new Task(RefreshAJ);
RecalcAJ.Start();
}
catch (Exception)
{
}
}
public void CreateConsumer()
{
try
{
_factory = new NMSConnectionFactory(_address);
if (_anonymous)
{
_connection = _factory.CreateConnection();
}
else
{
_connection = _factory.CreateConnection(_username, _passwd);
}
_connection.ClientId = _clientId;
_connection.Start();
_session = _connection.CreateSession();
_consumer = _session.CreateDurableConsumer(
new ActiveMQTopic(_topicName), _clientId, null, false);
_consumer.Listener += new MessageListener(consumer_Listener);
Tr.Common.Log.TrLog.Default.Info($"[{_name}] ActiveMQ_Address:{_address};ActiveMQ_UserName:{_username};ActiveMQ_Passwd:{_passwd};" +
$"ActiveMQ_TopicName:{_topicName}");
}
catch (System.Exception ex)
{
Tr.Common.Log.TrLog.Default.Error(ex.Message, ex);
}
}
private void button1_Click(object sender, EventArgs e)
{
try
{
//Create the Connection factory
IConnectionFactory factory = new ConnectionFactory("tcp://localhost:61616/");
//Create the connection
using (IConnection connection = factory.CreateConnection())
{
connection.ClientId = "pubsunListener1";
connection.Start();
//Create the Session
using (ISession session = connection.CreateSession())
{
//Create the Consumer
IMessageConsumer consumer = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic("pubsub"), "pubsunListener1");
//consumer.Listener += new MessageListener(consumer_Listener);
//注册监听事件
consumer.Listener += new MessageListener(consumer_Listener);
Console.ReadLine();
}
connection.Stop();
connection.Close();
}
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
}
static void Main(string[] args)
{
try
{
Console.WriteLine("订阅者");
IConnectionFactory factory = new ConnectionFactory("tcp://localhost:61616");
using (IConnection connection = factory.CreateConnection())
{
connection.ClientId = "123456789";
connection.Start();
using (ISession session = connection.CreateSession())
{
IMessageConsumer consumer = session.CreateDurableConsumer(
new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic("zzz"), "zjm", null, false);
consumer.Listener += new MessageListener(consumer_Listener);
Console.ReadLine();
}
connection.Stop();
connection.Close();
}
}
catch (Exception ex)
{
Console.WriteLine($"异常{ex.Message}");
Console.ReadLine();
}
}
/// <summary>
/// 创建消费者
/// </summary>
/// <returns></returns>
public IMessageConsumer CreateConsumer()
{
if (connection == null)
{
Start(); return(consumer);
}
if (!string.IsNullOrEmpty(ClientID))
{
try
{
connection.ClientId = ClientID;
}
catch { return(consumer); }
}
session = connection.CreateSession();
//connection.Start();
if (IsTopic)
{
//consumer = session.CreateConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic(TopicName), null, false);
consumer = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic(TopicName), Selector, null, true);
}
else
{
consumer = session.CreateConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQQueue(TopicName), null, false);
}
consumer.Listener += Consumer_Listener;
return(consumer);
}
protected void RunTestDurableConsumer(AcknowledgementMode ackMode)
{
SendDurableMessage();
using (IConnection connection = CreateConnection(TEST_CLIENT_ID))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.Transactional))
{
ITopic topic = SessionUtil.GetTopic(session, DURABLE_TOPIC);
using (IMessageConsumer consumer = session.CreateDurableConsumer(topic, CONSUMER_ID, DURABLE_SELECTOR, false))
{
IMessage msg = consumer.Receive(receiveTimeout);
Assert.IsNotNull(msg, "Did not receive first durable message.");
msg.Acknowledge();
SendDurableMessage();
msg = consumer.Receive(receiveTimeout);
Assert.IsNotNull(msg, "Did not receive second durable message.");
msg.Acknowledge();
if (AcknowledgementMode.Transactional == ackMode)
{
session.Commit();
}
}
}
}
}
static void Main(string[] args)
{
try
{
//Create the Connection factory
IConnectionFactory factory = new ConnectionFactory("tcp://localhost:61616/");
//Create the connection
using (IConnection connection = factory.CreateConnection())
{
connection.ClientId = "AMQ listener";
connection.Start();
//Create the Session
using (ISession session = connection.CreateSession())
{
//Create the Consumer
IMessageConsumer consumer = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic("AMQ"), "AMQ listener", null, false);
consumer.Listener += new MessageListener(consumer_Listener);
Console.ReadLine();
}
connection.Stop();
connection.Close();
}
}
catch (System.Exception e)
{
Console.WriteLine(e.Message);
}
}
public void TestDurableConsumer()
{
try
{
RegisterDurableConsumer(TEST_CLIENT_ID, TOPIC, CONSUMER_ID, DURABLE_SELECTOR, false);
SendPersistentMessage();
using (IConnection connection = CreateConnection(TEST_CLIENT_ID))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.DupsOkAcknowledge))
{
ITopic topic = SessionUtil.GetTopic(session, TOPIC);
using (IMessageConsumer consumer = session.CreateDurableConsumer(topic, CONSUMER_ID, DURABLE_SELECTOR, false))
{
IMessage msg = consumer.Receive(receiveTimeout);
Assert.IsNotNull(msg, "Did not receive first durable message.");
SendPersistentMessage();
msg = consumer.Receive(receiveTimeout);
Assert.IsNotNull(msg, "Did not receive second durable message.");
}
}
}
}
finally
{
UnregisterDurableConsumer(TEST_CLIENT_ID, CONSUMER_ID);
}
}
public void TestCloseDurableTopicSubscriberDetachesWithCloseFalse()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
string topicName = "myTopic";
string subscriptionName = "mySubscription";
ITopic topic = session.GetTopic(topicName);
testPeer.ExpectDurableSubscriberAttach(topicName, subscriptionName);
testPeer.ExpectLinkFlow();
IMessageConsumer durableConsumer = session.CreateDurableConsumer(topic, subscriptionName, null, false);
testPeer.ExpectDetach(expectClosed: false, sendResponse: true, replyClosed: false);
durableConsumer.Close();
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void TestCreateDurableConsumer()
{
using (TestAmqpPeer testAmqpPeer = new TestAmqpPeer(Address, User, Password))
{
testAmqpPeer.Open();
TestLinkProcessor testLinkProcessor = new TestLinkProcessor();
testAmqpPeer.RegisterLinkProcessor(testLinkProcessor);
NmsConnection connection = (NmsConnection)EstablishConnection();
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
string topicName = "myTopic";
string subscriptionName = "mySubscription";
ITopic topic = session.GetTopic(topicName);
IMessageConsumer durableConsumer = session.CreateDurableConsumer(topic, subscriptionName, null, false);
Assert.NotNull(durableConsumer);
// Expect That Durable Subscriber Attach
Assert.That(() => testLinkProcessor.Consumer, Is.Not.Null.After(200));
Assert.AreEqual(subscriptionName, testLinkProcessor.Consumer.Link.Name);;
Source source = (Source)testLinkProcessor.Consumer.Attach.Source;
Assert.AreEqual((uint)TerminusDurability.UNSETTLED_STATE, source.Durable);
Assert.AreEqual(new Symbol("never"), source.ExpiryPolicy);
Assert.AreEqual(topicName, source.Address);
Assert.IsFalse(source.Dynamic);
connection.Close();
}
}
public void TestCloseDurableTopicSubscriberDetachesWithCloseFalse()
{
using (var testListener = new TestListener(IPEndPoint))
{
testListener.Open();
Amqp.Types.List result = null;
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
testListener.RegisterTarget(TestPoint.Detach, (stream, channel, fields) =>
{
TestListener.FRM(stream, 0x16UL, 0, channel, fields[0], false);
result = fields;
manualResetEvent.Set();
return(TestOutcome.Stop);
});
IConnection connection = EstablishConnection();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
string topicName = "myTopic";
string subscriptionName = "mySubscription";
ITopic topic = session.GetTopic(topicName);
IMessageConsumer durableConsumer = session.CreateDurableConsumer(topic, subscriptionName, null, false);
durableConsumer.Close();
manualResetEvent.WaitOne(TimeSpan.FromMilliseconds(100));
// Assert that closed field is set to false
Assert.IsFalse((bool)result[1]);
}
}
/// <summary>
/// 订阅Topic消息
/// </summary>
/// <param name="topic">消息Topic</param>
/// <param name="clientId"></param>
/// <param name="subscribeName"></param>
/// <param name="mode"></param>
public void SubscribeTopicMessage(string topic, string clientId, string subscribeName, AcknowledgementMode mode)
{
try
{
using (IConnection connection = _factory.CreateConnection(_user, _pwd))
{
connection.ClientId = clientId;
connection.Start();
using (ISession session = connection.CreateSession(mode))
{
//持久性订阅Topic(将消息写入磁盘，即使重启MQ，下次订阅任然可以接收到该消息)
IMessageConsumer consumer = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic(topic), subscribeName, null, false);
//ITextMessage message = consumer.Receive() as ITextMessage;
//string str = message.Text;
consumer.Listener += new MessageListener(customer_listener);
}
connection.Stop();
connection.Close();
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 消费者开始
/// </summary>
public virtual void Start()
{
if (_connection != null)
{
if (!_connection.IsStarted)
{
_connection.Start();
}
return;
}
_connection = ConnectionPool.Instance.GetConnection(_options);
_connection.ExceptionListener += ex =>
{
ConnectionExceptionListener?.Invoke(this, new HandleExceptionEventArgs <IConnection>(ex, _connection, _options));
};
_session = _connection.CreateSession(_options.AcknowledgementMode);
if (_options.Durable && _options.Type == MQType.Topic && !string.IsNullOrEmpty(_options.DurableClientId))
{
_consumer = _session.CreateDurableConsumer(new ActiveMQTopic(_options.Name), _options.DurableClientId, _options.Selector, _options.Nolocal);//消息持久化
}
else
{
_consumer = _session.CreateConsumer(_options.Type.CreateDestination(_options.Name), _options.Selector, _options.Nolocal);
}
_consumer.Listener += Consumer_Listener;
ResetCancellationSource();
_connection.Start();
}
public void TestMe()
{
count = 0;
RegisterDurableConsumer();
SendPersistentMessage();
using (IConnection connection = Factory.CreateConnection())
{
connection.ClientId = CLIENT_ID;
connection.Start();
using (ISession session = connection.CreateSession(
AcknowledgementMode.DupsOkAcknowledge))
{
ITopic topic = session.GetTopic(TOPIC);
IMessageConsumer consumer = session.CreateDurableConsumer(
topic, CONSUMER_ID, "2 > 1", false);
consumer.Listener += new MessageListener(consumer_Listener);
/// Don't know how else to give the system enough time. /// Thread.Sleep(5000); Assert.AreEqual(0, count); Console.WriteLine("Count = " + count); SendPersistentMessage(); Thread.Sleep(5000); Assert.AreEqual(2, count); Console.WriteLine("Count = " + count); consumer.Dispose(); }
connection.Stop();
}
}
}
/// <summary>
/// 订阅消息
/// </summary>
/// <param name="consumerName">消费者名称</param>
/// <param name="isQueues">是否为Queues</param>
/// <param name="durableName">durable id（为null 使用普通模式，且仅对topic有效）</param>
/// <returns>是否成功</returns>
public bool SubscribeConsumer(string consumerName, bool isQueues, string durableName)
{
IMessageConsumer consumer;
try
{
if (!isQueues && durableName != null)
{
consumer = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic(consumerName), durableName, null, false);
}
else
{
consumer = session.CreateConsumer(((isQueues) ? ((IDestination)(new Apache.NMS.ActiveMQ.Commands.ActiveMQQueue(consumerName))):((IDestination)(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic(consumerName)))), null, false);
}
}
catch (Exception ex)
{
nowErrorMes = ex.Message;
return(false);
}
consumerList.Add(consumer);
if (isWithEvent)
{
consumer.Listener += consumer_Listener;
}
return(true);
}
public CaptureDTO Popup(string userId)
{
var sysUser = _sysUserRepository.GetById(userId.ToInt());
if (sysUser.IsNotNull() && !sysUser.SysChannels.IsNullOrEmpty())
{
var sb = new StringBuilder();
sysUser.SysChannels.ToList().ForEach(t => sb.Append($"or channel='{t.Name}' "));
var selector = sb.ToString().TrimStart('o', 'r').TrimEnd(' ');
var rtnJson = string.Empty;
IConnectionFactory factory = new ConnectionFactory(ConfigPara.MQIdaddress);
//Create the connection
using (Apache.NMS.IConnection connection = factory.CreateConnection())
{
try
{
connection.ClientId = "SKCustome" + userId;
connection.Start();
//Create the Session
using (ISession session = connection.CreateSession())
{
IMessageConsumer consumer = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic("MQMessage"), sysUser.Name, selector, false);
var i = 10;
while (i > 0)
{
ITextMessage msg = (ITextMessage)consumer.Receive(new TimeSpan(1000));
if (msg != null)
{
rtnJson = msg.Text;
}
i--;
}
consumer.Close();
}
}
catch
{
}
finally
{
connection.Stop();
connection.Close();
}
}
var capture = rtnJson.ToObject <Capture>();
if (capture.IsNotNull())
{
if (capture.CreateTime.AddMinutes(2) > DateTime.Now)
{
return(capture.ConvertoDto <Capture, CaptureDTO>());
}
}
}
return(default(CaptureDTO));
}
public ConsumerWrapper(ISession session, String topic)
{
Session = session;
var name = topic.GetHashCode().ToString();
Consummer = session.CreateDurableConsumer(session.GetTopic(topic), name, null, true);
Consummer.Listener += MessageListenner;
}
public void CreateConsumer()
{
// cons = session.CreateConsumer(dest);
//持久，如果断开了，生产者将不会删除消息，而是等待该消费者恢复上线后，继续为其服务。
cons = session.CreateDurableConsumer(new Apache.NMS.ActiveMQ.Commands.ActiveMQTopic(topicCfg.topicStr), "customer", selector, false);
cons.Listener += new MessageListener(consumer_Listener);
}
public void TestCloseDurableSubscriberWithUnackedAndUnconsumedPrefetchedMessages()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
string topicName = "myTopic";
string subscriptionName = "mySubscription";
ITopic topic = session.GetTopic(topicName);
int messageCount = 5;
// Create a consumer and fill the prefetch with some messages,
// which we will consume some of but ack none of.
testPeer.ExpectDurableSubscriberAttach(topicName, subscriptionName);
testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), count: messageCount);
IMessageConsumer durableConsumer = session.CreateDurableConsumer(topic, subscriptionName, null, false);
int consumeCount = 2;
IMessage receivedMessage = null;
for (int i = 1; i <= consumeCount; i++)
{
receivedMessage = durableConsumer.Receive();
Assert.NotNull(receivedMessage);
Assert.IsInstanceOf <NmsTextMessage>(receivedMessage);
}
// Expect the messages that were not delivered to be released.
for (int i = 1; i <= consumeCount; i++)
{
testPeer.ExpectDispositionThatIsAcceptedAndSettled();
}
receivedMessage.Acknowledge();
testPeer.ExpectDetach(expectClosed: false, sendResponse: true, replyClosed: false);
for (int i = consumeCount + 1; i <= messageCount; i++)
{
testPeer.ExpectDispositionThatIsReleasedAndSettled();
}
testPeer.ExpectEnd();
durableConsumer.Close();
session.Close();
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(3000);
}
}
public void StartListeners(MessageListener listener1, MessageListener listener2)
{
var topic = _session.GetTopic(Config.TEST_TOPIC_NAME);
_messageConsumer1 = _session.CreateConsumer(topic);
_messageConsumer2 = _session.CreateDurableConsumer(topic, "testConsumer", "FLAG = '1'", false);
_messageConsumer1.Listener += listener1;
_messageConsumer2.Listener += listener2;
}
public ActiveMq(bool durable)
{
_connectionFactory = new ConnectionFactory("tcp://localhost:61616");
_connectionFactory.AsyncSend = true;
_connectionFactory.ProducerWindowSize = int.MaxValue;
_connection = _connectionFactory.CreateConnection();
_connection.ClientId = "13AC0CF8-65FE-4638-8B85-62210DD89BEE";
_connection.Start();
_session = _connection.CreateSession();
ActiveMQTopic topic = new ActiveMQTopic("topic");
_consumer = _session.CreateDurableConsumer(topic, "durable", "2 > 1", false);
_producer = _session.CreateProducer(topic);
_producer.DeliveryMode = durable ? MsgDeliveryMode.Persistent : MsgDeliveryMode.NonPersistent;
}
private void TryConnect()
{
Task.Factory.StartNew(() =>
{
while (!_cts.IsCancellationRequested)
{
if (!_isConnect)
{
_logger.Info("开始连接指令队列服务器![{0}-{1}]".GetFormat(_name, _uri));
try
{
_factory = new ConnectionFactory(_uri);
_connection = _factory.CreateConnection();
_connection.ConnectionInterruptedListener += () =>
{
_logger.Error("与指令队列服务器断开连接![{0}-{1}]".GetFormat(_name, _uri));
_isConnect = false;
};
_connection.ClientId = _clientId;
_connection.Start();
_session = _connection.CreateSession();
_consumer = _session.CreateDurableConsumer(new ActiveMQTopic(_name), _connection.ClientId, null, false);
_consumer.Listener += OnReceived;
_isConnect = true;
_logger.Info("连接指令队列服务器成功![{0}-{1}]".GetFormat(_name, _uri));
}
catch (Exception ex)
{
_logger.Error("连接指令队列服务器失败![{0}-{1}]".GetFormat(_name, _uri), ex);
_isConnect = false;
}
}
Thread.Sleep(10 * 1000);
}
}, _cts.Token);
}
/// <summary>
/// Create a message consumer to the given destination
/// </summary>
/// <param name="session">session to connect to</param>
/// <param name="destination">destination topic to read from</param>
/// <param name="appendedText">optional text to append to durable subscriber name</param>
/// <returns>a consumer to the given destination</returns>
private IMessageConsumer CreateConsumer(ISession session, ITopic destination, string appendedText = null)
{
string subscriberId = ConfigurationManager.AppSettings["ActiveMQDurableSubscriberId"];
if (!string.IsNullOrEmpty(subscriberId))
return session.CreateDurableConsumer(destination, string.Concat(subscriberId, appendedText), null, false);
else
return session.CreateConsumer(destination);
}
/// <summary>
/// Creates a MessageConsumer for the given Session and Destination.
/// </summary>
/// <param name="session">The session to create a MessageConsumer for.</param>
/// <param name="destination">The destination to create a MessageConsumer for.</param>
/// <returns>The new MessageConsumer</returns>
protected IMessageConsumer CreateConsumer(ISession session, IDestination destination)
{
// Only pass in the NoLocal flag in case of a Topic:
// Some NMS providers, such as WebSphere MQ 6.0, throw IllegalStateException
// in case of the NoLocal flag being specified for a Queue.
if (PubSubDomain)
{
if (SubscriptionDurable && destination is ITopic)
{
return session.CreateDurableConsumer(
(ITopic) destination, DurableSubscriptionName, MessageSelector, PubSubNoLocal);
}
else
{
return session.CreateConsumer(destination, MessageSelector, PubSubNoLocal);
}
}
else
{
return session.CreateConsumer(destination, MessageSelector);
}
}
