java实现从邮箱接入邮件

最近项目需要从邮箱中读取邮件并且进行解析。于是在晚上找了这么个工具类（记录一下）

public class MailMessageUtil {

    private Logger log = LoggerFactory.getLogger(MailMessageUtil.class);

    @Autowired
    private BaseFeignClient baseFeignClient;


    public List<MailMessage> receivePop3(Date startTime, Date endTime, MailConfig config) throws Exception {
        // 准备连接服务器的会话信息
        Properties props = new Properties();
        props.setProperty("mail.store.protocol", config.getProtocol());
        props.setProperty("mail.pop3.host", config.getMailHost());
        props.setProperty("mail.pop3.port", config.getMailPort());
//        props.setProperty("mail.store.protocol", config.getProtocol());
//        props.setProperty("mail.imap.host", config.getMailHost());
//        props.setProperty("mail.imap.port", config.getMailPort());
//        props .setProperty("mail.debug.auth", "true");
//        props .setProperty("mail.imap.ssl.enable", "true");
//        props .setProperty("mail.imap.auth.plain.disable", "true");
        // 创建Session实例对象
        log.warn("创建session！");
        Session session = Session.getInstance(props);
        // 创建POP3协议的Store对象
        Store store = session.getStore(config.getProtocol());
        // 连接邮件服务器
        log.warn("开始 connect ！");
        store.connect(config.getUserName(), config.getPasswowrd());
        // 获得收件箱
        log.warn("获取收件箱！");
        Folder folder = store.getFolder("INBOX");
        // 以读写模式打开收件箱
        folder.open(Folder.READ_WRITE);
        // 获得收件箱的邮件列表
        //搜索条件
//        Date timePoint = new Date();
//        Calendar calendar = Calendar.getInstance();
//        calendar.setTime(timePoint);
//        calendar.add(Calendar.DAY_OF_YEAR, -1);
//        Calendar cal = Calendar.getInstance();
//        cal.setTime(endTime);
//        cal.add(Calendar.DAY_OF_YEAR, -2);
//        startTime = cal.getTime();
        SearchTerm geTerm = new ReceivedDateTerm(ComparisonTerm.GE, startTime);
        /*
            不知道什么原因，协议由之前的pop3协议改为现在imap协议之后，这个时间范围搜索不起作用
            所以最新查取一天前之后的所有邮件，在邮件列表中再根据时间过滤
         */
        SearchTerm leTerm = new ReceivedDateTerm(ComparisonTerm.LT, endTime);
        SearchTerm andTerm = new AndTerm(geTerm, leTerm);
        log.warn("搜索邮件！");
        Message[] messages = folder.search(andTerm);
//        // 打印不同状态的邮件数量
//        System.out.println("收件箱中共" + messages.length + "封邮件!");
//        System.out.println("收件箱中共" + folder.getUnreadMessageCount() + "封未读邮件!");
//        System.out.println("收件箱中共" + folder.getNewMessageCount() + "封新邮件!");
//        System.out.println("收件箱中共" + folder.getDeletedMessageCount() + "封已删除邮件!");
//        System.out.println("------------------------开始解析邮件----------------------------------");
//        int total = folder.getMessageCount();
//        System.out.println("-----------------您的邮箱共有邮件：" + total + " 封--------------");
//        // 得到收件箱文件夹信息，获取邮件列表
//        Message[] msgs = folder.getMessages();
//        System.out.println("\t收件箱的总邮件数：" + msgs.length);
        log.warn("邮件列表！");
        List<MailMessage> mailList = parseMessage(startTime, endTime, messages);
        log.warn("解析完毕！");
//        List<MailMessage> returnList = new ArrayList<>();
//        for(MailMessage mailMessage : mailList){
//            if(Date.from(mailMessage.getReceiveTime()).getTime() >= startTime.getTime() && Date.from(mailMessage.getReceiveTime()).getTime() < endTime.getTime()){
//                returnList.add(mailMessage);
//            }
//        }
        folder.close(false);
        store.close();
        return mailList;
    }


