Springboot 用quartz定时发送邮件

—————项目目录结构——————

———————项目配置————————

1、 添加pom依赖

   <!-- mail start -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>

2、application.yml配置文件

spring:
  #  定时发送邮件
  mail:
    #发送方qq邮箱需要的授权码，下文3中讲述
    password: **********
    default-encoding: UTF-8
    #qq邮箱用的
    host: smtp.qq.com
    properties:
      mail:
        smtp:
          starttls:
            enable: true
            required: true
          auth: true
    #发送放邮箱
    username: *****@qq.com

3、qq邮箱授权码

3.1 登录qq邮箱后进去主页，点击设置

3.2 找到邮箱设置，点击账户

3.3 找到POP3/SMTP服务 点击开启，发送短信就可以获得授权码

4、 在conf包下新增JobFactory.class

package com.hiQiBlog.conf;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

/**
 * @author ${ww}
 * @Title: JobFactory
 * @Description: TODO
 */
@Component
public class JobFactory extends AdaptableJobFactory {
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;
    //生成一个job实例
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        //调用父类的方法
        Object jobInstance = super.createJobInstance(bundle);
        //进行注入
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

5、在config包中新增QuartzConfiguration.class

package com.hiQiBlog.config;



import com.hiQiBlog.conf.JobFactory;
import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
@Configuration
public class QuartzConfiguration {



    /**
     * @author ${ww}
     * @Title: QuartzConfigration
     * @Description: TODO
     */
    @Configuration
    @EnableScheduling
    public class QuartzConfigration {

        @Autowired
        private JobFactory jobFactory;

        @Bean
        public SchedulerFactoryBean schedulerFactoryBean() {
            SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
            schedulerFactoryBean.setOverwriteExistingJobs(true);
            schedulerFactoryBean.setJobFactory(jobFactory);
            return schedulerFactoryBean;
        }


        // 创建schedule
        @Bean(name = "scheduler")
        public Scheduler scheduler() {
            return schedulerFactoryBean().getScheduler();
        }

    }
}

6、新建SendEmailJob.class

package com.hiQiBlog.job;

import com.hiQiBlog.service.SendEmailSevice;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;

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

/**
 * @author ${ww}
 * @Title: HelloJob
 * @Description: TODO
 */
public class SendEmailJob implements  Job {
    @Autowired
    private SendEmailSevice emailService;
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("现在的时间是：" + sf.format(date));
        //具体的业务逻辑
        System.out.println("开始任务");
        //发送邮件的方法
        emailService.sendEmail();
    }
}

7、新建接口层ISendEmailSevice和实现类SendEmailSeviceImpl

package com.hiQiBlog.service;

import com.hiQiBlog.entity.User;

import java.util.List;

public interface ISendEmailSevice {
   //简单邮件
   public boolean sendEmail();
   //发送带附件的复杂的邮件
   public boolean  sendAttachmentMail();
}

package com.hiQiBlog.service.impl;


import com.hiQiBlog.service.ISendEmailSevice;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.FileSystemResource;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;


@Service
public class SendEmailSeviceImpl implements ISendEmailSevice {
    @Value("${spring.mail.username}")
    private String fromEmail;

    //注入spring发送邮件的对象
    @Autowired
    private JavaMailSender javaMailSender;

