【实战】使用Java结合Sendmail邮件服务器+Quartz开源框架定时发邮件

【实战】废话不多说，直接教你如何搭建以及使用，具体细节需要你自己细细品味。

环境：Centos7,window10 64bit

第一步: 搭建Sendmail邮件服务器。【不能在本地linux搭建，因为必须有外网，可以在阿里云上面搭建】

1、安装sendmail（centos6.3下默认yum源，默认sendmail系统自带）

yum install sendmail* -y

问题1：会遇到发邮件和启动很慢或者My unqualified host name (iZ23ole851hZ) unknown; sleeping for retry

解决办法：vim /etc/hosts

11.11.11.11 localhost.localdomain localhost  yourhost

127.0.0.1  localhost.localdomain localhost

systemctl enable sendmail.

servicesystemctl start sendmail

systemctl restart sendmail

systemctl   status sendmail

测试发送一封邮件到自己的邮箱:

mail abc@qq.com

Subject: qweqwe   ---》回车

asdasd  ----》Ctrl+D

EOT

到邮箱看看是否收到该邮件，收到则配置成功

2.修改sendmail配置文件

1.修改/etc/mail/sendmail.mc

删掉dnl注释

TRUST_AUTH_MECH(`EXTERNAL DIGEST-MD5 CRAM-MD5 LOGIN PLAIN')dnl

define(`confAUTH_MECHANISMS', `EXTERNAL GSSAPI DIGEST-MD5 CRAM-MD5 LOGIN PLAIN')dnl

修改Addr 为0.0.0.0