    /**
    * @Description:   imap
    * @Author:         
    * @CreateDate:     2020/10/20 15:58
    * @Version:        1.0
    */
    public List<MailMessage> receiveImap(Date startTime, Date endTime, MailConfig config) throws Exception {
        // 准备连接服务器的会话信息
        Properties props = new Properties();
//        props.setProperty("mail.store.protocol", config.getProtocol());
//        props.setProperty("mail.pop3.host", config.getMailHost());
//        props.setProperty("mail.pop3.port", config.getMailPort());
        props.setProperty("mail.store.protocol", config.getProtocol());
        props.setProperty("mail.imap.host", config.getMailHost());
        props.setProperty("mail.imap.port", config.getMailPort());
        props.setProperty("mail.debug.auth", "true");
        props.setProperty("mail.imap.ssl.enable", "true");
        props.setProperty("mail.imap.auth.plain.disable", "true");
        // 创建Session实例对象
        log.warn("创建session！");
        Session session = Session.getInstance(props);
        // 创建POP3协议的Store对象
        Store store = session.getStore(config.getProtocol());
        // 连接邮件服务器
        log.warn("开始 connect ！");
        store.connect(config.getUserName(), config.getPasswowrd());
        // 获得收件箱
        log.warn("获取收件箱！");
        Folder folder = store.getFolder("INBOX");
        // 以读写模式打开收件箱
        folder.open(Folder.READ_WRITE);
        // 获得收件箱的邮件列表
        //搜索条件
        Date timePoint = new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(timePoint);
        calendar.add(Calendar.DAY_OF_YEAR, -1);
//        Calendar cal = Calendar.getInstance();
//        cal.setTime(endTime);
//        cal.add(Calendar.DAY_OF_YEAR, -2);
//        startTime = cal.getTime();
        SearchTerm geTerm = new ReceivedDateTerm(ComparisonTerm.GE, calendar.getTime());

        /*
            不知道什么原因，协议由之前的pop3协议改为现在imap协议之后，这个时间范围搜索不起作用
            所以最新查取一天前之后的所有邮件，在邮件列表中再根据时间过滤
         */
//        SearchTerm leTerm = new ReceivedDateTerm(ComparisonTerm.LT, new Timestamp(endTime.getTime()));
//        SearchTerm andTerm = new AndTerm(geTerm);
        log.warn("搜索邮件！");
        Message[] messages = folder.search(geTerm);
//        // 打印不同状态的邮件数量
//        System.out.println("收件箱中共" + messages.length + "封邮件!");
//        System.out.println("收件箱中共" + folder.getUnreadMessageCount() + "封未读邮件!");
//        System.out.println("收件箱中共" + folder.getNewMessageCount() + "封新邮件!");
//        System.out.println("收件箱中共" + folder.getDeletedMessageCount() + "封已删除邮件!");
//        System.out.println("------------------------开始解析邮件----------------------------------");
//        int total = folder.getMessageCount();
//        System.out.println("-----------------您的邮箱共有邮件：" + total + " 封--------------");
//        // 得到收件箱文件夹信息，获取邮件列表
//        Message[] msgs = folder.getMessages();
//        System.out.println("\t收件箱的总邮件数：" + msgs.length);
        log.warn("邮件列表！{}", messages.length);
        List<MailMessage> mailList = parseMessage(startTime, endTime, messages);
        log.warn("解析完毕！{}", mailList.size());
        List<MailMessage> returnList = new ArrayList<>();
        for(MailMessage mailMessage : mailList){
            if(Date.from(mailMessage.getReceiveTime()).getTime() >= startTime.getTime() && Date.from(mailMessage.getReceiveTime()).getTime() < endTime.getTime()){
                returnList.add(mailMessage);
            }
        }
        folder.close(false);
        store.close();
        return returnList;
    }

