邮件群发问题

　　在做邮件发送时遇到一个问题以及解决方式，记录一下。

　　我们公司的邮箱是Coremail的企业邮箱，群发邮件时发现，如果有一个邮箱地址不存在，那么本次群发会失败；而群发其他的邮箱时如qq邮箱，163邮箱如果有一个地址不存在，那么本次发送还是成功的。所以猜测可能与邮箱服务器有关。

　　为了解决给北纬邮箱群发的问题，我网上查了一下，看了一下 java mail 的 api，发现发送邮件调用 send 方法时，失败会抛出异常 javax.mail.SendFailedException，而这个异常里面封装了三个变量：

　　invalid 是不存在的邮箱地址，validSent 是已发送的邮箱地址,validUnsent 是未发送成功的邮箱地址，因此思路就是捕获该异常，将不存在的邮箱地址去除后再次发送即可。简单的封装了一下 java mail：

　　

import javax.activation.DataHandler;
import javax.activation.FileDataSource;
import javax.mail.*;
import javax.mail.internet.*;
import java.io.File;
import java.io.UnsupportedEncodingException;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;

/**
 * 邮件发送
 *
 * @author Xiaosy
 * @date 2017-12-28 14:26
 */
public class EmailSender {
    /**
     * 邮件服务器地址
     */
    private String host;
    /**
     * 发件人用户名
     */
    private String username;
    /**
     * 发件人密码
     */
    private String password;

    private String from;
    /**
     * 邮件对象
     */
    private MimeMessage mimeMessage;
    /**
     * 接收方邮件地址
     */
    private InternetAddress[] addresses;
    /**
     * 无效的邮箱地址
     */
    private String[]invalidAddresses;
    /**
     * 已发送的邮箱
     */
    private String[]validSendAddresses;
    /**
     * 未发送成功的邮箱地址
     */
    private String[]validUnSendAddresses;
    private Session session;
    private Properties props;
    //附件添加的组件
    private Multipart mp;
    //附件文件
    private List<FileDataSource> files = new LinkedList<FileDataSource>();


    private EmailSender(String from, String smtpHost, String sendUserName, String sendUserPassword){
        this.from = from;
        this.host = smtpHost;
        this.username = sendUserName;
        this.password = sendUserPassword;
        init();
    }
    private void init(){
        if (props == null) {
            props = System.getProperties();
        }
        props.put("mail.smtp.host", this.host);
        props.put("mail.smtp.auth", "true"); // 需要身份验证
        props.put("mail.mime.splitlongparameters","false");
        session = Session.getDefaultInstance(props, null);
        // 置true可以在控制台（console)上看到发送邮件的过程
        session.setDebug(false);
        // 用session对象来创建并初始化邮件对象
        mimeMessage = new MimeMessage(session);
        // 生成附件组件的实例
        mp = new MimeMultipart();
    }

    public static EmailSender newInstance(String from, String smtpHost, String sendUserName, String sendUserPassword){
        return new EmailSender(from,smtpHost, sendUserName, sendUserPassword);
    }

    /**
     * 设置邮件主题
     * @param subject
     * @return
     * @throws MessagingException
     */
    public EmailSender subject(String subject) throws MessagingException{
        this.mimeMessage.setSubject(subject);
        return this;
    }
    public EmailSender subject(String subject, String charset) throws MessagingException{
        this.mimeMessage.setSubject(subject,charset);
        return this;
    }

    /**
     * 设置正文，支持html标签
     * @param content
     * @return
     * @throws MessagingException
     */
    public EmailSender content(String content) throws MessagingException{
        BodyPart bp = new MimeBodyPart();
        bp.setContent("<meta http-equiv=Content-Type content=text/html; charset=UTF-8>" + content, "text/html;charset=UTF-8");
        this.mp.addBodyPart(bp);
        return this;
    }

    /**
     * 设置收件人
     * @param to
     * @return
     * @throws MessagingException
     */
    public EmailSender to(String...to) throws MessagingException {
        this.addresses = new InternetAddress[to.length];
        for(int i =0;i<to.length;i++){
            this.addresses[i] = new InternetAddress(to[i]);
        }
        return this;
    }
    public EmailSender to(String to) throws MessagingException {
        this.addresses = new InternetAddress[]{new InternetAddress(to)};
        return this;
    }

    /**
     * 设置抄送
     * @param cc
     * @return
     * @throws MessagingException
     */
    public EmailSender cc(String...cc) throws MessagingException {
        InternetAddress[]addresses = new InternetAddress[cc.length];
        for(int i =0;i<cc.length;i++){
            addresses[i] = new InternetAddress(cc[i]);
        }
        this.mimeMessage.setRecipients(Message.RecipientType.CC,addresses);
        return this;
    }
    public EmailSender cc(String cc) throws MessagingException {
        InternetAddress[]addresses = new InternetAddress[]{new InternetAddress(cc)};
        this.mimeMessage.setRecipients(Message.RecipientType.TO,addresses);
        return this;
    }

