springboot+rabbitmq发送邮件

准备rabbitmq服务

我前面有个安装docker的帖子,如果想省事又快捷的安装rabbitmq请先安装docker,如果你想在自己的Linux机器里直接安装也不是不行,但是你要做好被烦死的准备。https://blog.csdn.net/Curtisjia/article/details/104186314
在这里插入图片描述
OK,这里我已经假设你的docker环境没有任何问题了,然后开始拉rabbitmq的镜像,命令如下:

docker run -d --hostname my-rabbit --name leo-rabbit -p 5672:5672 -p 15672:15672 rabbitmq:3-management

说明:

-d 后台运行容器;

–name 指定容器名(自己命名);

–hostname 主机名(RabbitMQ的一个重要注意事项是它根据所谓的 “节点名称” 存储数据,默认为主机名);

完了之后,输入docker ps,能看到自己的镜像启动就OK了。
在这里插入图片描述
然后去页面输入 服务端IP :15672

什么,你不会查看自己的服务端IP?ifconfig去查看,(开玩笑,能学到这个层次的人,怎么可能还会有不会看IP的呢)。
然后回车
在这里插入图片描述
抱歉我这里是登陆过的,你那边应该会让你登陆,用户名和密码默认都是guest。

后台邮件服务端准备

先导入必要依赖

在这里插入图片描述
web、rabbitmq、mail、thymeleaf

开启邮件服务,我这里选的是QQ邮箱

在这里插入图片描述
在这里插入图片描述
之后你的得到一串密码,要保存好,那就是你登陆邮箱的密码,待会会用到。

开始写配置文件

server.port=8082
spring.mail.host=smtp.qq.com
spring.mail.protocol=smtp
spring.mail.default-encoding=UTF-8
spring.mail.password=这个写邮箱那边给你的密码,别写QQ密码
spring.mail.username=自己的QQ邮箱
spring.mail.port=465
spring.mail.properties.mail.smtp.socketFactory.class=javax.net.ssl.SSLSocketFactory
spring.mail.properties.mail.debug=true //邮件发送成功的话
//会打印在控制台,这步可以考虑不要
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.host=服务端IP
spring.rabbitmq.port=5672 //这里端口是5672,不要写15672,否则会报错

准备前端发送的邮件模板

老样子,在resources文件夹下创建templates文件夹,必须是templates否则springboot识别不到,当然你也可以在配置文件里改,我觉得没必要。
然后创建一个mail.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>入职欢迎邮件</title>
</head>
<body>
欢迎 <span th:text="${name}"></span>加入我们!你的入职信息如下:
    <table border="1">
        <tr>
            <td>姓名</td>
            <td th:text="${name}"></td>
        </tr>
        <tr>
            <td>职位</td>
            <td th:text="${posName}"></td>
        </tr>
        <tr>
            <td>职称</td>
            <td th:text="${joblevelName}"></td>
        </tr>
        <tr>
            <td>部门</td>
            <td th:text="${departmentName}"></td>
        </tr>
    </table>
<p>希望在未来的日子里,携手共进!</p>
</body>
</html>

开始搭建服务端

一、创建队列

	@Bean
    Queue queue(){
        return new Queue("leo.mail.welcome");
    }

这里写在了主函数里,创建一个叫这么个名字的队列。
在这里插入图片描述
装逼的点开源码,然后发现没看懂,果断close,进行下一步;

二、创建邮件发送的类MailReceiver
先贴源码:

package com.leo.mailserver.receiver;

import com.leo.vhr.model.Employee;
import com.leo.vhr.model.Hr;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.mail.MailProperties;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Component;
import org.thymeleaf.TemplateEngine;
import org.thymeleaf.context.Context;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import java.util.Date;

/**
 * @description:
 * @author: Leo
 * @createDate: 2020/2/6
 * @version: 1.0
 */
@Component
public class MailReceiver
{
    public static final Logger log= LoggerFactory.getLogger(MailReceiver.class);
    @Autowired
    JavaMailSender javaMailSender;
    @Autowired
    MailProperties mailProperties;
    @Autowired
    TemplateEngine templateEngine;
    @RabbitListener(queues = "leo.mail.welcome")
    public void handler(Employee employee){
        //log.info(employee.toString());
        MimeMessage mimeMessage = javaMailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(mimeMessage);
        try
        {
            helper.setTo(employee.getEmail());
            helper.setFrom(mailProperties.getUsername());
            helper.setSubject("入职欢迎邮件");
            helper.setSentDate(new Date());
            Context context = new Context();
            context.setVariable("name",employee.getName());
            context.setVariable("posName",employee.getPosition().getName());
            context.setVariable("joblevelName",employee.getJobLevel().getName());
            context.setVariable("departmentName",employee.getDepartment().getName());
            String mail = templateEngine.process("mail", context);
            helper.setText(mail,true);
            javaMailSender.send(mimeMessage);
        }
        catch (MessagingException e)
        {
            e.printStackTrace();
            log.error("邮件发送失败!"+e.getMessage());
        }
    }
}

  1. @RabbitListener(queues = “leo.mail.welcome”)
    选择监听的队列
  2. 注入JavaMailSender
