/// <summary> /// Invoked by an <see cref="Spring.Objects.Factory.IObjectFactory"/> /// after it has injected all of an object's dependencies. /// </summary> /// <remarks> /// Ensure that the DefaultMessageQueueObjectName property is set, creates /// a default implementation of the <see cref="IMessageQueueFactory"/> interface /// (<see cref="DefaultMessageQueueFactory"/>) that retrieves instances on a per-thread /// basis, and registers in the Spring container a default implementation of /// <see cref="IMessageConverter"/> (<see cref="XmlMessageConverter"/>) with a /// simple System.String as its TargetType. <see cref="QueueUtils.RegisterDefaultMessageConverter"/> /// </remarks> public void AfterPropertiesSet() { if (MessageQueueFactory == null) { AssertUtils.ArgumentNotNull(applicationContext, "MessageQueueTemplate requires the ApplicationContext property to be set if the MessageQueueFactory property is not set for automatic create of the DefaultMessageQueueFactory"); DefaultMessageQueueFactory mqf = new DefaultMessageQueueFactory(); mqf.ApplicationContext = applicationContext; messageQueueFactory = mqf; } if (messageConverterObjectName == null) { messageConverterObjectName = QueueUtils.RegisterDefaultMessageConverter(applicationContext); } //If it has not been set by the user explicitly, then initialize. CreateDefaultMetadataCache(); }
/// <summary> /// Send the message queue selecting the appropriate transactional delivery options. /// </summary> /// <remarks> /// <para> /// If the message queue is transactional and there is an ambient MessageQueueTransaction /// in thread local storage (put there via the use of Spring's MessageQueueTransactionManager /// or TransactionalMessageListenerContainer), the message will be sent transactionally using the /// MessageQueueTransaction object in thread local storage. This lets you group together multiple /// messaging operations within the same transaction without having to explicitly pass around the /// MessageQueueTransaction object. /// </para> /// <para> /// If the message queue is transactional but there is no ambient MessageQueueTransaction, /// then a single message transaction is created on each messaging operation. /// (MessageQueueTransactionType = Single). /// </para> /// <para> /// If there is an ambient System.Transactions transaction then that transaction will /// be used (MessageQueueTransactionType = Automatic). /// </para> /// <para> /// If the queue is not transactional, then a non-transactional send /// (MessageQueueTransactionType = None) is used. /// </para> /// </remarks> /// <param name="mq">The mq.</param> /// <param name="msg">The MSG.</param> protected virtual void DoSendMessageQueue(MessageQueue mq, Message msg) { MessageQueueTransaction transactionToUse = QueueUtils.GetMessageQueueTransaction(null); if (metadataCache != null) { MessageQueueMetadata mqMetadata = metadataCache.Get(mq.Path); if (mqMetadata != null) { if (mqMetadata.RemoteQueue) { if (mqMetadata.RemoteQueueIsTransactional) { // DefaultMessageQueue transaction is externally managed. DoSendMessageTransaction(mq, transactionToUse, msg); return; } DoSendMessageQueueNonTransactional(mq, transactionToUse, msg); return; } } } else { if (LOG.IsWarnEnabled) { LOG.Warn("MetadataCache has not been initialized. Set the MetadataCache explicitly in standalone usage and/or " + "configure the MessageQueueTemplate in an ApplicationContext. If deployed in an ApplicationContext by default " + "the MetadataCache will automaticaly populated."); } } // Handle assuming these are local queues. if (mq.Transactional) { // DefaultMessageQueue transaction is externally managed. DoSendMessageTransaction(mq, transactionToUse, msg); } else { DoSendMessageQueueNonTransactional(mq, transactionToUse, msg); } }