    /**
     * 添加附件，可添加多个
     * @param fileName
     * @param file
     * @return
     * @throws MessagingException
     * @throws UnsupportedEncodingException
     */
    public EmailSender addAttachmentFile(String fileName, File file) throws MessagingException, UnsupportedEncodingException {
        BodyPart bp = new MimeBodyPart();
        FileDataSource fileds = new FileDataSource(file);
        bp.setDataHandler(new DataHandler(fileds));
        bp.setFileName(MimeUtility.encodeText(fileName, "utf-8", null)); // 解决附件名称乱码
        this.mp.addBodyPart(bp);// 添加附件
        this.files.add(fileds);
        return this;
    }

    /**
     * 发送邮件
     * @param skpiInvalidAddresses 是否跳过不正确的邮箱地址，true跳过,默认不跳过
     * @return
     */
    public boolean send(boolean skpiInvalidAddresses){
        Transport transport = null;
        try {
            this.mimeMessage.setRecipients(Message.RecipientType.TO,this.addresses);
            this.mimeMessage.setFrom(this.from);
            this.mimeMessage.setContent(this.mp);
            this.mimeMessage.saveChanges();
            System.out.println("邮件发送中...");
            transport = this.session.getTransport("smtp");
            //连接邮件服务器并进行身份验证
            transport.connect(this.host,this.username,this.password);
            //发送邮件
            transport.sendMessage(this.mimeMessage,this.addresses);
            System.out.println("发送成功");
            this.validSendAddresses = new String[this.addresses.length];
            for(int i=0;i<this.addresses.length;i++){
                this.validSendAddresses[i] = this.addresses[i].toString();
            }
        }catch (SendFailedException e){
            Address[]invalid = e.getInvalidAddresses();
            if(invalid != null && invalid.length > 0){
                this.invalidAddresses = new String[invalid.length];
                for(int i=0;i<invalid.length;i++){
                    this.invalidAddresses[i]=invalid[i].toString();
                }
            }
            Address[]validSendTo = e.getValidSentAddresses();
            if(validSendTo != null && validSendTo.length > 0){
                this.validSendAddresses = new String[validSendTo.length];
                for(int i=0;i<validSendTo.length;i++){
                    this.validSendAddresses[i]=validSendTo[i].toString();
                }
            }
            Address[]validUnSendTo = e.getValidUnsentAddresses();
            if(validUnSendTo != null && validUnSendTo.length > 0){
                this.validUnSendAddresses = new String[validUnSendTo.length];
                for(int i=0;i<validUnSendTo.length;i++){
                    this.validUnSendAddresses[i]=validUnSendTo[i].toString();
                }
            }
            //跳过不正确的邮箱
            if(skpiInvalidAddresses && invalid != null && invalid.length>0){
                if(validUnSendTo != null && validUnSendTo.length > 0){
                    this.validUnSendAddresses = null;
                    return sendFailedAddresses(validUnSendTo);
                }
            }else {
                return false;
            }

        } catch (MessagingException e) {
            e.printStackTrace();
            return false;
        }finally {
            if(transport != null){
                try {
                    transport.close();
                } catch (MessagingException e) {
                    e.printStackTrace();
                }
            }
        }
        return true;
    }

    public boolean send(){
        return send(false);
    }

    private boolean sendFailedAddresses(Address[]failedAddresses){
        Transport transport = null;
        try {
            this.mimeMessage.setRecipients(Message.RecipientType.TO,failedAddresses);
            transport = this.session.getTransport("smtp");
            //连接邮件服务器并进行身份验证
            transport.connect(this.host,this.username,this.password);
            //发送邮件
            transport.sendMessage(this.mimeMessage,failedAddresses);
            this.validSendAddresses = new String[failedAddresses.length];
            for(int i=0;i<failedAddresses.length;i++){
                this.validSendAddresses[i] = failedAddresses[i].toString();
            }
        }catch (SendFailedException e){
            e.printStackTrace();
            return false;
        }catch (MessagingException e){
            e.printStackTrace();
            return false;
        }
        return true;
    }


    public String[] getInvalidAddresses() {
        return invalidAddresses;
    }

    public void setInvalidAddresses(String[] invalidAddresses) {
        this.invalidAddresses = invalidAddresses;
    }

    public String[] getValidSendAddresses() {
        return validSendAddresses;
    }