javaMailSender.createMimeMessage();//创建消息对象
  1. 实现MimeMessageHelper对象,并把消息对象传入捡来
MimeMessageHelper helper = new MimeMessageHelper(mimeMessage);

然后就是从哪来到哪去,主题、发送时间。

  1. helper.setFrom(mailProperties.getUsername());
    这里从哪发送我为什么要这么写呢?这是出于灵活变化的考虑,如果在这里写死的话,那么每次变化发送人的时候,我要在配置文件和代码里改两次。所以我的发送人,就写从配置文件里传来的人。
    首先到配置文件的spring.mail.username,按住Ctrl,你会发现配置文件也是把这些信息注入到了MailProperties;
    在这里插入图片描述
    所以我把这个类注入进来,直接获取username,这样配置文件更改的时候,我的代码就不必更改了;

  2. 渲染邮件模板
    注入TemplateEngine,它属于org.thymeleaf.包下面。
    实现他下面的process方法,点击源码看:
    在这里插入图片描述
    他需要一个模板名,我们这边要被渲染的模板叫mail,还需要一个context,那么我们就new一个Context给他。
    在这里插入图片描述
    然后逐一对应的写变量和要传入的参数。

  3. 最后设置setText,点击源码:
    在这里插入图片描述
    首先他需要一个发送的文本,我们把

String mail = templateEngine.process("mail", context);

赋值给一个参数,传进去,然后第二个参数问你是不是HTML,传入true;

  1. 把传入的邮件发送出去
javaMailSender.send(mimeMessage);

说明

传入的数据如果是通过数据库来动态获取的话,需要在对应的实体类上实现序列化接口。

OK,通过队列实现邮件发送就说到这里;
也许有人看到这里还在想,用队列到底有什么作用啊?没看出来啊!这里我说一下,假如你从前端传入完参数运行出了点问题,但是中间件这边收到了邮件。那么在下次请求完成之后,他会自动的把之前的保存在中间件的邮件发送过去!

详细请参考

https://mp.weixin.qq.com/s/fKAjWkbzM0X9MLHVaPUEHQ
公众号也可以关注:江南一点雨,有很多的学习资源和视频;
哔哩哔哩上可以搜狂神说,里面有很多入门级视频教程;

Author By 朝花不迟暮

