public ProcessingMessageMailbox(IProcessingMessageScheduler <X, Y, Z> scheduler, IProcessingMessageHandler <X, Y, Z> messageHandler)
{
_waitingToRetryMessageDict = new ConcurrentDictionary <int, X>();
_messageQueue = new ConcurrentQueue <X>();
_mailboxScheduler = scheduler;
_messageHandler = messageHandler;
}
public ProcessingMessageMailbox(string routingKey, IProcessingMessageScheduler <X, Y> scheduler, IProcessingMessageHandler <X, Y> messageHandler, ILogger logger)
{
_routingKey = routingKey;
_messageQueue = new ConcurrentQueue <X>();
_scheduler = scheduler;
_messageHandler = messageHandler;
_logger = logger;
_lastActiveTime = DateTime.Now;
}
public DefaultMessageProcessor(IProcessingMessageScheduler <X, Y> processingMessageScheduler, IProcessingMessageHandler <X, Y> processingMessageHandler, ILoggerFactory loggerFactory)
{
_mailboxDict = new ConcurrentDictionary <string, ProcessingMessageMailbox <X, Y> >();
_processingMessageScheduler = processingMessageScheduler;
_processingMessageHandler = processingMessageHandler;
_logger = loggerFactory.Create(GetType().FullName);
_scheduleService = ObjectContainer.Resolve <IScheduleService>();
_timeoutSeconds = ENodeConfiguration.Instance.Setting.AggregateRootMaxInactiveSeconds;
_taskName = "CleanInactiveAggregates_" + DateTime.Now.Ticks + new Random().Next(10000);
}
/// <summary>
/// 处理中消息邮箱
/// </summary>
/// <param name="businessKey">业务键</param>
/// <param name="subscriber">订阅者</param>
/// <param name="messageHandlerProvider">消息处理器提供者</param>
/// <param name="processingMessageHandler">处理中消息处理器</param>
/// <param name="continueWhenHandleFail">相同BusinessKey的消息处理失败后，是否继续推进</param>
/// <param name="retryIntervalSeconds">重试间隔秒数（-1 表示不重试）</param>
/// <param name="batchSize">批量处理大小</param>
public DefaultProcessingMessageMailbox(
string businessKey,
string subscriber,
IMessageHandlerProvider messageHandlerProvider,
IProcessingMessageHandler processingMessageHandler,
bool continueWhenHandleFail,
int retryIntervalSeconds,
int batchSize)
{
if (string.IsNullOrEmpty(businessKey))
{
throw new ArgumentNullException(nameof(businessKey));
}
_processingMessageDict = new ConcurrentDictionary <long, ProcessingMessage>();
_problemProcessingMessages = new ConcurrentDictionary <long, ProcessingMessageWithCreatedTime>();
_logger = LoggerManager.GetLogger(GetType());
_nextSequence = 1;
_consumingSequence = 1;
LastActiveTime = DateTime.Now;
Locker = new SpinLock();
BusinessKey = businessKey;
Subscriber = subscriber;
_messageHandlerProvider = messageHandlerProvider;
_processingMessageHandler = processingMessageHandler;
_continueWhenHandleFail = continueWhenHandleFail;
if (retryIntervalSeconds != -1)
{
_retryIntervalSeconds = retryIntervalSeconds <= 0 ? 1 : retryIntervalSeconds;
_retryEnabled = true;
}
else
{
_retryIntervalSeconds = Int32.MaxValue;
_retryEnabled = false;
}
_batchSize = batchSize <= 0 ? 1000 : batchSize;
_ctsWhenDisposing = new CancellationTokenSource();
if (_continueWhenHandleFail && _retryEnabled)
{
ProcessProblemMessage();
}
}
public DefaultProcessingMessageScheduler(IProcessingMessageHandler <X, Y> messageHandler)
{
_messageHandler = messageHandler;
}
public DefaultProcessingMessageScheduler(IProcessingMessageHandler <X, Y, Z> messageHandler)
{
_messageHandler = messageHandler;
_taskFactory = new TaskFactory(new LimitedConcurrencyLevelTaskScheduler(Environment.ProcessorCount));
}
public void SetProcessingCommandHandler(IProcessingMessageHandler <ProcessingCommand, ICommand, CommandResult> processingCommandHandler)
{
_processingCommandHandler = processingCommandHandler;
}
public DefaultMessageProcessor(IProcessingMessageScheduler <X, Y, Z> processingMessageScheduler, IProcessingMessageHandler <X, Y, Z> processingMessageHandler)
{
_mailboxDict = new ConcurrentDictionary <string, ProcessingMessageMailbox <X, Y, Z> >();
_processingMessageScheduler = processingMessageScheduler;
_processingMessageHandler = processingMessageHandler;
}
public void SetProcessingCommandHandler(IProcessingMessageHandler<ProcessingCommand, ICommand, CommandResult> processingCommandHandler)
{
_processingCommandHandler = processingCommandHandler;
}
/// <summary>
/// 处理中消息邮箱提供者
/// </summary>
/// <param name="processingMessageHandler">处理中消息处理器</param>
public DefaultProcessingMessageMailboxProvider(IProcessingMessageHandler processingMessageHandler)
{
_processingMessageHandler = processingMessageHandler;
}
public DefaultPublishableExceptionProcessor(
IProcessingMessageScheduler <ProcessingPublishableExceptionMessage, IPublishableException> processingMessageScheduler,
IProcessingMessageHandler <ProcessingPublishableExceptionMessage, IPublishableException> processingMessageHandler,
ILoggerFactory loggerFactory) : base(processingMessageScheduler, processingMessageHandler, loggerFactory)
{
}
public DefaultApplicationMessageProcessor(
IProcessingMessageScheduler <ProcessingApplicationMessage, IApplicationMessage> processingMessageScheduler,
IProcessingMessageHandler <ProcessingApplicationMessage, IApplicationMessage> processingMessageHandler,
ILoggerFactory loggerFactory) : base(processingMessageScheduler, processingMessageHandler, loggerFactory)
{
}
public ProcessingMessageMailbox(IProcessingMessageScheduler <X, Y, Z> scheduler, IProcessingMessageHandler <X, Y, Z> messageHandler)
{
_messageQueue = new ConcurrentQueue <X>();
_scheduler = scheduler;
_messageHandler = messageHandler;
}
public DefaultDomainEventProcessor(
IProcessingMessageScheduler <ProcessingDomainEventStreamMessage, DomainEventStreamMessage> processingMessageScheduler,
IProcessingMessageHandler <ProcessingDomainEventStreamMessage, DomainEventStreamMessage> processingMessageHandler,
ILoggerFactory loggerFactory) : base(processingMessageScheduler, processingMessageHandler, loggerFactory)
{
}