    public void setValidSendAddresses(String[] validSendAddresses) {
        this.validSendAddresses = validSendAddresses;
    }

    public String[] getValidUnSendAddresses() {
        return validUnSendAddresses;
    }

    public void setValidUnSendAddresses(String[] validUnSendAddresses) {
        this.validUnSendAddresses = validUnSendAddresses;
    }
}

　　测试代码如下：

　　

 @Test
public void testSendMail(){
    String subject = "测试用";
    String content = "测试内容";
    String[]emails = new String[]{"myqq@qq.com","aaa@abc.com","bbb@bw.com"};

    try {
        EmailSender javaMailSender = EmailSender.newInstance(from,mailConfiguration.getHost(),mailConfiguration.getUsername(),mailConfiguration.getPassword())
                    .subject(subject).content(content).to(emails);
        System.out.println(javaMailSender.send());
        String[]invalidAddress = javaMailSender.getInvalidAddresses();
        System.out.println("Invalid address : " + JSONObject.toJSONString(invalidAddress));
        String[]validUnSentAddress = javaMailSender.getValidUnSendAddresses();
        System.out.println("valid unsent address : " + JSONObject.toJSONString(validUnSentAddress));
        String[]validSentAddress = javaMailSender.getValidSendAddresses();
        System.out.println("valid sent address : " + JSONObject.toJSONString(validSentAddress));
    } catch (MessagingException e) {
        e.printStackTrace();
    }
}

其中，send() 方法默认是不跳过不存在的邮箱地址的，如果要自动跳过，参数设置为 true 即可：
默认时的结果如下：

参数设置为 true 时结果如下：

而我的 qq 邮箱也确实收到了邮件。

如果使用 spring 封装的 mail，调用 mailSender.send(MimeMessage message) 方法时抛出的异常是 org.springframework.mail.MailSendException，查看源码发现这个异常并没有 ivali dAddress、validSentAddress 和 validUnSentAddress 三个变量，但是它有一个异常数组：

javax.mail.SendFailedException 应该被放到了这里面，修改 spring 发送邮件的代码如下：

/**
 * 发送邮件
 * @param skpiInvalidAddresses 是否跳过不正确的邮箱地址，true跳过,默认不跳过
 * @return
 */
public boolean send(boolean skpiInvalidAddresses) throws IllegalStateException{
    if(mailSender == null){
        LOGGER.info("Mail Sender Instance is not allowed null");
        throw new IllegalStateException("You should call newInstance() method first before call send() method");
    }
    try {
        mailSender.send(this.message);
    }catch (MailSendException e){
        Exception[] messageExceptions = e.getMessageExceptions();
        if(messageExceptions != null && messageExceptions.length > 0) {
            SendFailedException subEx = null;
            for (int i = 0; i < messageExceptions.length; ++i) {
                if (messageExceptions[i] instanceof SendFailedException) {
                    subEx = (SendFailedException) messageExceptions[i];
                    break;
                }
            }
            if (subEx == null) {
                return false;
            }
            Address[] invalid = subEx.getInvalidAddresses();
            if (invalid != null) {
                this.invalidAddresses = new String[invalid.length];
                for (int j = 0; j < invalid.length; j++) {
                    this.invalidAddresses[j] = invalid[j].toString();
                }
            }

            Address[] validUnsentAddresses = subEx.getValidUnsentAddresses();
            if (validUnsentAddresses != null) {
                this.validUnSendAddresses = new String[validUnsentAddresses.length];
                for (int j = 0; j < validUnsentAddresses.length; j++) {
                    this.validUnSendAddresses[j] = validUnsentAddresses[j].toString();
                }
            }

            Address[]validSentAddresses = subEx.getValidSentAddresses();
            if(validSentAddresses != null){
                this.validSendAddresses = new String[validSentAddresses.length];
                for(int j=0;j<validSentAddresses.length;j++){
                    this.validSendAddresses[j] = validSentAddresses[j].toString();
                }
            }

            if(skpiInvalidAddresses){
                return sendFailedAddress(this.validUnSendAddresses);
            }else {
                return false;
            }
        }
    }
    return true;
}

经过测试同样可以正常工作。

需要注意的是，发送邮件前必须设置 From 字段，如果未设置此字段，invalidAddress 是获取不到地址错误的邮箱的，而导致群发的所有邮箱地址放到了 validUnSentAddress 里面，这样就跟通常的情况是一样的了。

小提示：邮件发送 html 的内容时，如果有图片时，使用图片链接显示的话，很多邮箱服务器会屏蔽外部链接导致图片显示出现问题，可以采用内嵌方式将图片内嵌入正文中，但是这种方式会增加邮件大小。