    @Override
    public boolean sendEmail() {
        SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
        //目标邮箱
        simpleMailMessage.setTo("*******@qq.com");
        simpleMailMessage.setFrom(fromEmail);
        //主题
        simpleMailMessage.setSubject("测试");
        simpleMailMessage.setText("utf-8");
        try {
            javaMailSender.send(simpleMailMessage);        //执行发送
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean sendAttachmentMail() {
        MimeMessage mimeMessage = javaMailSender.createMimeMessage();
        try {
            MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
            helper.setTo("[email protected]");
            helper.setSubject("测试");
            helper.setText("utf-8");
            helper.setFrom(fromEmail);
//            if(filepath.size()>0){						//读取附件文件（传入文件路径）
//                for (Object string : filepath) {		//遍历文件数组，实现多个附件的添加
//                    FileSystemResource file = new FileSystemResource(string.toString());
//                    String fileName = file.getFilename();//获取文件名
//                    helper.addAttachment(fileName, file);//参数：文件名，文件路径
//                }
//                try {
//                    javaMailSender.send(mimeMessage);		//发送邮件
//                } catch (Exception e) {
//                    return false;						//发送出现异常(或者文件路径不对)
//                }
//                return true;							//成功发送
//            }else {
//                return false;    						//没有附件文件（中断发送）
//            }
            try {
                    javaMailSender.send(mimeMessage);		//发送邮件
                } catch (Exception e) {
                    return false;						//发送出现异常(或者文件路径不对)
                }
                return true;
        } catch (MessagingException e) {
            e.printStackTrace();
            //捕获到创建MimeMessageHelper的异常
//			return false;
            return true;
        }

    }
}

8、新建接口层IQuartzService和实现类QuartzServiceImpl

package com.hiQiBlog.service;

public interface IQuartzService {
    void startJob(String time, String jobName, String group);

    /****
     * 暂停一个任务
     * @param triggerName
     * @param triggerGroupName
     */
    void pauseJob(String triggerName, String triggerGroupName);
    /****
     * 暂停重启一个定时器任务
     * @param triggerName
     * @param triggerGroupName
     */
    void resumeJob(String triggerName, String triggerGroupName);

    /****
     * 删除一个定时器任务，删除了，重启就没什么用了
     * @param triggerName
     * @param triggerGroupName
     */
    void deleteJob(String triggerName, String triggerGroupName);

    /***
     * 根据出发规则匹配任务，立即执行定时任务，暂停的时候可以用
     */
    void doJob(String triggerName, String triggerGroupName);

    /***
     * 开启定时器，这时才可以开始所有的任务，默认是开启的
     */
    void startAllJob();

    /**
     * 关闭定时器，则所有任务不能执行和创建
     */
    void shutdown();
}

package com.hiQiBlog.service.impl;

import com.hiQiBlog.job.SendEmailJob;
import com.hiQiBlog.service.IQuartzService;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author ${ww}
 * @Title: QuartzServiceImpl
 * @Description: TODO
 */
/**
 SimpleScheduleBuilder是简单调用触发器，它只能指定触发的间隔时间和执行次数；
 CronScheduleBuilder是类似于Linux Cron的触发器，它通过一个称为CronExpression的规则来指定触发规则，通常是每次触发的具体时间；（关于CronExpression，详见：官方，中文网文）
 CalendarIntervalScheduleBuilder是对CronScheduleBuilder的补充，它能指定每隔一段时间触发一次。
 */

@Service
public class QuartzServiceImpl implements IQuartzService {

    @Autowired
    private Scheduler scheduler;
    @Override
    public void startJob(String time, String jobName, String group) {
        try {
            // 创建jobDetail实例，绑定Job实现类
            // 指明job的名称，所在组的名称，以及绑定job类
            JobDetail jobDetail = JobBuilder.newJob(SendEmailJob.class).withIdentity(jobName, group).build();//设置Job的名字和组
            //corn表达式  每x秒执行一次
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(time);
            //设置定时任务的时间触发规则
            CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(jobName, group).withSchedule(scheduleBuilder).build();
            System.out.println(scheduler.getSchedulerName());
            // 把作业和触发器注册到任务调度中, 启动调度
            scheduler.scheduleJob(jobDetail, cronTrigger);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /****
     * 暂停一个任务
     * @param triggerName
     * @param triggerGroupName
     */
    @Override
    public void pauseJob(String triggerName, String triggerGroupName) {
        try {
            JobKey jobKey = new JobKey(triggerName, triggerGroupName);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail == null) {
                return;
            }
            System.out.println("开始暂停一个定时器");
            scheduler.pauseJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /****
     * 暂停重启一个定时器任务
     * @param triggerName
     * @param triggerGroupName
     */
    @Override
    public void resumeJob(String triggerName, String triggerGroupName) {
        try {
            JobKey jobKey = new JobKey(triggerName, triggerGroupName);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail == null) {
                return;
            }
            scheduler.resumeJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }


    /****
     * 删除一个定时器任务，删除了，重启就没什么用了
     * @param triggerName
     * @param triggerGroupName
     */
    @Override
    public void deleteJob(String triggerName, String triggerGroupName) {
        try {
            JobKey jobKey = new JobKey(triggerName, triggerGroupName);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail == null) {
                return;
            }
            scheduler.deleteJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }


    /***
     * 根据出发规则匹配任务，立即执行定时任务，暂停的时候可以用
     */
    @Override
    public void doJob(String triggerName, String triggerGroupName) {
        try {
            JobKey jobKey = JobKey.jobKey(triggerName, triggerGroupName);
            scheduler.triggerJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }


    /***
     * 开启定时器，这时才可以开始所有的任务，默认是开启的
     */
    @Override
    public void startAllJob() {
        try {
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 关闭定时器，则所有任务不能执行和创建
     */
    @Override
    public void shutdown() {
        try {
            scheduler.shutdown();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

8、测试类

package com.hiQiBlog;

import com.hiQiBlog.service.IQuartzService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {

@Autowired
IQuartzService e;
    /**
     * 发送html格式Email
     */
    @Test
    public void testEmail() throws Exception {
        //参数 第一个是cron表达式 每五秒一次 第二个是job名称 第三个是所在组名称
        e.startJob("*/5 * * * * ? ","zz","zz");
    }

}