    /**
     * 解析邮件
     * @param messages 要解析的邮件列表
     */
    public List<MailMessage> parseMessage(Date startTime, Date endTIme, Message ...messages) throws MessagingException, IOException {
        System.setProperty("mail.mime.decodetext.strict", "false");
        List<MailMessage> mailList = new ArrayList<>();
        if (messages == null || messages.length < 1){
            return mailList;
        }
        // 解析所有邮件
        for (int i = 0, count = messages.length; i < count; i++) {
            MailMessage mailMessage = new MailMessage();
            MimeMessage msg = (MimeMessage) messages[i];
            Date receiveDate = msg.getReceivedDate();
            if(receiveDate == null || receiveDate.getTime() < startTime.getTime() || receiveDate.getTime() > endTIme.getTime()){
                continue;
            }
            boolean isContainerAttachment = isContainAttachment(msg);
            StringBuffer content = new StringBuffer(30);
            String contentType = msg.getContentType();

            //part.getContentType()里既有plain又有html，这是为了防止一些无法解析html的地方也能收到邮件内容，所以才重复的发2段同样的内容
            if(contentType.startsWith("text/plain")){
                getMailTextContent(msg, content, true);
            }else{
                getMailTextContent(msg, content, false);
            }
            mailMessage.setSubject(getSubject(msg));
            mailMessage.setSendAddress(getFrom(msg));
            mailMessage.setReceiveAddress(getReceiveAddress(msg, null));
            mailMessage.setSendTime(msg.getSentDate() == null ? null : msg.getSentDate().toInstant());
            mailMessage.setReceiveTime(msg.getReceivedDate() == null ? null : msg.getReceivedDate().toInstant());
            mailMessage.setIsSeen(isSeen(msg));
            mailMessage.setMailPriority(getPriority(msg));
            mailMessage.setIsReply(isReplySign(msg));
            mailMessage.setMailSize(msg.getSize());
            mailMessage.setIsContainerAttachment(isContainAttachment(msg));
            mailMessage.setContent(content.toString());
            if (isContainerAttachment) {
                mailMessage.setAttachIds(saveAttachment(msg));
            }
            mailList.add(mailMessage);
        }
        return mailList;
    }

    /**
     * 获得邮件主题
     * @param msg 邮件内容
     * @return 解码后的邮件主题
     */
    public static String getSubject(MimeMessage msg) throws UnsupportedEncodingException, MessagingException {
        return MimeUtility.decodeText(msg.getSubject() == null ? "":msg.getSubject());
    }

    /**
     * 获得邮件发件人
     * @param msg 邮件内容
     * @return 姓名 <Email地址>
     * @throws MessagingException
     * @throws UnsupportedEncodingException
     */
    public static String getFrom(MimeMessage msg) throws MessagingException, UnsupportedEncodingException {
        String from = "";
        Address[] froms = msg.getFrom();
        if (froms.length < 1){
            return  from;
        }
        InternetAddress address = (InternetAddress) froms[0];
        String person = address.getPersonal();
        if (person != null) {
            person = MimeUtility.decodeText(person) + " ";
        } else {
            person = "";
        }
        from = person + "<" + address.getAddress() + ">";
        return address.getAddress();
    }

    /**
     * 根据收件人类型，获取邮件收件人、抄送和密送地址。如果收件人类型为空，则获得所有的收件人
     * <p>Message.RecipientType.TO  收件人</p>
     * <p>Message.RecipientType.CC  抄送</p>
     * <p>Message.RecipientType.BCC 密送</p>
     * @param msg 邮件内容
     * @param type 收件人类型
     * @return 收件人1 <邮件地址1>, 收件人2 <邮件地址2>, ...
     * @throws MessagingException
     */
    public static String getReceiveAddress(MimeMessage msg, Message.RecipientType type) throws MessagingException {
        StringBuffer receiveAddress = new StringBuffer();
        Address[] addresss = null;
        if (type == null) {
            addresss = msg.getAllRecipients();
        } else {
            addresss = msg.getRecipients(type);
        }
        if (addresss == null || addresss.length < 1){
            return "";
        }
        for (Address address : addresss) {
            InternetAddress internetAddress = (InternetAddress)address;
            receiveAddress.append(internetAddress.getAddress()).append(",");
        }
        receiveAddress.deleteCharAt(receiveAddress.length()-1);	//删除最后一个逗号
        return receiveAddress.toString();
    }

    /**
     * 获得邮件发送时间
     * @param msg 邮件内容
     * @return yyyy年mm月dd日 星期X HH:mm
     * @throws MessagingException
     */
    public static String getSentDate(MimeMessage msg, String pattern) throws MessagingException {
        Date receivedDate = msg.getSentDate();
        if (receivedDate == null){
            return "";
        }
        if (pattern == null || "".equals(pattern)){
            pattern = "yyyy年MM月dd日 E HH:mm ";
        }
        return new SimpleDateFormat(pattern).format(receivedDate);
    }

