java实现收发邮件

 /**
     * description:发送邮件
     * 发送邮件
     */
    public static void sendEmail(String receiveEmail,String content) throws Exception {
        //邮件配置类
        Properties properties = new Properties();
        properties.put("mail.transport.protocol", "smtp");
        properties.put("mail.smtp.host", "smtp.qq.com");
        properties.put("mail.smtp.port", 465);
        properties.put("mail.smtp.auth", "true");
        properties.put("mail.smtp.ssl.enable", "true");
        properties.put("mail.debug", "true");
        Session session = Session.getInstance(properties);
        Message message = new MimeMessage(session);
        // 设置发件人邮箱地址
        message.setFrom(new InternetAddress("xxxxxxxx@qq.com"));
        // 设置收件人邮箱地址
        //message.setRecipients(Message.RecipientType.TO, new InternetAddress[]{new InternetAddress("2990853648@qq.com"),new InternetAddress("2990853648@qq.com"),new InternetAddress("2990853648@qq.com")});
        message.setRecipient(Message.RecipientType.TO, new InternetAddress(receiveEmail));
        message.setSubject("审批结果");
        message.setText(content);
        Transport transport = session.getTransport();
        // 连接自己的邮箱账户,password为授权码
        transport.connect("xxxxxxx@qq.com", "xxxxxxxxx");
        transport.sendMessage(message, message.getAllRecipients());
        transport.close();
    }



    //----------------------------------------------------------------------------------------------



	//使用imap协议接收邮件，imap协议和pop3协议的区别：IMAP协议可以修改邮箱服务器上的邮件状态。
	    /**
     * 接收邮件
     */
    public EmailContext receive(String protocol, String host, String username, String password) throws Exception {
        //读取收件箱
        EmailContext emailContext = readInbox(protocol,host,username,password);
        if(emailContext==null){
            return null;
        }
        //处理邮件
        List<EmailInfo> result = parseMessage(emailContext.messages);
        emailContext.setEmailInfos(result);
        return emailContext;
    }

//----------------------------------------------------------------------------------------------




    public static EmailContext readInbox(String protocol, String host, String user, String password) throws Exception{
        //邮件配置类
        Properties properties = new Properties();
        Session session = Session.getDefaultInstance(properties);
        //session.setDebug(true);
        Store store = session.getStore(protocol);
        store.connect(host,user,password);
        // 获得用户的邮件帐户
        Folder folder=store.getFolder("INBOX");
        if (folder == null) {
            System.out.println("获取邮箱文件信息为空");
        }
        EmailContext emailContext = new EmailContext();
        // 设置对邮件帐户的访问权限可以读写
        folder.open(Folder.READ_WRITE);
        SearchTerm flagTerm = new FlagTerm(new Flags(Flags.Flag.SEEN), false);//搜索未读邮件
        Message[] messages =  folder.search(flagTerm);
        if(messages==null || messages.length==0){return null; }

        for (int i = 0, count = messages.length; i < count; i++) {//将读取的邮件标位已读状态
            messages[i].setFlag(Flags.Flag.SEEN, true);
        }
        emailContext.setMessages(messages);
        emailContext.setFolder(folder);
        return emailContext;
    }



//----------------------------------------------------------------------------------------------




 /**
     * 解析邮件
     * @param messages 要解析的邮件列表
     */
    public List<EmailInfo> parseMessage(Message...messages) throws MessagingException {
        if (messages == null || messages.length < 1) {
            throw new MessagingException("未找到要解析的邮件!");
        }
        List<EmailInfo> result = new ArrayList<>();
        // 解析所有邮件
        for (int i = 0, count = messages.length; i < count; i++) {
            if(!messages[i].getFolder().isOpen())
            {
                messages[i].getFolder().open(Folder.READ_WRITE);
            }
            MimeMessage msg = (MimeMessage) messages[i];
            EmailInfo emailInfo = new EmailInfo();
            try{
                emailInfo.setSubject(msg.getSubject());
                emailInfo.setSender(getFrom(msg));
                emailInfo.setSenderName(getSenderName(msg));
                emailInfo.setSendAt(msg.getSentDate());
                emailInfo.setMessageId(msg.getMessageID());
                //邮件源文件
                emailInfo.setSourceFileKey(saveSourceEmailFile(msg));
                emailInfo.setReplyMessageId(getHeader(msg,"In-Reply-To"));
                String body = getTextFromMessage(msg);
                body = obtainEmailType(emailInfo,body);
                try{
                    emailInfo.setBody(readReplyContent(body));
                }catch (Exception e){
                    e.printStackTrace();
                }
               // emailInfo.setAttachments(readAttachments(msg));
                result.add(emailInfo);
                if(messages[i].getFolder().isOpen())
                {
                    messages[i].getFolder().close(true);
                }
            }catch (Exception e){
                System.out.println("读取文件失败");
                e.printStackTrace();
            }
        }
        return result;
    }




