基于Quartz实现简单的定时发送邮件

一、什么是Quartz

Quartz 是一个轻量级任务调度框架，只需要做些简单的配置就可以使用；它可以支持持久化的任务存储，即使是任务中断或服务重启后，仍可以继续运行。Quartz既可以做为独立的应用提供服务，也可以和其他应用集成一起使用。

核心概念：

1、Job

表示一个工作，要执行的具体内容。此接口中只有一个方法

void execute(JobExecutionContext context) 

2、JobDetail

JobDetail表示一个具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容，另外JobDetail还包含了这个任务调度的方案和策略。 

3、Trigger代表一个调度参数的配置，什么时候去调。 

4、Scheduler代表一个调度容器，一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合，就可以被Scheduler容器调度了。

Quartz的类关系图：

注意：Quartz的版本与Spring 的版本有关， Spring 2.x的版本最好用Quartz 1.8.5的，若是 Spring 3.0以上的Quartz 的版本最好用 2.0以上的。

二、基于Sping+Quartz实现简单的JAVA邮件发送

1.创建一个Java(Web)工程

2.实现SimpleMail、MailJob、EmailScheduler类

SimpleMail：

 package com.quartz.mail;

 import org.apache.commons.mail.EmailException;
 import org.apache.commons.mail.SimpleEmail;

 import javax.mail.internet.AddressException;
 import javax.mail.internet.InternetAddress;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;

 /**
  * Created by xiwu.xxw on 2015/8/8.
  */
  public class SimpleMail {
     private SimpleEmail mail;

     /**
      * 初始化一封邮件，暂不支持富媒体和附件
      * @param receivers 邮件的接收者
      * @param subject 邮件主题
      * @param content 邮件内容
      * @throws EmailException
      * @throws AddressException
      */
     public  SimpleMail(List<String> receivers,String subject,String content) throws EmailException, AddressException {
         mail=new SimpleEmail();
         mail.setCharset("UTF-8");
         List<InternetAddress> toList=new ArrayList<InternetAddress>();
         for(String receiver: receivers){
          toList.add(new InternetAddress(receiver));
         }
         mail.setTo(toList);
         mail.setSubject(subject);
         mail.setContent(content, "text/html;charset=utf-8");
     }

     /**
      * 发送邮件
      * @param from 发送方邮件地址
      * @param password 发送授权码
      * @return
      * @throws EmailException
      */
     public  String sendEmail(String from,String password) throws EmailException {
         mail.setFrom(from);
         //发送方邮箱权限认证，发送方邮箱须开通SMTP/POP/IMAP功能
         mail.setAuthentication(from, password);
         mail.setHostName("smtp." + from.split("@")[1]);
         mail.setSentDate(new Date());
         return mail.send();
     }
 }