在这里插入图片描述

  • 2
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 在 Spring Boot 中,你可以通过 RabbitMQ 的 `x-delayed-message` 插件来实现延时队列,而不需要使用额外的插件或库。下面是实现步骤: 1. 添加依赖 在 `pom.xml` 文件中添加 RabbitMQ 的依赖: ```xml <dependency> <groupId>org.springframework.amqp</groupId> <artifactId>spring-rabbit</artifactId> <version>2.3.12.RELEASE</version> </dependency> ``` 2. 配置 RabbitMQ 的 `x-delayed-message` 插件 在 RabbitMQ 中,你需要先安装 `x-delayed-message` 插件。你可以通过 `rabbitmq-plugins` 命令来安装插件: ``` rabbitmq-plugins enable rabbitmq_delayed_message_exchange ``` 或者,你可以在 `rabbitmq.conf` 文件中添加以下配置,然后重启 RabbitMQ: ``` plugins.rabbitmq_delayed_message_exchange = {git, "https://github.com/rabbitmq/rabbitmq-delayed-message-exchange", {branch, "master"}} ``` 3. 配置 RabbitMQ 的连接信息 在 `application.properties` 中添加 RabbitMQ 的连接信息: ```properties spring.rabbitmq.host=your-rabbitmq-host spring.rabbitmq.port=5672 spring.rabbitmq.username=your-rabbitmq-username spring.rabbitmq.password=your-rabbitmq-password ``` 4. 定义队列和交换器 在 Spring Boot 中,你可以使用 `@Configuration` 和 `@Bean` 注解来定义队列和交换器。下面是一个例子: ```java @Configuration public class RabbitConfig { @Bean public Queue delayedQueue() { return QueueBuilder.durable("delayed.queue") .withArgument("x-dead-letter-exchange", "normal.exchange") .withArgument("x-dead-letter-routing-key", "normal.routingkey") .build(); } @Bean public CustomExchange delayedExchange() { Map<String, Object> args = new HashMap<>(); args.put("x-delayed-type", "direct"); return new CustomExchange("delayed.exchange", "x-delayed-message", true, false, args); } @Bean public Binding binding() { return BindingBuilder.bind(delayedQueue()) .to(delayedExchange()) .with("delayed.routingkey") .noargs(); } } ``` 在上面的例子中,我们定义了一个 `delayedQueue` 队列,它的死信交换器是 `normal.exchange`,死信路由键是 `normal.routingkey`。我们还定义了一个 `delayedExchange` 交换器,它的类型是 `x-delayed-message`,并将 `x-delayed-type` 属性设置为 `direct`。最后,我们将 `delayedQueue` 队列绑定到 `delayedExchange` 交换器上,并使用路由键 `delayed.routingkey`。 5. 发送延时消息 你可以使用 `RabbitTemplate` 类来发送消息到 `delayedQueue` 队列。在发送消息时,你需要将消息的 `headers` 属性设置为 `x-delay`,并将值设置为消息的延时时间(单位为毫秒)。 ```java @Autowired private RabbitTemplate ### 回答2: 在Spring Boot实现RabbitMQ延时队列需要以下几个步骤: 1. 首先,我们需要定义一个交换机(Exchange),用于将消息发送到延时队列中。可以使用DirectExchange、TopicExchange或FanoutExchange等不同类型的交换机。交换机的类型根据具体的业务需求而定。 2. 接下来,我们需要定义两个队列,一个为延时队列,另一个为业务队列。延时队列用于接收需要延时处理的消息,业务队列用于接收延时队列中处理完成的消息。 3. 创建并配置消息发送和接收的相关组件。使用RabbitTemplate来发送消息到延时队列,创建一个消费者来接收延时队列中的消息并处理。 4. 在消息发送时,可以通过给消息设置不同的过期时间来实现延时功能。在发送消息时,将消息携带的延时时间设置为过期时间,然后发送到延时队列中。 5. 在消费者中,监听业务队列,当接收到延时队列中的消息时,进行相应的处理,例如发送邮件、生成报表等。 这样就实现RabbitMQ延时队列的功能。通过设置消息的过期时间,可以控制消息何时被消费。延时队列可以在某个特定的时间点将消息转发到业务队列,完成后续处理。Spring Boot提供了简单而强大的集成,可以轻松实现延时队列的功能。 ### 回答3: 实现RabbitMQ延时队列的核心思想是利用RabbitMQ的插件(x-delayed-message)和Spring Boot的消息中间件(RabbitTemplate)结合使用。 首先,确保在RabbitMQ服务中安装了插件。在RabbitMQ的安装目录下,执行以下命令: ``` rabbitmq-plugins enable rabbitmq_delayed_message_exchange ``` 接下来,在Spring Boot项目的pom.xml文件中添加RabbitMQ的依赖: ```xml <dependencies> <!-- RabbitMQ --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> </dependencies> ``` 然后,创建一个配置类,用于连接RabbitMQ服务和创建延时队列: ```java @Configuration public class RabbitMQConfig { @Autowired private Environment env; @Bean public ConnectionFactory connectionFactory() { CachingConnectionFactory connectionFactory = new CachingConnectionFactory(); connectionFactory.setAddresses(env.getProperty("spring.rabbitmq.addresses")); connectionFactory.setUsername(env.getProperty("spring.rabbitmq.username")); connectionFactory.setPassword(env.getProperty("spring.rabbitmq.password")); return connectionFactory; } @Bean public RabbitTemplate rabbitTemplate() { RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory()); rabbitTemplate.setMessageConverter(jsonMessageConverter()); return rabbitTemplate; } @Bean public MessageConverter jsonMessageConverter() { return new Jackson2JsonMessageConverter(); } @Bean public Exchange delayedExchange() { Map<String, Object> args = new HashMap<>(); args.put("x-delayed-type", "direct"); return new CustomExchange("delayed-exchange", "x-delayed-message", true, false, args); } @Bean public Queue delayedQueue() { return new Queue("delayed-queue", true); } @Bean public Binding delayedBinding() { return BindingBuilder.bind(delayedQueue()).to(delayedExchange()).with("delayed-routing-key").noargs(); } } ``` 在上述代码中,我们创建了一个自定义的Exchange,将其类型设置为"x-delayed-message",并创建了一个延时队列,将其绑定在这个Exchange上。这样,消息发送到这个Exchange时,会根据消息中的延时时间属性进行延时处理。 最后,我们可以通过RabbitTemplate发送延时消息: ```java @Service public class RabbitMQService { @Autowired private RabbitTemplate rabbitTemplate; public void sendDelayedMessage(String message, int delayTime) { rabbitTemplate.convertAndSend("delayed-exchange", "delayed-routing-key", message, new MessagePostProcessor() { @Override public Message postProcessMessage(Message message) throws AmqpException { message.getMessageProperties().setHeader("x-delay", delayTime); return message; } }); } } ``` 在上述代码中,我们通过rabbitTemplate将消息发送到名为"delayed-exchange"的Exchange上,并设置消息的延时时间属性"x-delay"。最后,通过"convertAndSend"方法发送消息。 以上就是使用Spring Boot实现RabbitMQ延时队列的简单示例。通过这种方式,我们可以轻松地实现消息的延时处理,使得系统更加灵活和高效。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值