//----------------------------------------------------------------------------------------------




    /**
     * 提取邮件类型
     * @param emailInfo
     * @param body
     */
    private String obtainEmailType(EmailInfo emailInfo , String body){
        if(body == null){
            emailInfo.setEmailTypeEnum(EmailTypeEnum.NEW_EMAIL);
            return null;
        }
        if(body.contains("《hidden《") && body.contains("》hidden》")){
            emailInfo.setEmailTypeEnum(EmailTypeEnum.REPLY);
            String startFlag = "《hidden《";
            int start = body.lastIndexOf(startFlag);
            int end = body.lastIndexOf("》hidden》");
            String info = body.substring(start + startFlag.length() , end);
            String[] split = info.split(":");
            if(split.length != 2){
                emailInfo.setEmailTypeEnum(EmailTypeEnum.NEW_EMAIL);
            }else {
                emailInfo.setTicketId(split[0]);
                emailInfo.setTicketTableName(split[1]);
            }
        }else {
            emailInfo.setEmailTypeEnum(EmailTypeEnum.NEW_EMAIL);
        }
        return body;
    }

    private static String getTextFromMessage(Message message) throws MessagingException, IOException {
        String result = "";
        if(message.isMimeType("text/plain") || message.isMimeType("text/html")){
            result = message.getContent().toString();
        }else if(message.isMimeType("multipart/mixed")){
            result = getTextFromMimeMultipart((Multipart) message.getContent());
        }else if(message.isMimeType("multipart/alternative")){
            result = getTextFromMimeMultipart((Multipart) message.getContent());
        }
        return result;
    }

    private static String getTextFromMimeMultipart(
            Multipart mimeMultipart)  throws MessagingException, IOException{
        String result = "";
        int count = mimeMultipart.getCount();
        for (int i = 0; i < count; i++) {
            BodyPart bodyPart = mimeMultipart.getBodyPart(i);
            if (bodyPart.isMimeType("text/plain")) {
                result = result + bodyPart.getContent();
            }else if (bodyPart.isMimeType("text/html")) {
                String html = (String) bodyPart.getContent();
                result = result + html;
            } else if (bodyPart.getContent() instanceof Multipart){
                result = result + getTextFromMimeMultipart((Multipart)bodyPart.getContent());
            } else if (bodyPart.isMimeType("text/html")) {
                String html = (String) bodyPart.getContent();
                result = result + html;
            } else if (bodyPart.getContent() instanceof Multipart){
                result = result + getTextFromMimeMultipart((Multipart)bodyPart.getContent());
            }
        }
        return result;
    }

    private String saveSourceEmailFile(MimeMessage msg){
        return "source_file_key";
    }

    private String getHeader(MimeMessage mimeMessage,String header){
        String[] headers = new String[0];
        try{
            headers = mimeMessage.getHeader(header);
        } catch (MessagingException e){
            e.printStackTrace();
        }
        return headers != null && headers.length > 0 ? headers[0] : null;
    }


//----------------------------------------------------------------------------------------------



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



//----------------------------------------------------------------------------------------------


    /**
     * 获取发件人
     * @param msg
     * @return
     */
    public String getSenderName(MimeMessage msg) throws MessagingException{
        Address[] froms = msg.getFrom();
        if (froms.length < 1){
            return "";
        }
        InternetAddress address = (InternetAddress) froms[0];
        return address.getPersonal();
    }


//----------------------------------------------------------------------------------------------




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



//----------------------------------------------------------------------------------------------


    public static class EmailContext{
        private List<EmailInfo> emailInfos;
        private Message[] messages;
        private Folder folder;

        public List<EmailInfo> getEmailInfos(){
            return emailInfos;
        }

        public void setEmailInfos(List<EmailInfo> emailInfos){
            this.emailInfos = emailInfos;
        }

        public Folder getFolder(){
            return folder;
        }

        public void setFolder(Folder folder){
            this.folder = folder;
        }

        public Message[] getMessages(){
            return messages;
        }

        public void setMessages(Message[] messages){
            this.messages = messages;
        }
    }



//----------------------------------------------------------------------------------------------



    public static class EmailInfo{
        private String subject;
        private String sender;
        private String senderName;
        private Date sendAt;
        private String body;
        private String messageId;
        private String replyMessageId;
        private String sourceFileKey;
        private String ticketId;
        private String ticketTableName;
        private EmailTypeEnum emailTypeEnum;
        private List<MultipartFile> attachments;

        public String getSubject(){
            return subject;
        }

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

        public String getSender(){
            return sender;
        }

        public void setSender(String sender){
            this.sender = sender;
        }

        public String getSenderName(){
            return senderName;
        }

        public void setSenderName(String senderName){
            this.senderName = senderName;
        }

        public Date getSendAt(){
            return sendAt;
        }

        public void setSendAt(Date sendAt){
            this.sendAt = sendAt;
        }

        public String getBody(){
            return body;
        }

        public void setBody(String body){
            this.body = body;
        }

        public List<MultipartFile> getAttachments(){
            return attachments;
        }

        public void setAttachments(List<MultipartFile> attachments){
            this.attachments = attachments;
        }

        public String getMessageId(){
            return messageId;
        }

        public void setMessageId(String messageId){
            this.messageId = messageId;
        }

        public String getSourceFileKey(){
            return sourceFileKey;
        }

        public void setSourceFileKey(String sourceFileKey){
            this.sourceFileKey = sourceFileKey;
        }

        public String getReplyMessageId(){
            return replyMessageId;
        }

        public void setReplyMessageId(String replyMessageId){
            this.replyMessageId = replyMessageId;
        }

        public String getTicketId(){
            return ticketId;
        }

        public void setTicketId(String ticketId){
            this.ticketId = ticketId;
        }

        public String getTicketTableName(){
            return ticketTableName;
        }

        public void setTicketTableName(String ticketTableName){
            this.ticketTableName = ticketTableName;
        }

        public EmailTypeEnum getEmailTypeEnum(){
            return emailTypeEnum;
        }

        public void setEmailTypeEnum(EmailTypeEnum emailTypeEnum){
            this.emailTypeEnum = emailTypeEnum;
        }
    }

