前言

好久没有做项目了，这次做一个发送邮件的小项目。发邮件是一个比较耗时的操作，之前在我的个人博客里面回复评论和友链申请是会通过发送邮件来通知对方的，不过当时只是简单的进行了异步操作。 那么这次来使用RabbitMQ去统一发送邮件，我的想法是通过调用邮件发送接口，将请求发送到队列。然后在队列中接收并执行邮件发送操作。 本文采用简单的点对点模式：

在点对点模式中，只会有一个消费者进行消费。

对于常用的RabbitMQ队列模式不了解的可以查看往期文章：

• .NET 中使用RabbitMQ初体验 - 妙妙屋（zy） - 博客园 (cnblogs.com) https://www.cnblogs.com/ZYPLJ/p/17572104.html
• ZY知识库 · ZY - 在.NET Core中使用RabbitMQ (pljzy.top) https://pljzy.top/blog/post/fa670520e3df2839.html

架构图

简单描述下项目结构。项目主要分为生产者、RabbitMQ、消费者这3个对象。

• 生产者（Publisher）：负责将邮件发送请求发送到RabbitMQ的队列中。
• RabbitMQ服务器：作为消息中间件，用于接收并存储生产者发送的消息。
• 消费者（Consumer）：从RabbitMQ的队列中接收邮件发送请求，并执行实际的邮件发送操作。

项目结构

• RabbitMQEmailProject
  • EamilApiProject 生产者
    • Controllers 控制器
    • Service 服务
  • RabiitMQClient 消费者
    • Program 主程序
  • Model 实体类

开始编码(一阶段)

首先我们先简单的将生产者和消费者代码完成，让生产者能够发送消息，消费者能够接受并处理消息。代码有点多，不过注释也多很容易看懂。 给生产者和消费者都安装上用于处理RabiitMQ连接的Nuget包：

dotnet add package RabbitMQ.Client

生产者

EamilApiProject

配置文件

appsetting.json

"RabbitMQ": {  
  "Hostname": "localhost",  
  "Port": "5672",  
  "Username": "guest",  
  "Password": "guest"  
}

控制器

[ApiController]  
[Route("[controller]")]  
public class SendEmailController : ControllerBase  
{  
    private readonly EmailService _emailService;  
  
    public SendEmailController(EmailService emailService)  
    {       
	     _emailService = emailService;  
    }  
    [HttpPost(Name = "SendEmail")]  
    public IActionResult Post([FromBody] EmailDto emailRequest)  
    {        
	    _emailService.SendEamil(emailRequest);  
        return Ok("邮件已发送");  
    }
}

服务

RabbitMQ连接服务

public class RabbitMqConnectionFactory :IDisposable  
{  
    private readonly RabbitMqSettings _settings;  
    private IConnection _connection;  
  
    public RabbitMqConnectionFactory (IOptions<RabbitMqSettings> settings)  
    {       
	     _settings = settings.Value;  
    }  
    public IModel CreateChannel()  
    {        
    if (_connection == null || _connection.IsOpen == false)  
        {            
        var factory = new ConnectionFactory()  
            {  
                HostName = _settings.Hostname,  
                UserName = _settings.Username,  
                Password = _settings.Password  
            };  
            _connection = factory.CreateConnection();  
        }  
        return _connection.CreateModel();  
    }  
    public void Dispose()  
    {        
	    if (_connection != null)  
        {            
	        if (_connection.IsOpen)  
            {               
	             _connection.Close();  
            }            
            _connection.Dispose();  
        }    
    }
}

发送邮件服务

public class EmailService
{
    private readonly RabbitMqConnectionFactory _connectionFactory;

    public EmailService(RabbitMqConnectionFactory connectionFactory)
    {
        _connectionFactory = connectionFactory;
    }
    public void SendEamil(EmailDto emailDto)
    {
        using var channel = _connectionFactory.CreateChannel();
        var properties = channel.CreateBasicProperties();
        properties.Persistent = true;//消息持久化
        
        var message = JsonConvert.SerializeObject(emailDto);
        var body = Encoding.UTF8.GetBytes(message);

        channel.BasicPublish( string.Empty, "email_queue", properties, body);
    }
}

注册服务