MailJob：

 package com.quartz.job;

 import com.quartz.mail.SimpleMail;
 import org.quartz.JobDataMap;
 import org.quartz.JobExecutionContext;
 import org.quartz.JobExecutionException;
 import org.springframework.scheduling.quartz.QuartzJobBean;

 import java.util.List;

 /**
  * Created by xiwu.xxw on 2015/8/8.
  */
 public class MailJob extends QuartzJobBean {
     /**
      * 执行Job任务
      * @param context
      * @throws JobExecutionException
      */
     @Override
     protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
         JobDataMap map=context.getJobDetail().getJobDataMap();
         try {
             SimpleMail mail=new SimpleMail((List<String>) map.get("receivers"),map.getString("subject"),map.getString("content"));
             String result=mail.sendEmail(map.getString("from"), map.getString("password"));
             System.out.println(result);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

EmailScheduler：

 package com.quartz.scheduler;

 import org.quartz.SchedulerException;
 import org.quartz.impl.StdScheduler;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 import org.springframework.scheduling.quartz.CronTriggerBean;
 import org.springframework.scheduling.quartz.JobDetailBean;
 import org.springframework.scheduling.quartz.SimpleTriggerBean;

 import java.util.ArrayList;
 import java.util.List;

 /**
  * Created by xiwu.xxw on 2015/8/8.
  */
 public class EMailScheduler {
         public static void main(String[] args) throws SchedulerException {
             //收件人
             List<String> receivers=new ArrayList<String>();
             receivers.add("xxxxx@qq.com");
             receivers.add("xxxxx@126.com");
             receivers.add("xxxxx@163.com");

             ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
             //邮件JobBean
             JobDetailBean mailJob= (JobDetailBean) context.getBean("mailJob");
             mailJob.setName("mailJob");
             mailJob.setGroup("textEmail");
             // 指明任务就算没有绑定Trigger仍保留在Quartz的JobStore中
             //mailJob.setDurability(true);
             mailJob.getJobDataMap().put("receivers",receivers);
             mailJob.getJobDataMap().put("subject","基于Quartz实现邮件发送");
             mailJob.getJobDataMap().put("content","本程序基于Quartz实现了定时群发邮件的功能，目前只支持文本发送!");

             //发送邮件任务的SimpleTrigger触发器
             SimpleTriggerBean simpleTrigger= (SimpleTriggerBean) context.getBean("SimpleTrigger");

             //发送邮件任务调度器
             StdScheduler scheduler= (StdScheduler) context.getBean("startQuartzTask");
             //加入一个任务到Quartz框架中, 并与simpleTrigger关联
             //Quartz会自动校正与设置simpleTrigger的JobName与JobGroup属性
             scheduler.scheduleJob(mailJob,simpleTrigger);

             //发送邮件任务的CronTrigger触发器
             CronTriggerBean croTrigger= (CronTriggerBean) context.getBean("CronTrigger");
             //将发送邮件任务的触发器与邮件任务关联并注册到调度器
             croTrigger.setJobName("mailJob");
             croTrigger.setJobGroup("textEmail");
             //因为任务已在上一条语句中已加入, 所以不能再使用scheduleJob(JobDetail, Trigger)
             scheduler.scheduleJob(croTrigger);

             try {
                 //开始调度
                 scheduler.start();
             } catch (SchedulerException e) {
                 e.printStackTrace();
             }
         }
 }

3.配置applicationContext.xml

 <?xml version="1.0" ?>
 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="
            http://www.springframework.org/schema/aop     http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
            http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/tx      http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        ">

     <bean id="dataEditor" class="org.springframework.beans.propertyeditors.CustomDateEditor">
         <constructor-arg>
             <bean class="java.text.SimpleDateFormat">
                 <constructor-arg value="yyyy-MM-dd H:m:s"/>
             </bean>
         </constructor-arg>
         <constructor-arg value="true"/>
     </bean>

     <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
         <property name="customEditors">
             <map>
                 <entry key="java.util.Date">
                     <ref local="dataEditor"/>
                 </entry>
             </map>
         </property>
     </bean>

     <bean id="mailJob" class="org.springframework.scheduling.quartz.JobDetailBean">
         <property name="jobClass">
             <value>com.quartz.job.MailJob</value>
         </property>
         <property name="jobDataAsMap">
             <map>
                 <entry key="from">
                     <value>xxxxxxx@126.com</value>
                 </entry>
                 <entry key="password">
                     <value>uebbqvlizrywzhei</value>
                 </entry>
             </map>
         </property>
     </bean>

     <bean id="SimpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
         <property name="startDelay">
             <value>5000</value>
         </property>
         <property name="repeatInterval">
             <value>120000</value>
         </property>
         <property name="repeatCount">
             <value>3</value>
         </property>
     </bean>

     <bean id="CronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
         <property name="cronExpression">
             <value>0 25/2 17 8 8 ? 2015</value>
         </property>
         <property name="endTime" value="2015-08-08 17:30:00"/>
     </bean>

     <bean id="startQuartzTask" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" />
 </beans>

4.效果如下

三、注意事项

（1）Job被创建后，可以保存在Scheduler中，与Trigger是独立的，同一个Job可以有多个Trigger；这种松耦合的另一个好处是，当与Scheduler中的Job关联的trigger都过期时，可以配置Job稍后被重新调度，而不用重新定义Job；还有，可以修改或者替换Trigger，而不用重新定义与之关联的Job。

（2）将Job和Trigger注册到Scheduler时，可以为它们设置key，配置其身份属性。Job和Trigger的key（JobKey和TriggerKey）可以用于将Job和Trigger放到不同的分组（group）里，然后基于分组进行操作。同一个分组下的Job或Trigger的名称必须唯一，即一个Job或Trigger的key由名称（name）和分组（group）组成。

（3）在Quartz中，如果实现org.quartz.Job接口，那么这个job是stateless的，job实例的参数不能在多个任务之间共享，做并发，如果实现org.quartz.StatefulJob，这个job是个单例的，job实例的属性可以从当前任务传递到下一个任务，做串行。