JavaMail在javax.mail.search包中定义了一个用于创建搜索条件的SearchTerm类，应用程序创建SearchTerm类的实例对象后，就可以调用Folder.Search(SearchTerm st)方法搜索邮件夹中符合搜索条件的所有邮件。SearchTerm是一个抽象类，JavaMail提供了22个实现子类以帮助应用程序创建不同的搜索条件，这22个类可分为两大类型，如下所示：

1、用于创建逻辑组合关系的类

AND条件（AndTerm类）
OR条件（OrTerm类）
NOT条件（NotTerm类）
Comparison条件（ComparisonTerm类）

2、用于创建具体搜索条件的类

DATE条件（SentDateTerm、ReceivedDateTerm类）
CONTENT条件（BodyTerm类）
HEADER条件（FromStringTerm、RecipientStringTerm、SubjectTerm类等）

下面通过实现来说明以上类的用法及含义：

1、搜索发件人为“智联招聘“，而且邮件正文包含“Java工程师“的所有邮件

SearchTerm andTerm = new AndTerm( new FromStringTerm(“智联招聘”), new BodyTerm(“java工程师”));

Message[] messages = folder.search(andTerm);

2、搜索发件人为“智联招聘“或主题包含“最新职位信息“的所有邮件

SearchTerm orTerm = new OrTerm( new FromStringTerm(“智联招聘”), new SubjectTerm(“最新职位信息”));

Message[] messages = folder.search(orTerm);

3、搜索周一到今天收到的的所有邮件

Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.DAY_OF_WEEK, calendar.get(Calendar.DAY_OF_WEEK - (Calendar.DAY_OF_WEEK - 1)) - 1);
Date mondayDate = calendar.getTime();
SearchTerm comparisonTermGe = new SentDateTerm(ComparisonTerm.GE, mondayDate);
SearchTerm comparisonTermLe = new SentDateTerm(ComparisonTerm.LE, new Date());
SearchTerm comparisonAndTerm = new AndTerm(comparisonTermGe, comparisonTermLe);
Message[] messages = folder.search(comparisonAndTerm);

4、搜索大于或等100KB的所有邮件

int mailSize = 1024 * 100; SearchTerm intComparisonTerm = new SizeTerm(IntegerComparisonTerm.GE, mailSize);
Message[] messages = folder.search(intComparisonTerm);

ComparisonTerm类常用于日期和数字比较中，它使用六个常量EQ（＝）、GE（>=）、GT（>）、LE（<=）、LT（<）、NE（!=）来表示六种不同的比较操作。

//如果需要在取得邮件数后将邮件置为已读则这里需要使用READ_WRITE,否则READ_ONLY就可以
inbox.open(Folder.READ_WRITE);
// Message messages[] = inbox.getMessages(); //获取所有邮件

//建立搜索条件FlagTerm，这里FlagTerm继承自SearchTerm，也就是说除了获取未读邮
//件的条件还有很多其他条件同样继承了SearchTerm的条件类，像根据发件人，主题搜索等，
// 还有复杂的逻辑搜索类似：
//     
//    SearchTerm orTerm = new OrTerm(   
//            new FromStringTerm(from),   
//            new SubjectTerm(subject)   
//            ); 
//  

FlagTerm ft = 
    new FlagTerm(new Flags(Flags.Flag.SEEN), false); //false代表未读，true代表已读

/**
* Flag 类型列举如下
* Flags.Flag.ANSWERED 邮件回复标记，标识邮件是否已回复。
* Flags.Flag.DELETED 邮件删除标记，标识邮件是否需要删除。
* Flags.Flag.DRAFT 草稿邮件标记，标识邮件是否为草稿。
* Flags.Flag.FLAGGED 表示邮件是否为回收站中的邮件。
* Flags.Flag.RECENT 新邮件标记，表示邮件是否为新邮件。
* Flags.Flag.SEEN 邮件阅读标记，标识邮件是否已被阅读。
* Flags.Flag.USER 底层系统是否支持用户自定义标记，只读。
*/

————————————————
版权声明：本文为CSDN博主「JackIT健_686」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_37758648/article/details/85246290