builder.Services.Configure<RabbitMqSettings>(builder.Configuration.GetSection("RabbitMQ"));
builder.Services.AddSingleton<RabbitMqConnectionFactory >();
builder.Services.AddTransient<EmailService>();

实体

Model

public class EmailDto  
{  
    /// <summary>  
    /// 邮箱地址  
    /// </summary>  
    public string Email { get; set; }  
    /// <summary>  
    /// 主题  
    /// </summary>  
    public string Subject { get; set; }  
    /// <summary>  
    /// 内容  
    /// </summary>  
    public string Body { get; set; }  
}

public class RabbitMqSettings  
{  
    public string Hostname { get; set; }  
    public string Port { get; set; }  
    public string Username { get; set; }  
    public string Password { get; set; }  
}

消费者

RabiitMQClient

static void Main(string[] args)  
{  
    var factory = new ConnectionFactory { HostName = "localhost", Port = 5672, UserName = "guest", Password = "guest" };  
    using var connection = factory.CreateConnection();  
    using var channel = connection.CreateModel();  
  
    channel.QueueDeclare(queue: "email_queue",  
        durable: true,//是否持久化  
        exclusive: false,//是否排他  
        autoDelete: false,//是否自动删除  
        arguments: null);//参数  
  
    //这里可以设置prefetchCount的值，表示一次从队列中取多少条消息，默认是1，可以根据需要设置  
    //这里设置了prefetchCount为1，表示每次只取一条消息，然后处理完后再确认收到，这样可以保证消息的顺序性  
    //global是否全局  
    channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);  
  
    Console.WriteLine(" [*] 正在等待消息...");  
  
    //创建消费者  
    var consumer = new EventingBasicConsumer(channel);  
    //注册事件处理方法  
    consumer.Received += (model, ea) =>  
    {  
        byte[] body = ea.Body.ToArray();  
        var message = Encoding.UTF8.GetString(body);  
        var email = JsonConvert.DeserializeObject<EmailDto>(message);  
        Console.WriteLine(" [x] 发送邮件 {0}", email.Email);  
        //处理完消息后，确认收到  
        //multiple是否批量确认  
        channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);  
    };    //开始消费  
    //queue队列名  
    //autoAck是否自动确认，false表示手动确认  
    //consumer消费者  
    channel.BasicConsume(queue: "email_queue",  
        autoAck: false,  
        consumer: consumer);  
  
    Console.WriteLine(" 按任意键退出");  
    Console.ReadLine();  
}	

一阶段测试效果

一阶段就是消费者和生产者能正常运行。 可以看到生产者发送邮件之后，消费者能够正常消费请求。那么开始二阶段，将邮件发送代码完成，并实现能够通过队列处理邮件发送。 对于邮件发送失败就简单的做下处理，相对较好的解决方案就是使用死信队列，将发送失败的消息放到死信队列处理，我这里就不用死信队列，对于死信队列感兴趣的可以查看往期文章：

• .NET中使用RabbitMQ延时队列和死信队列 - 妙妙屋（zy） - 博客园 (cnblogs.com)
• ZY知识库 · ZY - RabbitMQ延时队列和死信队列 (pljzy.top)

开始编码(二阶段)

简单的创建一个用于发送邮件的类，这里使用MailKit库发送邮件。

public class EmailService  
{  
	private readonly SmtpClient client;  

	public EmailService(SmtpClient client)  
	{  
		this.client = client;  
	}  

	public async Task SendEmailAsync(string from, string to, string subject, string body)  
	{
		try
		{
			await client.ConnectAsync("smtp.163.com", 465, SecureSocketOptions.SslOnConnect); 
			// 认证  
			await client.AuthenticateAsync("zy1767992919@163.com", "");  

			// 创建一个邮件消息  
			var message = new MimeMessage(); 
			message.From.Add(new MailboxAddress("发件人名称", from));  
			message.To.Add(new MailboxAddress("收件人名称", to));  
			message.Subject = subject;  

			// 设置邮件正文  
			message.Body = new TextPart("html")  
			{  
				Text = body  
			};  

			// 发送邮件  
			var response =await client.SendAsync(message);  
			
			// 断开连接  
			await client.DisconnectAsync(true);  
		}
		catch (Exception ex)
		{
			// 断开连接  
			await client.DisconnectAsync(true);  
			throw new EmailServiceException("邮件发送失败", ex);  
		}
	}  
}  