    /**
     * 判断邮件中是否包含附件
     * @param part 邮件内容
     * @return 邮件中存在附件返回true，不存在返回false
     * @throws MessagingException
     * @throws IOException
     */
    public static boolean isContainAttachment(Part part) throws MessagingException, IOException {
        boolean flag = false;
        if (part.isMimeType("multipart/*")) {
            MimeMultipart multipart = (MimeMultipart) part.getContent();
            int partCount = multipart.getCount();
            for (int i = 0; i < partCount; i++) {
                BodyPart bodyPart = multipart.getBodyPart(i);
                String disp = bodyPart.getDisposition();
                if (disp != null && (disp.equalsIgnoreCase(Part.ATTACHMENT) || disp.equalsIgnoreCase(Part.INLINE))) {
                    flag = true;
                } else if (bodyPart.isMimeType("multipart/*")) {
                    flag = isContainAttachment(bodyPart);
                } else {
                    String contentType = bodyPart.getContentType();
                    if (contentType.indexOf("application") != -1) {
                        flag = true;
                    }
                    if (contentType.indexOf("name") != -1) {
                        flag = true;
                    }
                }
                if (flag) {
                    break;
                }
            }
        } else if (part.isMimeType("message/rfc822")) {
            flag = isContainAttachment((Part)part.getContent());
        }
        return flag;
    }

    /**
     * 判断邮件是否已读
     * @param msg 邮件内容
     * @return 如果邮件已读返回true,否则返回false
     * @throws MessagingException
     */
    public static boolean isSeen(MimeMessage msg) throws MessagingException {
        return msg.getFlags().contains(Flags.Flag.SEEN);
    }

    /**
     * 判断邮件是否需要阅读回执
     * @param msg 邮件内容
     * @return 需要回执返回true,否则返回false
     * @throws MessagingException
     */
    public static boolean isReplySign(MimeMessage msg) throws MessagingException {
        boolean replySign = false;
        String[] headers = msg.getHeader("Disposition-Notification-To");
        if (headers != null) {
            replySign = true;
        }
        return replySign;
    }

    /**
     * 获得邮件的优先级
     * @param msg 邮件内容
     * @return 1(High):紧急  3:普通(Normal)  5:低(Low)
     * @throws MessagingException
     */
    public static String getPriority(MimeMessage msg) throws MessagingException {
        String priority = "普通";
        String[] headers = msg.getHeader("X-Priority");
        if (headers != null) {
            String headerPriority = headers[0];
            if (headerPriority.indexOf("1") != -1 || headerPriority.indexOf("High") != -1) {
                priority = "紧急";
            } else if (headerPriority.indexOf("5") != -1 || headerPriority.indexOf("Low") != -1) {
                priority = "低";
            } else {
                priority = "普通";
            }
        }
        return priority;
    }

    /**
     * 获得邮件文本内容
     * @param part 邮件体
     * @param content 存储邮件文本内容的字符串
     * @throws MessagingException
     * @throws IOException
     */
    public static void getMailTextContent(Part part, StringBuffer content, boolean plainFlag) throws MessagingException, IOException {
        //如果是文本类型的附件，通过getContent方法可以取到文本内容，但这不是我们需要的结果，所以在这里要做判断
        boolean isContainTextAttach = part.getContentType().indexOf("name") > 0;
        if (part.isMimeType("text/html") && !isContainTextAttach && plainFlag == false) {
            content.append(part.getContent().toString());
        }else if(part.isMimeType("text/html") && !isContainTextAttach && plainFlag){
            content.append(part.getContent().toString());
            plainFlag = false;
        } else if (part.isMimeType("message/rfc822")) {
            getMailTextContent((Part)part.getContent(),content, plainFlag);
        } else if (part.isMimeType("multipart/*")) {
            Multipart multipart = (Multipart) part.getContent();
            int partCount = multipart.getCount();
            for (int i = 0; i < partCount; i++) {
                BodyPart bodyPart = multipart.getBodyPart(i);
                getMailTextContent(bodyPart,content, plainFlag);
            }
        }
    }

