JavaMail读取收件箱退信邮件/分析邮件附件获取Message_Id

需求描述：公司最近有个项目邮件通知功能，但是客户上传的邮件地址并不一定存在，以及其他的各种问题。所有希望发送通知后有个回执，及时发现地址存在问题的邮箱。

需求分析：经过分析JavaMail可以读取收件箱邮件，我们可以通过对应通知的退信来回写通知状态。那么问题来了，发送通知和退信如何建立映射？经过调研，最终确定采用以下方案解决。

映射方案：

1. 在发送邮件通知时在Header中指定自定义的Message_Id，作为唯一标示，本系统中采用UUID。
2. 定时任务扫描服务器邮箱的收件箱，本系统我们搜索收件箱中前30分钟内的主题为：“来自postmaster@net.cn的退信”,的退信邮件。
3. 分析退信附件，退信关联邮件信息存在附件中，我们需要的Message_Id也在其中，解析附件获取Message_Id回写通知状态。

核心代码：

邮件搜索

 package com.yinghuo.yingxinxin.notification.service;

 import com.yinghuo.yingxinxin.notification.domain.PayrollNotificationEntity;
 import com.yinghuo.yingxinxin.notification.domain.valobj.EmailNotificationStatus;
 import com.yinghuo.yingxinxin.notification.repository.NotificationRepository;
 import com.yinghuo.yingxinxin.notification.util.DateUtil;
 import com.yinghuo.yingxinxin.notification.util.EmailUtil;
 import com.yinghuo.yingxinxin.notification.util.StringUtil;
 import lombok.Data;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang.exception.ExceptionUtils;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

 import javax.mail.*;
 import javax.mail.search.AndTerm;
 import javax.mail.search.ComparisonTerm;
 import javax.mail.search.SearchTerm;
 import javax.mail.search.SentDateTerm;
 import javax.mail.search.SubjectTerm;
 import java.util.Arrays;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.Properties;

 @Service
 @Slf4j
 @Data
 @ConfigurationProperties(prefix = "spring.mail")
 public class EmailBounceScanService {
     private final static String subjectKeyword = "来自postmaster@net.cn的退信";

     private String popHost;
     private String username;
     private String password;
     private Integer timeOffset;
     private final NotificationRepository payrollSendRecordRepository;

     private Properties buildInboxProperties() {
         Properties properties = new Properties();
         properties.setProperty("mail.store.protocol", "pop3");
         properties.setProperty("mail.pop3.host", popHost);
         properties.setProperty("mail.pop3.auth", "true");
         properties.setProperty("mail.pop3.default-encoding", "UTF-8");
         return properties;
     }

     public void searchInboxEmail() {
         Session session = Session.getInstance(this.buildInboxProperties());
         Store store = null;
         Folder receiveFolder = null;
         try {
             store = session.getStore("pop3");
             store.connect(username, password);
             receiveFolder = store.getFolder("inbox");
             receiveFolder.open(Folder.READ_ONLY);

             int messageCount = receiveFolder.getMessageCount();
             if (messageCount > 0) {
                 Date now = Calendar.getInstance().getTime();
                 Date timeOffsetAgo = DateUtil.nextXMinute(now, timeOffset);
                 SearchTerm comparisonTermGe = new SentDateTerm(ComparisonTerm.GE, timeOffsetAgo);
                 SearchTerm search = new AndTerm(new SubjectTerm(subjectKeyword), comparisonTermGe);

                 Message[] messages = receiveFolder.search(search);
                 if (messages.length == 0) {
                     log.info("No bounce email was found.");
                     return;
                 }
                 this.messageHandler(messages);
             }
         } catch (MessagingException e) {
             log.error("Exception in searchInboxEmail {}", ExceptionUtils.getFullStackTrace(e));
             e.printStackTrace();
         } finally {
             try {
                 if (receiveFolder != null) {
                     receiveFolder.close(true);
                 }
                 if (store != null) {
                     store.close();
                 }
             } catch (MessagingException e) {
                 log.error("Exception in searchInboxEmail {}", ExceptionUtils.getFullStackTrace(e));
                 e.printStackTrace();
             }
         }
     }

     @Transactional
     public void messageHandler(Message[] messageArray) {
         Arrays.stream(messageArray).filter(EmailUtil::isContainAttachment).forEach((message -> {
             String messageId = null;
             try {
                 messageId = EmailUtil.getMessageId(message);
             } catch (Exception e) {
                 log.error("getMessageId:", ExceptionUtils.getFullStackTrace(e));
                 e.printStackTrace();
             }
             if (StringUtil.isEmpty(messageId)) return;

             PayrollNotificationEntity payrollNotificationEntity = payrollSendRecordRepository.findFirstByMessageId(messageId);
             if (payrollNotificationEntity == null || EmailNotificationStatus.BOUNCE.getStatus() == payrollNotificationEntity.getStatus()) {
                 log.warn("not found payrollNotificationEntity by messageId:{}", messageId);
                 return;
             }

             payrollNotificationEntity.setStatus(EmailNotificationStatus.BOUNCE.getStatus());
             payrollNotificationEntity.setErrorMessage(EmailNotificationStatus.BOUNCE.getErrorMessage());
             payrollSendRecordRepository.save(payrollNotificationEntity);
         }));
     }
 }

附件解析

 package com.yinghuo.yingxinxin.notification.util;

 import lombok.extern.slf4j.Slf4j;

 import javax.mail.BodyPart;
 import javax.mail.MessagingException;
 import javax.mail.Multipart;
 import javax.mail.Part;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;

 @Slf4j
 public final class EmailUtil {
     private static final String multipart = "multipart/*";

     public static String getMessageId(Part part) throws Exception {
         if (!part.isMimeType(multipart)) {
             return "";
         }

         Multipart multipart = (Multipart) part.getContent();
         for (int i = 0; i < multipart.getCount(); i++) {
             BodyPart bodyPart = multipart.getBodyPart(i);

             if (part.isMimeType("message/rfc822")) {
                 return getMessageId((Part) part.getContent());
             }
             InputStream inputStream = bodyPart.getInputStream();

             try (BufferedReader br = new BufferedReader(new InputStreamReader(inputStream))) {
                 String strLine;
                 while ((strLine = br.readLine()) != null) {
                     if (strLine.startsWith("Message_Id:")) {
                         String[] split = strLine.split("Message_Id:");
                         return split.length > 1 ? split[1].trim() : null;
                     }
                 }
             }
         }

         return "";
     }

     public static boolean isContainAttachment(Part part) {
         boolean attachFlag = false;
         try {
             if (part.isMimeType(multipart)) {
                 Multipart mp = (Multipart) part.getContent();
                 for (int i = 0; i < mp.getCount(); i++) {
                     BodyPart mpart = mp.getBodyPart(i);
                     String disposition = mpart.getDisposition();
                     if ((disposition != null) && ((disposition.equals(Part.ATTACHMENT)) || (disposition.equals(Part.INLINE))))
                         attachFlag = true;
                     else if (mpart.isMimeType(multipart)) {
                         attachFlag = isContainAttachment((Part) mpart);
                     } else {
                         String contype = mpart.getContentType();
                         if (contype.toLowerCase().contains("application"))
                             attachFlag = true;
                         if (contype.toLowerCase().contains("name"))
                             attachFlag = true;
                     }
                 }
             } else if (part.isMimeType("message/rfc822")) {
                 attachFlag = isContainAttachment((Part) part.getContent());
             }
         } catch (MessagingException | IOException e) {
             e.printStackTrace();
         }
         return attachFlag;
     }
 }