public class EmailServiceFactory  
{  
	public EmailService CreateEmailService()  
	{  
		var client = new SmtpClient();  
		return new EmailService(client);  
	}  
}  
public class EmailServiceException : Exception  
{  
	public EmailServiceException(string message) : base(message)  
	{  
	}  

	public EmailServiceException(string message, Exception innerException) : base(message, innerException)  
	{  
	}  
}  

接下来我们在消费者中调用邮件发送方法即可，如果不使用死信队列，我们只需要在事件处理代码加上邮件发送逻辑就行了。

consumer.Received += async (model, ea) =>
{
	byte[] body = ea.Body.ToArray();
	var message = Encoding.UTF8.GetString(body);
	
	var email = JsonConvert.DeserializeObject<EmailDto>(message);
	
	// 创建一个EmailServiceFactory实例
	var emailServiceFactory = new EmailServiceFactory();  
	  
	// 使用EmailServiceFactory创建一个EmailService实例  
	var emailService = emailServiceFactory.CreateEmailService();  
	  
	// 调用EmailService的SendEmailAsync方法来发送电子邮件  
	string from = "zy1767992919@163.com"; // 发件人地址  
	string to = email.Email; // 收件人地址  
	string subject = email.Subject; // 邮件主题  
	string emailbody = email.Body; // 邮件正文  
	  
	try  
	{  
		await emailService.SendEmailAsync(from, to, subject, emailbody);  
		Console.WriteLine(" [x] 发送邮件 {0}", email.Email);
	}  
	catch (Exception ex)  
	{  
		Console.WriteLine(" [x] 发送邮件失败 " + ex.Message);  
		//这里可以记录日志
		//可以使用BasicNack方法，重新回到队列，重新消费
	}  
	
	
	//处理完消息后，确认收到
	//multiple是否批量确认
	channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
};

在上面中可以将发送失败的邮件重新放队列，多试几次，这里就不做多余的介绍了。

完成效果展示

一封正确的邮件

ok，现在展示邮件发送Demo的完整展示。 首先我们来写一个正确的邮箱地址进行发送： 可以看到当我们发送请求之后，消费者正常消费了这条请求，同时邮件发送服务也正常执行。

多条发送邮件请求

那么接下来，我们通过Api测试工具，一次性发送多条邮件请求。其中包含正确的邮箱地址、错误的邮箱地址，看看消费者能不能正常消费呢~ 这里简单的发送3条请求，2封正确的邮件地址，一封错误的，看看2封正常邮件地址的能不能正常发送出去。

这里有个问题，如果我填的邮件格式是正确的但是这个邮件地址是不存在的，他是能正常发送过去的，然后会被邮箱服务器退回来，这里不知道该怎么判断是否发送成功。所以我这的错误地址是格式就不对的邮件地址，用来模拟因为网络原因或者其他原因导致的邮件发送不成功。

可以看到3条请求都成功了，并且消费者接收到并正确消费了。2条正确邮件也收到了，1条错误的邮件也捕获到了。

总结

本文通过使用RabiitMQ点对点模式来完成一个发送邮件的小项目，通过队列去处理邮件发送。 通过RabbitMQ.Client库去连接RabbitMQ服务器。 使用MailKit库发送邮件。 通过使用RabbitMQ来避免邮件发送请求时间长的问题，同时能在消费者中重试、记录发送失败的邮件，来统一发送、统一处理。 不足点就是被退回的邮件不知道该如何处理。 可优化点：

• 可以使用WorkQueues工作队列队列模式将消息分发给多个消费者，适用于消息量较大的情况。
• 可以使用死信队列处理发送失败的邮件

参考链接

• RabbitMQ tutorial - Work Queues | RabbitMQ https://www.rabbitmq.com/tutorials/tutorial-two-dotnet
• .NET 中使用RabbitMQ初体验 - 妙妙屋（zy） - 博客园 (cnblogs.com) https://www.cnblogs.com/ZYPLJ/p/17572104.html
• ZY知识库 · ZY - RabbitMQ延时队列和死信队列 (pljzy.top) https://pljzy.top/blog/post/8a8b75ca23896940.html