    /**
     * 保存附件
     * @param part 邮件中多个组合体中的其中一个组合体
     * @throws UnsupportedEncodingException
     * @throws MessagingException
     * @throws FileNotFoundException
     * @throws IOException
     */
    public List<Long> saveAttachment(Part part) throws UnsupportedEncodingException, MessagingException,
            FileNotFoundException, IOException {
        List<Long> attachIds = new ArrayList<>();
        if (part.isMimeType("multipart/*")) {
            Multipart multipart = (Multipart) part.getContent();	//复杂体邮件
            //复杂体邮件包含多个邮件体
            int partCount = multipart.getCount();
            for (int i = 0; i < partCount; i++) {
                //获得复杂体邮件中其中一个邮件体
                BodyPart bodyPart = multipart.getBodyPart(i);
                //某一个邮件体也有可能是由多个邮件体组成的复杂体
                String disp = bodyPart.getDisposition();
                if (disp != null && (disp.equalsIgnoreCase(Part.ATTACHMENT) || disp.equalsIgnoreCase(Part.INLINE))) {
                    InputStream is = bodyPart.getInputStream();
                    attachIds.add(saveFile(is, decodeText(bodyPart.getFileName())));
                } else if (bodyPart.isMimeType("multipart/*")) {
                    saveAttachment(bodyPart);
                } else {
                    String contentType = bodyPart.getContentType();
                    if (contentType.indexOf("name") != -1 || contentType.indexOf("application") != -1) {
                        attachIds.add(saveFile(bodyPart.getInputStream(), decodeText(bodyPart.getFileName())));
                    }
                }
            }
        } else if (part.isMimeType("message/rfc822")) {
            saveAttachment((Part) part.getContent());
        }
        return attachIds;
    }

    /**
     * 读取输入流中的数据保存至指定目录
     * @param is 输入流
     * @param fileName 文件名
     * @throws FileNotFoundException
     * @throws IOException
     */
    private Long saveFile(InputStream is, String fileName) {
        byte[] bytes = new byte[0];
        try {
            bytes = IOUtils.toByteArray(is);
            BytesUploadReq req = new BytesUploadReq();
            req.setBytes(bytes);
            req.setFileName(fileName);
            req.setSubCode(SystemSubcode.TASK_MAIL);
            AttachData attachData = baseFeignClient.doUploadFileBytes(req);
            return attachData.getId();
        } catch (IOException e) {
            log.error("邮件对接附件"+ fileName +"下载失败！", e);
            return -1L;
        }
    }

    /**
     * 文本解码
     * @param encodeText 解码MimeUtility.encodeText(String text)方法编码后的文本
     * @return 解码后的文本
     * @throws UnsupportedEncodingException
     */
    public static String decodeText(String encodeText) throws UnsupportedEncodingException {
        if (encodeText == null || "".equals(encodeText)) {
            return "";
        } else {
            return MimeUtility.decodeText(encodeText);
        }
    }

