Mico.Demo/MassTransit示例代码/MassTransitDemo.Publisher/Controllers/MessageController.cs

using MassTransit;
using Microsoft.AspNetCore.Mvc;
using MassTransitDemo.Contracts;

namespace MassTransitDemo.Publisher.Controllers;

/// <summary>
/// 消息发布控制器
/// 提供发布/订阅模式和请求/响应模式的API接口
/// </summary>
[ApiController]
[Route("api/[controller]")]
public class MessageController : ControllerBase
{
    private readonly IPublishEndpoint _publishEndpoint;
    private readonly IRequestClient<RequestMessage> _requestClient;
    private readonly ILogger<MessageController> _logger;

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="publishEndpoint">发布端点，用于发布/订阅模式</param>
    /// <param name="requestClient">请求客户端，用于请求/响应模式</param>
    /// <param name="logger">日志记录器</param>
    public MessageController(
        IPublishEndpoint publishEndpoint,
        IRequestClient<RequestMessage> requestClient,
        ILogger<MessageController> logger)
    {
        _publishEndpoint = publishEndpoint;
        _requestClient = requestClient;
        _logger = logger;
    }

    /// <summary>
    /// 发布/订阅模式：发布一条广播消息
    /// </summary>
    /// <param name="request">消息发布请求</param>
    /// <returns>操作结果</returns>
    [HttpPost("publish")]
    public async Task<IActionResult> PublishMessage([FromBody] PublishMessageRequest request)
    {
        try
        {
            _logger.LogInformation("开始发布消息，标题: {Title}", request.Title);

            // 创建发布/订阅消息实例
            var message = new PublishSubscribeMessage
            {
                MessageId = Guid.NewGuid(),
                CreatedAt = DateTime.UtcNow,
                Title = request.Title,
                Content = request.Content,
                Priority = request.Priority
            };

            // 使用MassTransit发布消息（广播给所有订阅者）
            await _publishEndpoint.Publish(message);

            _logger.LogInformation("消息发布成功，MessageId: {MessageId}", message.MessageId);

            return Ok(new PublishMessageResponse
            {
                Success = true,
                MessageId = message.MessageId,
                Message = "消息发布成功"
            });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "消息发布失败");
            return StatusCode(500, new ErrorResponse
            {
                Success = false,
                Error = ex.Message
            });
        }
    }

    /// <summary>
    /// 请求/响应模式：发送请求并等待响应
    /// </summary>
    /// <param name="request">请求内容</param>
    /// <returns>响应结果</returns>
    [HttpPost("request")]
    public async Task<IActionResult> SendRequest([FromBody] SendRequestRequest request)
    {
        try
        {
            _logger.LogInformation("开始发送请求，操作: {Operation}", request.Operation);

            // 创建请求消息实例
            var requestMessage = new RequestMessage
            {
                RequestId = Guid.NewGuid(),
                RequestedAt = DateTime.UtcNow,
                Operation = request.Operation,
                Parameters = request.Parameters
            };

            // 使用MassTransit发送请求并等待响应
            var response = await _requestClient.GetResponse<ResponseMessage>(requestMessage);

            _logger.LogInformation("请求处理完成，RequestId: {RequestId}, 成功: {Success}",
                requestMessage.RequestId, response.Message.Success);

            return Ok(new RequestResponseResult
            {
                Success = true,
                RequestId = requestMessage.RequestId,
                Response = response.Message
            });
        }
        catch (RequestTimeoutException)
        {
            _logger.LogError("请求超时");
            return StatusCode(408, new ErrorResponse
            {
                Success = false,
                Error = "请求超时"
            });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "请求处理失败");
            return StatusCode(500, new ErrorResponse
            {
                Success = false,
                Error = ex.Message
            });
        }
    }
}

/// <summary>
/// 发布消息请求模型
/// </summary>
public class PublishMessageRequest
{
    /// <summary>
    /// 消息标题
    /// </summary>
    public string Title { get; set; } = string.Empty;

    /// <summary>
    /// 消息内容
    /// </summary>
    public string Content { get; set; } = string.Empty;

    /// <summary>
    /// 消息优先级（默认：1）
    /// </summary>
    public int Priority { get; set; } = 1;
}

/// <summary>
/// 发布消息响应模型
/// </summary>
public class PublishMessageResponse
{
    /// <summary>
    /// 操作是否成功
    /// </summary>
    public bool Success { get; set; }

    /// <summary>
    /// 消息唯一标识符
    /// </summary>
    public Guid MessageId { get; set; }

    /// <summary>
    /// 响应消息
    /// </summary>
    public string Message { get; set; } = string.Empty;
}

/// <summary>
/// 发送请求模型
/// </summary>
public class SendRequestRequest
{
    /// <summary>
    /// 操作类型
    /// </summary>
    public string Operation { get; set; } = string.Empty;

    /// <summary>
    /// 请求参数（JSON格式字符串）
    /// </summary>
    public string Parameters { get; set; } = string.Empty;
}

/// <summary>
/// 请求响应结果模型
/// </summary>
public class RequestResponseResult
{
    /// <summary>
    /// 操作是否成功
    /// </summary>
    public bool Success { get; set; }

    /// <summary>
    /// 请求唯一标识符
    /// </summary>
    public Guid RequestId { get; set; }

    /// <summary>
    /// 响应消息
    /// </summary>
    public ResponseMessage? Response { get; set; }
}

/// <summary>
/// 错误响应模型
/// </summary>
public class ErrorResponse
{
    /// <summary>
    /// 操作是否成功
    /// </summary>
    public bool Success { get; set; }

    /// <summary>
    /// 错误信息
    /// </summary>
    public string Error { get; set; } = string.Empty;
}