spring boot定时任务接收邮件并且存储附件的方法讲解

public class timertaskserviceimpl implements timertaskservice {

   @autowired

   private parsetxtserviceimpl parsetxtservice;

   /**

    * 接收邮件

    */

   @override

   @scheduled (cron= "0 10 8 * * ?" )

   public void timertaskinfo(){

     //邮件配置信息

     string host=constants.mail_host;

     string username=constants.mail_user_name;

     string password=constants.mail_pass_word;

     //邮件配置类

     properties properties= new properties();

     //邮件配置缓存

     session session=session.getdefaultinstance(properties);

     session.setdebug( true );

     string filename= null ;

     try {

       //邮件服务器的类型

       store store = session.getstore( "pop3" );

       //连接邮箱服务器

       store.connect(host,username,password);

       // 获得用户的邮件帐户

       folder folder=store.getfolder( "inbox" );

       if (folder == null ) {

         logger.info( "获取邮箱文件信息为空" );

       }

       // 设置对邮件帐户的访问权限可以读写

       folder.open(folder.read_write);

       calendar calendar=calendar.getinstance();

       calendar.add(calendar.date,- 1 );

       date mondaydate = calendar.gettime();

       searchterm comparisontermle = new sentdateterm(comparisonterm.gt, mondaydate);

       searchterm address= new subjectterm( "mu report" );

       searchterm comparisonandterm = new andterm(address, comparisontermle);

       message[] messages = folder.search(comparisonandterm);

       for ( int i = 0 ; i < messages.length ; i++){

         mimemessage msg = (mimemessage) messages[i];

         //判断是否有附件

         boolean iscontainerattachment = iscontainattachment(msg);

         if (iscontainerattachment) {

           //保存附件

           filename=saveattachment(msg,constants.storage_file);

           //保存接收到的邮件并且收件箱删除邮件

          msg.setflag(flags.flag.deleted, true );

         }

         if (!iscontainerattachment) {

           continue ;

         }

       }

       folder.close( true );

       store.close();

       parsetxtservice.readtxt(filename);

     } catch (nosuchproviderexception e){

       loggererror.error( "接收邮箱信息异常:{}" ,e);

     } catch (messagingexception e){

       loggererror.error( "连接邮箱服务器信息异常:{}" ,e);

     } catch (ioexception e){

       loggererror.error( "接收邮箱信息解析异常:{}" ,e);

     } catch (illegalstateexception e){

       loggererror.error( "接收邮箱信息为空:{}" ,e);

     }

   }

   /**

    * 判断邮件中是否包含附件

    * @return 邮件中存在附件返回true，不存在返回false

    * @throws messagingexception

    * @throws ioexception

    */

   public static boolean iscontainattachment(part part) throws messagingexception, ioexception {

     boolean flag = false ;

     if (part.ismimetype(constants.multi_part)) {

       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(constants.multi_part)) {

           flag = iscontainattachment(bodypart);

         } else {

           string contenttype = bodypart.getcontenttype();

           if (contenttype.indexof(constants.application_context) != - 1 ) {

             flag = true ;

           }

           if (contenttype.indexof(constants.name_context) != - 1 ) {

             flag = true ;

           }

         }

         if (flag){

           break ;

         }

       }

     } else if (part.ismimetype(constants.message_rfc)) {

       flag = iscontainattachment((part)part.getcontent());

     }

     return flag;

   }

   /**

    * 保存附件

    * @param part 邮件中多个组合体中的其中一个组合体

    * @param destdir 附件保存目录

    * @throws unsupportedencodingexception

    * @throws messagingexception

    * @throws filenotfoundexception

    * @throws ioexception

    */

   public string saveattachment(part part, string destdir) throws unsupportedencodingexception,

       messagingexception, filenotfoundexception, ioexception {

     string filename= null ;

     if (part.ismimetype(constants.multi_part)) {

       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();

           savefile(is, destdir, decodetext(bodypart.getfilename()));

           filename=decodetext(bodypart.getfilename());

         } else if (bodypart.ismimetype(constants.multi_part)) {

           saveattachment(bodypart,destdir);

         } else {

           string contenttype = bodypart.getcontenttype();

           if (contenttype.indexof(constants.name_context) != - 1 || contenttype.indexof

               (constants.application_context) != - 1 ) {

             savefile(bodypart.getinputstream(), destdir, decodetext(bodypart.getfilename()));

             filename=decodetext(bodypart.getfilename());

           }

         }

       }

     } else if (part.ismimetype(constants.message_rfc)) {

       saveattachment((part) part.getcontent(),destdir);

     }

     return filename;

   }

   /**

    * 读取输入流中的数据保存至指定目录

    * @param is 输入流

    * @param filename 文件名

    * @param destdir 文件存储目录

    * @throws filenotfoundexception

    * @throws ioexception

    */

   private void savefile(inputstream is, string destdir, string filename)

       throws filenotfoundexception, ioexception {

     bufferedinputstream bis = new bufferedinputstream(is);

     if (filename.contains(constants.txt_sufixx)) {

       bufferedoutputstream bos = new bufferedoutputstream(

           new fileoutputstream( new file(destdir + filename)));

       int len = - 1 ;

       while ((len = bis.read()) != - 1 ) {

         bos.write(len);

         bos.flush();

       }

       bos.close();

       bis.close();

     }

   }

}