    /**
     * @Description:    通过SSL连接
     * @Author:         
     * @CreateDate:     2020/10/20 15:57
     * @Version:        1.0
     */
    public static void receiveSSL() throws Exception{
        // 准备连接服务器的会话信息
        Properties props = new Properties();
        props.setProperty("mail.store.protocol", "pop3");
        props.setProperty("mail.pop3.host", "pop3.airchina.com");
        props.setProperty("mail.pop3.port", "110");
//        props.setProperty("mail.store.protocol", config.getProtocol());
//        props.setProperty("mail.imap.host", config.getMailHost());
//        props.setProperty("mail.imap.port", config.getMailPort());
//        props .setProperty("mail.debug.auth", "true");
//        props .setProperty("mail.imap.ssl.enable", "true");
//        props .setProperty("mail.imap.auth.plain.disable", "true");
        // 创建Session实例对象

        Session session = Session.getInstance(props);
        // 创建POP3协议的Store对象
        Store store = session.getStore("pop3");
        // 连接邮件服务器

        store.connect("*******", "********");
        // 获得收件箱
        Folder folder = store.getFolder("INBOX");
        // 以读写模式打开收件箱
        folder.open(Folder.READ_WRITE);
        // 获得收件箱的邮件列表
        //搜索条件
//        Date timePoint = new Date();
//        Calendar calendar = Calendar.getInstance();
//        calendar.setTime(timePoint);
//        calendar.add(Calendar.DAY_OF_YEAR, -1);
//        Calendar cal = Calendar.getInstance();
//        cal.setTime(endTime);
//        cal.add(Calendar.DAY_OF_YEAR, -2);
//        startTime = cal.getTime();
//        SearchTerm geTerm = new ReceivedDateTerm(ComparisonTerm.GE, startTime);
//        /*
//            不知道什么原因，协议由之前的pop3协议改为现在imap协议之后，这个时间范围搜索不起作用
//            所以最新查取一天前之后的所有邮件，在邮件列表中再根据时间过滤
//         */
//        SearchTerm leTerm = new ReceivedDateTerm(ComparisonTerm.LT, endTime);
//        SearchTerm andTerm = new AndTerm(geTerm, leTerm);
//        log.warn("搜索邮件！");
//        Message[] messages = folder.search(andTerm);
//        // 打印不同状态的邮件数量
//        System.out.println("收件箱中共" + messages.length + "封邮件!");
//        System.out.println("收件箱中共" + folder.getUnreadMessageCount() + "封未读邮件!");
//        System.out.println("收件箱中共" + folder.getNewMessageCount() + "封新邮件!");
//        System.out.println("收件箱中共" + folder.getDeletedMessageCount() + "封已删除邮件!");
//        System.out.println("------------------------开始解析邮件----------------------------------");
//        int total = folder.getMessageCount();
//        System.out.println("-----------------您的邮箱共有邮件：" + total + " 封--------------");
//        // 得到收件箱文件夹信息，获取邮件列表
//        Message[] msgs = folder.getMessages();
//        System.out.println("\t收件箱的总邮件数：" + msgs.length);
        Message[] messages = folder.getMessages();
        // 打印不同状态的邮件数量
        System.out.println("收件箱中共" + messages.length + "封邮件!");
        System.out.println("收件箱中共" + folder.getUnreadMessageCount() + "封未读邮件!");
        System.out.println("收件箱中共" + folder.getNewMessageCount() + "封新邮件!");
        System.out.println("收件箱中共" + folder.getDeletedMessageCount() + "封已删除邮件!");
        System.out.println("------------------------开始解析邮件----------------------------------");
        folder.close(false);
        store.close();


//        //设置SSL连接、邮件环境
//        Properties props = new Properties();
//        props.setProperty("mail.store.protocol", "pop3");
//        props.setProperty("mail.imap.host", "pop3.airchina.com");
//        props.setProperty("mail.imap.port", "110");
//        props .setProperty("mail.debug.auth", "true");
//        props .setProperty("mail.imap.ssl.enable", "true");
//        props .setProperty("mail.imap.auth.plain.disable", "true");
        //建立邮件会话
//        Session session = Session.getInstance(props);
//        //设置连接邮件仓库的环境
//        Store store = session.getStore("pop3");
//        //store.connect("customer_relations@airchina.com", "Gh@200520");
//        store.connect("fwzlcs@airchina.com", "Fwzlcs999");
//
//        Folder folder = store.getFolder("INBOX");
//
//        // 以读写模式打开收件箱
//        folder.open(Folder.READ_WRITE);

        // 获得收件箱的邮件列表
//        Message[] messages = folder.getMessages();
//        // 打印不同状态的邮件数量
//        System.out.println("收件箱中共" + messages.length + "封邮件!");
//        System.out.println("收件箱中共" + folder.getUnreadMessageCount() + "封未读邮件!");
//        System.out.println("收件箱中共" + folder.getNewMessageCount() + "封新邮件!");
//        System.out.println("收件箱中共" + folder.getDeletedMessageCount() + "封已删除邮件!");
//        System.out.println("------------------------开始解析邮件----------------------------------");
//        // 解析邮件
//        for (Message message : messages) {
            IMAPMessage msg = (IMAPMessage) message;
            String subject = MimeUtility.decodeText(msg.getSubject());
//        }
//        // 关闭资源
//        folder.close(false);
//        store.close();
    }