DAEMON_OPTIONS(`Port=smtp,Addr=0.0.0.0, Name=MTA')dnl

2.然后M4,生成配置文件
 m4 sendmail.mc > sendmail.cf

3.同时修改/etc/mail/access,开通访问权限  【这里一定要修改否则连不上sendmail service】
Connect:localhost.localdomain           RELAY
Connect:localhost                       RELAY
Connect:127.0.0.1                       RELAY
Connect:xx.xx.xxx.x                     RELAY     工作场所的网络外网IP
Connect:server ip                         RELAY     你自己的linux 外网ip

###windows 10 64bit

第二步：使用eclipse搭建Quartz开源定时任务调度框架以及测试sendmail邮件发送功能。

1.新建Java project,把如下代码放入到src下面。  假设package是com.mailtest; 也可以自己新建package。

构建需要的jar包：

项目->buid path->mail.1.7.4.jar

会用log4j的朋友，也可以使用它排错。

代码一：

import javax.mail.*;

public class MailAuthenticator extends Authenticator
{
    //******************************
    //由于发送邮件的地方比较多,
    //下面统一定义用户名,口令.
    //******************************
    public static String HUAWEI_MAIL_USER = "user";  ///这里是linux server的ssh的用户名
    public static String HUAWEI_MAIL_PASSWORD = "xxxxx";  ///这里是linux server的ssh的密码
    public MailAuthenticator()
    {
    }
    protected PasswordAuthentication getPasswordAuthentication()
    {
        return new PasswordAuthentication(HUAWEI_MAIL_USER, HUAWEI_MAIL_PASSWORD);
    }
}

代码二：

import javax.mail.*;
import java.util.*;
import java.io.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendMail {
    //要发送Mail地址
    private String mailTo = null;
    //Mail发送的起始地址
    private String mailFrom = null;
    //SMTP主机地址
    private String smtpHost = null;
    //是否采用调试方式
    private boolean debug = false;
    private String messageBasePath = null;
    //Mail主题
    private String subject;
    //Mail内容
    private String msgContent;
    private Vector attachedFileList;
    private String mailAccount = null;
    private String mailPass = null;
    private String messageContentMimeType ="text/html; charset=gb2312";
    private String mailbccTo = null;
    private String mailccTo = null;
    /**
     * SendMailService 构造子注解。
     */
    public SendMail() {
        super();
    }
    private void fillMail(Session session,MimeMessage msg) throws IOException, MessagingException{
        String fileName = null;
        Multipart mPart = new MimeMultipart();
        if (mailFrom != null) {
            msg.setFrom(new InternetAddress(mailFrom));
            System.out.println("发送人Mail地址："+mailFrom);
        } else {
            System.out.println("没有指定发送人邮件地址！");
            return;
        }
        if (mailTo != null) {
            InternetAddress[] address = InternetAddress.parse(mailTo);
            msg.setRecipients(Message.RecipientType.TO, address);
            System.out.println("收件人Mail地址："+mailTo);
        } else {
            System.out.println("没有指定收件人邮件地址！");
            return;
        }
        if (mailccTo != null) {
            InternetAddress[] ccaddress = InternetAddress.parse(mailccTo);
            System.out.println("CCMail地址："+mailccTo);
            msg.setRecipients(Message.RecipientType.CC, ccaddress);
        }
        if (mailbccTo != null) {
            InternetAddress[] bccaddress = InternetAddress.parse(mailbccTo);
            System.out.println("BCCMail地址："+mailbccTo);
            msg.setRecipients(Message.RecipientType.BCC, bccaddress);
        }
        msg.setSubject(subject);
        InternetAddress[] replyAddress = { new InternetAddress(mailFrom)};
        msg.setReplyTo(replyAddress);
        // create and fill the first message part
        MimeBodyPart mBodyContent = new MimeBodyPart();
        if (msgContent != null)
            mBodyContent.setContent(msgContent, messageContentMimeType);
        else
            mBodyContent.setContent("", messageContentMimeType);
        mPart.addBodyPart(mBodyContent);
        // attach the file to the message
        if (attachedFileList != null) {
            for (Enumeration fileList = attachedFileList.elements(); fileList.hasMoreElements();) {
    fileName = (String) fileList.nextElement();
    MimeBodyPart mBodyPart = new MimeBodyPart();
    // attach the file to the message
    FileDataSource fds = new FileDataSource(messageBasePath + fileName);
    System.out.println("Mail发送的附件为："+messageBasePath + fileName);
    mBodyPart.setDataHandler(new DataHandler(fds));
    mBodyPart.setFileName(fileName);
    mPart.addBodyPart(mBodyPart);
            }
        }
        msg.setContent(mPart);
        msg.setSentDate(new Date());
    }
    /**
     * 此处插入方法说明。
     */
    public void init()
    {
    }
    /**
     * 发送e_mail，返回类型为int
     * 当返回值为0时，说明邮件发送成功
     * 当返回值为3时，说明邮件发送失败
     */
    public int sendMail() throws IOException, MessagingException {
        int loopCount;
        Properties props = System.getProperties();
        props.put("mail.smtp.host", smtpHost);
        props.put("mail.smtp.auth", "true");
        MailAuthenticator auth = new MailAuthenticator();
        Session session = Session.getInstance(props, auth);
        session.setDebug(debug);
        MimeMessage msg = new MimeMessage(session);
        Transport trans = null;
        try {
            fillMail(session,msg);
            // send the message
            trans = session.getTransport("smtp");
            try {
    trans.connect(smtpHost, MailAuthenticator.HUAWEI_MAIL_USER, MailAuthenticator.HUAWEI_MAIL_PASSWORD);//, HUAWEI_MAIL_PASSWORD);
            } catch (AuthenticationFailedException e) {
    e.printStackTrace();
    System.out.println("连接邮件服务器错误：");
                return 3;
            } catch (MessagingException e) {
    System.out.println("连接邮件服务器错误：");
    return 3;
            }
            trans.send(msg);
            trans.close();
        } catch (MessagingException mex) {
            System.out.println("发送邮件失败：");
            mex.printStackTrace();
            Exception ex = null;
            if ((ex = mex.getNextException()) != null) {
    System.out.println(ex.toString());
    ex.printStackTrace();
            }
            return 3;
        } finally {
            try {
    if (trans != null && trans.isConnected())
    trans.close();
            } catch (Exception e) {
                System.out.println(e.toString());
            }
        }
        System.out.println("发送邮件成功！");
        return 0;
    }
    public void setAttachedFileList(java.util.Vector filelist)
    {
        attachedFileList = filelist;
    }
    public void setDebug(boolean debugFlag)
    {
        debug=debugFlag;
    }
    public void setMailAccount(String strAccount) {
        mailAccount = strAccount;
    }
    public void setMailbccTo(String bccto) {
        mailbccTo = bccto;
    }
    public void setMailccTo(String ccto) {
        mailccTo = ccto;
    }
    public void setMailFrom(String from)
    {
        mailFrom=from;
    }
    public void setMailPass(String strMailPass) {
        mailPass = strMailPass;
    }
    public void setMailTo(String to)
    {
        mailTo=to;
    }
    public void setMessageBasePath(String basePath)
    {
        messageBasePath=basePath;
    }
    public void setMessageContentMimeType(String mimeType)
    {
        messageContentMimeType = mimeType;
    }
    public void setMsgContent(String content)
    {
        msgContent=content;
    }
    public void setSMTPHost(String host)
    {
        smtpHost=host;
    }
    public void setSubject(String sub)
    {
        subject=sub;
    }
}

可以测试一下java是否能连上sendmail。

   public static void main(String[] argv) throws Exception
    {
        //for(int i = 0;i<10;i++) {
        SendMail sm = new SendMail();       
          sm.setSMTPHost("114.55.106.84");
        sm.setMailFrom("abc@qq.com");          //使用自己的邮箱
        sm.setMailTo("erf@qq.com");               //别人的邮箱
        sm.setMsgContent("hello");
        sm.setSubject("say hi~~");
        sm.sendMail();
        //}
    }

经过测试，邮件发送成功~   【如果实践到这里的童鞋不太会的或者遇到问题的可以留言，涉及的细节有点多，难免遗漏】

代码三：

搭建Quartz 任务调度。

项目->build path->quartz-1.8.1.jar,slf4j-api-1.7.7.jar,log4j-api-2.2.jar,jackson-mapper-asl-1.9.13.jar

假设自己的package 是com.quartz.test。

构建Job类QuartzJob.java

package com.quartz.test;

import java.io.IOException;
import java.text.SimpleDateFormat; 
import java.util.Date; 

import javax.mail.MessagingException;

import org.quartz.Job; 
import org.quartz.JobExecutionContext; 
import org.quartz.JobExecutionException; 

import com.mailtest.*;

/**
 * @Description: 任务执行类
 *
 * @ClassName: QuartzJob
 * @Copyright: Copyright (c) 2014
 *
  *@Copyright: Copyright (c) 2017
     * 
     * @author qq1960105914 
     * @date 2017
     * @version V2.0
 */ 
public class QuartzJob implements Job { 
 
    //@Override 
    public void execute(JobExecutionContext arg0) throws JobExecutionException { 
     SendMail sm = new SendMail();
        sm.setSMTPHost("xxxx");
        sm.setMailFrom("abc@qq.com");
        sm.setMailTo("erf@qq.com");
        sm.setMsgContent("hello");
        sm.setSubject("say hi~~");
        try {
   sm.sendMail();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (MessagingException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"邮件发送成功");   
    } 
}

构建scheduler  QuartzManager.java.   // 对任务进行增删改查.

package com.quartz.test;
import org.quartz.CronTrigger; 
import org.quartz.JobDetail; 
import org.quartz.Scheduler; 
import org.quartz.SchedulerFactory; 
import org.quartz.impl.StdSchedulerFactory;

public class QuartzManager {

    private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory(); 
    private static String JOB_GROUP_NAME = "EXTJWEB_JOBGROUP_NAME"; 
    private static String TRIGGER_GROUP_NAME = "EXTJWEB_TRIGGERGROUP_NAME";
   
    /**
     * @Description: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
     * 
     * @param jobName
     *            任务名
     * @param cls
     *            任务
     * @param time
     *            时间设置，参考quartz说明文档
     * 
     * @Title: QuartzManager.java
     * @Copyright: Copyright (c) 2014
     * 
     *@Copyright: Copyright (c) 2017
     * 
     * @author qq1960105914 
     * @date 2017
     * @version V2.0
     */
   
   // @SuppressWarnings("unchecked") 
    public static void addJob(String jobName, Class cls, String time) { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, cls);// 任务名，任务组，任务执行类 
            // 触发器 
            CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组 
            trigger.setCronExpression(time);// 触发器时间设定 
            sched.scheduleJob(jobDetail, trigger); 
            // 启动 
            if (!sched.isShutdown()) { 
                sched.start(); 
            } 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    }
   
    /**
     * @Description: 添加一个定时任务
     * 
     * @param jobName
     *            任务名
     * @param jobGroupName
     *            任务组名
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     * @param jobClass
     *            任务
     * @param time
     *            时间设置，参考quartz说明文档
     * 
     * @Title: QuartzManager.java
     * @Copyright: Copyright (c) 2014
     * 
     *@Copyright: Copyright (c) 2017
     * 
     * @author qq1960105914 
     * @date 2017
     * @version V2.0
     */
   
    //@SuppressWarnings("unchecked") 
    public static void addJob(String jobName, String jobGroupName, 
            String triggerName, String triggerGroupName, Class jobClass, 
            String time) { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            JobDetail jobDetail = new JobDetail(jobName, jobGroupName, jobClass);// 任务名，任务组，任务执行类 
            // 触发器 
            CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);// 触发器名,触发器组 
            trigger.setCronExpression(time);// 触发器时间设定 
            sched.scheduleJob(jobDetail, trigger); 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
     * 
     * @param jobName
     * @param time
     * 
     * @Title: QuartzManager.java
      *@Copyright: Copyright (c) 2017
     * 
     * @author qq1960105914 
     * @date 2017
     * @version V2.0
     */ 
    //@SuppressWarnings("unchecked") 
    public static void modifyJobTime(String jobName, String time) { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName,TRIGGER_GROUP_NAME); 
            if (trigger == null) { 
                return; 
            } 
            String oldTime = trigger.getCronExpression(); 
            if (!oldTime.equalsIgnoreCase(time)) { 
                JobDetail jobDetail = sched.getJobDetail(jobName,JOB_GROUP_NAME); 
                Class objJobClass = jobDetail.getJobClass(); 
                removeJob(jobName); 
                addJob(jobName, objJobClass, time); 
            } 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description: 修改一个任务的触发时间
     * 
     * @param triggerName
     * @param triggerGroupName
     * @param time
     * 
     * @Title: QuartzManager.java
      *@Copyright: Copyright (c) 2017
     * 
     * @author qq1960105914 
     * @date 2017
     * @version V2.0
     */ 
    public static void modifyJobTime(String triggerName, 
            String triggerGroupName, String time) { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName,triggerGroupName); 
            if (trigger == null) { 
                return; 
            } 
            String oldTime = trigger.getCronExpression(); 
            if (!oldTime.equalsIgnoreCase(time)) { 
                CronTrigger ct = (CronTrigger) trigger; 
                // 修改时间 
                ct.setCronExpression(time); 
                // 重启触发器 
                sched.resumeTrigger(triggerName, triggerGroupName); 
            } 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description: 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
     * 
     * @param jobName
     * 
     * @Title: QuartzManager.java *

      *@Copyright: Copyright (c) 2017
     * 
     * @author qq1960105914 
     * @date 2017
     * @version V2.0
     */ 
    public static void removeJob(String jobName) { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器 
            sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器 
            sched.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description: 移除一个任务
     * 
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     * 
     * @Title: QuartzManager.java
     * @Copyright: Copyright (c) 2017 
     * 
     * @author qq1960105914
     * @date 2017 
     * @version V2.0
     */ 
    public static void removeJob(String jobName, String jobGroupName, 
            String triggerName, String triggerGroupName) { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            sched.pauseTrigger(triggerName, triggerGroupName);// 停止触发器 
            sched.unscheduleJob(triggerName, triggerGroupName);// 移除触发器 
            sched.deleteJob(jobName, jobGroupName);// 删除任务 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description:启动所有定时任务
     * 
     * 
     * @Title: QuartzManager.java
     * @Copyright: Copyright (c) 2017
     * 
     * @author qq1960105914 
     * @date 2017
     * @version V2.0
     */ 
    public static void startJobs() { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            sched.start(); 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description:关闭所有定时任务
     * 
     * 
     * @Title: QuartzManager.java
     * @Copyright: Copyright (c) 2014
     * 
     * @author Comsys-LZP
     * @date 2014-6-26 下午03:50:26
     * @version V2.0
     */ 
    public static void shutdownJobs() { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            if (!sched.isShutdown()) { 
                sched.shutdown(); 
            } 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    }
   
 
}

构建main 类。

package com.quartz.test;

import com.quartz.test.QuartzJob; 
import com.quartz.test.QuartzManager; 
 
/**
 * @Description: 测试类
 *
 * @ClassName: QuartzTest
 * @Copyright: Copyright (c) 2017
 *
 * @author QQ1960105914
 * @date 20170215
 * @version  
 */ 
public class QuartzTest { 
    public static void main(String[] args) { 
        try { 
            String job_name = "动态任务调度"; 
            System.out.println("【系统启动】开始(每1秒输出一次)...");   
            QuartzManager.addJob(job_name, QuartzJob.class, "0/1 * * * * ?");   
             
            Thread.sleep(5000);   
            System.out.println("【修改时间】开始(每2秒输出一次)...");   
            QuartzManager.modifyJobTime(job_name, "10/2 * * * * ?");   
            Thread.sleep(6000);   
            System.out.println("【移除定时】开始...");   
            QuartzManager.removeJob(job_name);   
            System.out.println("【移除定时】成功");   
             
            System.out.println("【再次添加定时任务】开始(每10秒输出一次)...");   
            QuartzManager.addJob(job_name, QuartzJob.class, "*/10 * * * * ?");   
            Thread.sleep(60000);   
            System.out.println("【移除定时】开始...");   
            QuartzManager.removeJob(job_name);   
            System.out.println("【移除定时】成功"); 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
    } 
} 

以上测试过后收到邮件说明成功。

本实践本人亲测可以使用，同时网络也有借鉴。

参考文章部分内容：http://blog.csdn.net/pengpegv5yaya/article/details/37595889/