SpringBoot基于RabbitMQ发送邮件

SpringBoot基于RabbitMQ发送邮件

一. 背景

​ 新用户注册成功后，服务器会给用户发一份电子邮件，所以一共有两个模块。一个模块功能是用户注册，另一个模块功能是发送电子邮件。

​ 当用户注册成功，此时服务器会将邮件信息(MailMessage)和路由key发送到交换机中(mail.exchange)，交换机根据路由key再将邮件信息发送到邮件队列(mail.queue)中。发送邮件模板此时会监听该队列，一旦队列中有消息，那么它就会将邮件信息取出来，发送出去。

• 用户注册模块：springboot-mail-broker
• 发送邮件模块：springboot-user-demo

二. 用户注册模块

2.1 添加依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>

2.2 配置文件

server.port=8082
spring.application.name=springboot-user-demo

#rabbitmq配置
spring.rabbitmq.host=192.168.74.129
spring.rabbitmq.port=5672
spring.rabbitmq.password=winter
spring.rabbitmq.username=winter
spring.rabbitmq.virtual-host=rabbitmq-demo
#消费者的并发数量
spring.rabbitmq.listener.simple.concurrency=10
#消费者的最大并发数量
spring.rabbitmq.listener.simple.max-concurrency=20
#每个消费者每次监听时可拉取处理的消息数量
spring.rabbitmq.listener.direct.prefetch=5

2.3 邮件信息类

• 用于将邮件信息传递到发送模块

public class MailMessage implements Serializable {

    private static final long serialVersionUID = 136177995387991971L;
    private String to;
    private String from;
    private String subject;
    private String content;
    private Date sentDate;

    public String getTo() {
        return to;
    }

    public void setTo(String to) {
        this.to = to;
    }

    public String getFrom() {
        return from;
    }

    public void setFrom(String from) {
        this.from = from;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Date getSentDate() {
        return sentDate;
    }

    public void setSentDate(Date sentDate) {
        this.sentDate = sentDate;
    }

    @Override
    public String toString() {
        return "MailMessage{" +
                "to='" + to + '\'' +
                ", from='" + from + '\'' +
                ", subject='" + subject + '\'' +
                ", content='" + content + '\'' +
                ", sentDate=" + sentDate +
                '}';
    }
}

2.4 配置RabbitMQ

2.4.1 配置RabbitTemplate

package com.prosay.springboot.config;
@Configuration
public class RabbitmqConfig {
    private final static Logger log = LoggerFactory.getLogger(RabbitmqConfig.class);
    @Autowired
    private CachingConnectionFactory connectionFactory;

    @Bean
    public RabbitTemplate rabbitTemplate(){
        //消息发送到交换机后，是否调用回调方法
        connectionFactory.setPublisherConfirms(true);
        //消息从交换机发送到队列，是否调用回调方法
        connectionFactory.setPublisherReturns(true);
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMessageConverter(converter());

        //消息是否发送到了交换机
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (ack) {
                    log.info("消息发送成功:correlationData({}),ack({}),cause({})", correlationData, ack, cause);
                }else{
                    log.info("消息发送失败:correlationData({}),ack({}),cause({})", correlationData, ack, cause);
                }
            }
        });
        //如果调用setReturnCallback方法，那么Mandatory必须为true，否则Exchange没有找到Queue就会丢弃掉消息, 而不会触发回调
        rabbitTemplate.setMandatory(true);
        //消息是否从交换机发送到队列，如果发送失败就会调用returnedMessage方法
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                log.info("消息丢失:exchange({}),route({}),replyCode({}),replyText({}),message:{}",exchange,routingKey,replyCode,replyText,message);
            }
        });
        return rabbitTemplate;
    }
    
    @Bean
    public Jackson2JsonMessageConverter converter(){
        return new Jackson2JsonMessageConverter();
    }
}

2.4.2 配置队列、交换机

@Configuration
public class MailConfigForRabbitMQ {

    private static final String MAIL_QUEUE_NAME = "mail_queue";
    private static final String MAIL_EXCHANGE_NAME = "mail_exchange";
    private static final String MAIL_ROUTE_KEY = "mail_route_key";

    @Autowired
    private Environment environment;

    //创建队列
    @Bean
    public Queue mailQueue(){
        return new Queue(MAIL_QUEUE_NAME);
    }