    /**
    * @Description:    发送邮件
    * @Author:         
    * @CreateDate:     2020/12/2 13:49
    * @Version:        1.0
    */
    public void send(SendMailObject send, MailConfig config) throws Exception {
        Properties props = new Properties();
//        props.setProperty("mail.host", config.getMailHost());
//        props.setProperty("mail.transport.protocol", "smtp");
//        props.setProperty("mail.smtp.auth", "true");

        props.setProperty("mail.transport.protocol", "smtp");   // 使用的协议（JavaMail规范要求）
        props.setProperty("mail.smtp.host", config.getSendServerHost());   // 发件人的邮箱的 SMTP 服务器地址
        props.setProperty("mail.smtp.auth", "true");            // 需要请求认证

        // PS: 某些邮箱服务器要求 SMTP 连接需要使用 SSL 安全认证 (为了提高安全性, 邮箱支持SSL连接, 也可以自己开启),
        //     如果无法连接邮件服务器, 仔细查看控制台打印的 log, 如果有有类似 “连接失败, 要求 SSL 安全连接” 等错误,
        //     打开下面 /* ... */ 之间的注释代码, 开启 SSL 安全连接。
        // SMTP 服务器的端口 (非 SSL 连接的端口一般默认为 25, 可以不添加, 如果开启了 SSL 连接,
        //                  需要改为对应邮箱的 SMTP 服务器的端口, 具体可查看对应邮箱服务的帮助,
        //                  QQ邮箱的SMTP(SLL)端口为465或587, 其他邮箱自行去查看)

        props.setProperty("mail.smtp.port", config.getSendServerPort());
        props.setProperty("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
        props.setProperty("mail.smtp.socketFactory.fallback", "false");
        props.setProperty("mail.smtp.socketFactory.port", config.getSendServerPort());

        // 创建Session实例对象
        Session session = Session.getInstance(props);
        Transport transport = session.getTransport();
        //连接邮件服务器
        transport.connect(config.getUserName(), config.getPasswowrd());
        Message message = null;
        if(CollectionUtils.isEmpty(send.getAttachIds())){
            //如果附件列表为空，则发送SimpleMail
            message = createSimpleMail(session, send);
        }else{
            //如果附件列表不为空，则发送attachMail
            message = createAttachMail(session, send);
        }
        transport.sendMessage(message, message.getAllRecipients());
        transport.close();
    }

    /**
    * @Description:    构建附件邮件体
    * @Author:         
    * @CreateDate:     2020/12/2 17:40
    * @Version:        1.0
    */
    private Message createSimpleMail(Session session, SendMailObject send) throws Exception {
        //创建邮件对象
        MimeMessage message = new MimeMessage(session);
        //指明邮件的发件人
        message.setFrom(new InternetAddress(send.getSendAddress()));
        //指明邮件的收件人，现在发件人和收件人是一样的，那就是自己给自己发
        message.setRecipient(Message.RecipientType.TO, new InternetAddress(send.getReceiveAddress()));
        //邮件的标题
        message.setSubject(send.getSendTopic());
        //邮件的文本内容
        message.setContent(send.getMailContent(), "text/html;charset=UTF-8");
        //返回创建好的邮件对象
        return message;
    }

    /**
    * @Description:    创建邮件体
    * @Author:         
    * @CreateDate:     2020/12/2 16:33
    * @Version:        1.0
    */
    private Message createAttachMail(Session session, SendMailObject send) throws Exception {
        MimeMessage message = new MimeMessage(session);
        //设置邮件的基本信息
        //发件人
        message.setFrom(new InternetAddress(send.getSendAddress()));
        //收件人
        message.setRecipient(Message.RecipientType.TO, new InternetAddress(send.getReceiveAddress()));
        //邮件标题
        message.setSubject(send.getSendTopic());

        //创建容器描述数据关系
        MimeMultipart mp = new MimeMultipart();
        mp.setSubType("mixed");

        //创建邮件正文，为了避免邮件正文中文乱码问题，需要使用charset=UTF-8指明字符编码
        MimeBodyPart text = new MimeBodyPart();
        text.setContent(send.getMailContent(), "text/html;charset=UTF-8");
        mp.addBodyPart(text);
//        List<AttachDataModel> attachs = baseFeignClient.selectAttachDataById(send.getAttachIds());
//        for(AttachDataModel attachModel : attachs){
//            //创建邮件附件
//            MimeBodyPart attach = new MimeBodyPart();
//            DataHandler dh = new DataHandler(new FileDataSource(new File(attachModel.getFileUrl())));
//            attach.setDataHandler(dh);
//            attach.setFileName(dh.getName());
//            mp.addBodyPart(attach);
//        }
        message.setContent(mp);
        message.saveChanges();
        //返回生成的邮件
        return message;
    }
}

其中邮件中的附件处理起来比较麻烦，重点留意一下。