    //创建交换机
    @Bean
    public Exchange mailExchange(){
        //durable：是否可持久化(RabbitMQ关闭后，下次启动该交换机是否存在)
        return new DirectExchange(MAIL_EXCHANGE_NAME, true, false);
    }

    //绑定交换机和队列
    @Bean
    public Binding mailBinding(Queue mailQueue, Exchange mailExchange){
       return BindingBuilder
           .bind(mailQueue)
           .to(mailExchange)
           .with(MAIL_ROUTE_KEY)
           .noargs();
    }
}

2.5 控制层

@PostMapping("/register")
@ResponseBody
public Object register(User user) {
    System.out.println("注册成功");
    
    MailMessage mail = new MailMessage();
    mail.setSubject("Spring Boot");
    mail.setContent("这是一封来自Spring Boot的邮件！");
    mail.setSentDate(new Date());
    mail.setTo("1074593588@qq.com");
    mail.setFrom("1074593588@qq.com");
    //设置交换机
    this.rabbitTemplate.setExchange("mail_exchange");
    //设置路由key
    this.rabbitTemplate.setRoutingKey("mail_route_key");
    Message message = null;
    try {
        //Message该类是RabbitMQ提供的，将邮件信息mail转化为字节后存储Message的body中，设置   				Message的传输模式
        message = MessageBuilder.withBody(objectMapper.writeValueAsBytes(mail))
            .setDeliveryMode(MessageDeliveryMode.PERSISTENT)
            .build();
        //设置Message的头属性，内容格式为json
        message.getMessageProperties()
            .setHeader(AbstractJavaTypeMapper.DEFAULT_CONTENT_CLASSID_FIELD_NAME, 		            MessageProperties.CONTENT_TYPE_JSON);
        //将邮件信息发送到交换机
        this.rabbitTemplate.convertAndSend(message);
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    }
    return "注册成功";
}

三. 发送邮件模块

3.1 添加依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-mail</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>	

3.2 配置文件

server.port=8083
spring.application.name=springboot-mail-broker

#RabbitMQ相关配置
spring.rabbitmq.password=winter
spring.rabbitmq.username=winter
spring.rabbitmq.port=5672
spring.rabbitmq.virtual-host=rabbitmq-demo
spring.rabbitmq.host=192.168.74.129
#消费者的并发数量
spring.rabbitmq.listener.simple.concurrency=10
#消费者的最大并发数量
spring.rabbitmq.listener.simple.max-concurrency=20
#每个消费者每次监听时可拉取处理的消息数量
spring.rabbitmq.listener.direct.prefetch=5

spring.devtools.restart.enabled=true

#邮件配置
spring.mail.host=smtp.qq.com
spring.mail.username=1074593588@qq.com
spring.mail.password=xttktyjpirsmjbcd
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enbale=true
spring.mail.properties.mail.smtp.starttls.required=true

3.3 监听队列

Component
public class MailServiceImpl {

    @Autowired
    private ObjectMapper objectMapper;

    @Autowired
    private JavaMailSender sender;

	//该注解开启监听指定的对列，如果队列中有消息就去出来交给sendSimpleMail方法来处理
    @RabbitListener(queues = "mail_queue")
    public void sendSimpleMail(@Payload byte[] message) {
        try {
             MailMessage mailMessage = this.objectMapper.readValue(message, MailMessage.class);//将message，转换为MailMessage对象(自定义)
            SimpleMailMessage simpleMailMessage = new SimpleMailMessage();

            simpleMailMessage.setFrom(mailMessage.getFrom());
            simpleMailMessage.setTo(mailMessage.getTo());
            simpleMailMessage.setSentDate(mailMessage.getSentDate());
            simpleMailMessage.setSubject(mailMessage.getSubject());
            simpleMailMessage.setText(mailMessage.getContent());
			//发送邮件
            this.sender.send(simpleMailMessage);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

四. 总结

• 通过postman发送请求，注册一个用户后，此时服务器会发送邮件信息到交换机，再由交换机根据路由key将信息发送到队列中。此时队列情况如下：
  
  

  • 此时邮件队列中有一个正在等待被消费的邮件信息。

• 当启动发送邮件模块时，会自动取出队列中的信息，将邮件发送出去，发送完成后，此时队列情况如下：
  

  • 队列中的邮件信息已经被取出消费。

• 至此，一个简单的通过RabbitMQ发送邮件就算完成了。

  • 提高性能，快速响应用户。