使用Spring + quartz实现定时任务调度

最新推荐文章于 2023-02-10 22:46:00 发布
最新推荐文章于 2023-02-10 22:46:00 发布
阅读量210 收藏
点赞数
分类专栏： Spring框架学习 文章标签： spring quartz

需求如下:用户可以设置定时发送短信.

一.环境准备

1.maven导入

    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>2.2.1</version>
    </dependency>
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz-jobs</artifactId>
        <version>2.2.1</version>
    </dependency>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

2.数据库建立quartz表

网上找.注意替换 ENGINE=InnoDB

3.classpath下创建配置文件:

quartz.properties

# Configure Main Scheduler Properties
org.quartz.scheduler.instanceName=MyTestQuartz
org.quartz.scheduler.instanceId=AUTO
org.quartz.scheduler.skipUpdateCheck=true

# Configure ThreadPool
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool 
org.quartz.threadPool.threadCount=40
org.quartz.threadPool.threadPriority=4 

# Configure JobStore 
#org.quartz.jobStore.class=org.quartz.simpl.RAMJobStore//保存在内存
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.dataSource=QRTZ_DS
//默认前缀 可以按需修改
org.quartz.jobStore.tablePrefix=QRTZ_ 
org.quartz.jobStore.isClustered=true

#config datasource
org.quartz.dataSource.QRTZ_DS.driver=com.mysql.jdbc.Driver 
org.quartz.dataSource.QRTZ_DS.URL=jdbc:mysql://10.1.1.1:3306/testdb?createDatabaseIfNotExist=true&autoReconnect=true&useUnicode=true&characterEncoding=utf8
org.quartz.dataSource.QRTZ_DS.user=root 
org.quartz.dataSource.QRTZ_DS.password=root
org.quartz.dataSource.QRTZ_DS.maxConnections=100

# Configure Plugins
org.quartz.plugin.triggHistory.class=org.quartz.plugins.history.LoggingJobHistoryPlugin
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

二.Spring配置

applicationContext.quartz.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean name="schedulerFactoryBean" lazy-init="false"
        class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="configLocation" value="classpath:quartz.properties" />
    </bean>

    <bean id="quartzService"
        class="com.wlqq.mcs.admin.timer.quartz.service.impl.QuartzServiceImpl">
        <property name="sched" ref="schedulerFactoryBean" />
    </bean>

</beans>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

三.代码清单

目录结构如下图所示 
这里写图片描述

1.QuartzService.java

package xxx;

import java.text.ParseException;
import java.util.Date;
import java.util.concurrent.TimeUnit;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.SchedulerException;

public interface QuartzService {

    /**
     * 添加按间隔执行任务
     * @param jobName 任务名称
     * @param jobGroup 任务组名称
     * @param triggerName 触发器名称
     * @param triggerGroup 触发器组名称
     * @param job 任务实例
     * @param newJobDataMap 状态参数值
     * @param interval 时间间隔
     * @param timeUnit 时间单位
     * @return
     * @throws SchedulerException
     * @throws ParseException
     */
    Date addIntervalJob(String jobName, String jobGroup, String triggerName,
                        String triggerGroup, Job job, JobDataMap newJobDataMap,
                        Integer interval, TimeUnit timeUnit) throws SchedulerException, ParseException;

    /**
     * 添加按间隔执行任务
     * @param job 任务实例
     * @param newJobDataMap 状态参数值
     * @param interval 时间间隔
     * @param timeUnit 时间单位
     * @return
     * @throws SchedulerException
     * @throws ParseException
     */
    Date addIntervalJob(Job job, JobDataMap newJobDataMap,
                        Integer interval, TimeUnit timeUnit) throws SchedulerException, ParseException;

    /**
     * 修改按间隔执行任务
     * @param jobName 任务名称
     * @param jobGroup 任务组名称
     * @param triggerName 触发器名称
     * @param triggerGroup 触发器组名称
     * @param job 任务实例
     * @param newJobDataMap 状态参数值
     * @param interval 时间间隔
     * @param timeUnit 时间单位
     * @return
     * @throws SchedulerException
     * @throws ParseException
     */
    Date modifyIntervalJob(String jobName, String jobGroup, String triggerName,
                           String triggerGroup, Job job, JobDataMap newJobDataMap,
                           Integer interval, TimeUnit timeUnit) throws SchedulerException, ParseException;

    /**
     * 修改按间隔执行任务时间间隔
     * @param triggerName 触发器名称
     * @param triggerGroup 触发器组名称
     * @param interval 时间间隔
     * @param timeUnit 时间单位
     * @return
     * @throws SchedulerException
     * @throws ParseException
     */
    Date modifyJobInterval(String triggerName, String triggerGroup,
                           Integer interval, TimeUnit timeUnit) throws SchedulerException, ParseException;

    /**
     * 添加计划任务
     * @param jobName 任务名称
     * @param jobGroup 任务组名称
     * @param triggerName 触发器名称
     * @param triggerGroup 触发器组名称
     * @param job 任务实例
     * @param newJobDataMap 状态参数值
     * @param cronExpression cron执行表达式
     * @return
     * @throws SchedulerException
     * @throws ParseException
     */
    Date addCronJob(String jobName, String jobGroup, String triggerName,
                    String triggerGroup, Job job, JobDataMap newJobDataMap, String cronExpression)
            throws SchedulerException, ParseException;

    /**
     * 添加计划任务
     * @param job 任务实例
     * @param newJobDataMap 状态参数值
     * @param cronExpression cron执行表达式
     * @return
     * @throws SchedulerException
     * @throws ParseException
     */
    public Date addCronJob(Job job, JobDataMap newJobDataMap,String cronExpression)
            throws SchedulerException, ParseException;

    /**
     * 修改计划任务
     * 
     * @param jobName
     * @param jobGroup
     * @param triggerName
     * @param triggerGroup
     * @param job
     * @param cronExpression
     * @return
     * @throws SchedulerException
     * @throws ParseException
     */
    Date modifyCronJob(String jobName, String jobGroup, String triggerName,
                       String triggerGroup, Job job, JobDataMap newJobDataMap, String cronExpression)
            throws SchedulerException, ParseException;

    /**
     * 修改计划任务的触发时间
     * 
     * @param triggerName
     * @param triggerGroupName
     * @param cronExpression
     * @throws SchedulerException
     * @throws ParseException
     */
    Date modifyCronJobTime(String triggerName, String triggerGroupName,
                           String cronExpression) throws SchedulerException, ParseException;

    /**
     * 移除任务
     * 
     * @param jobName
     * @param jobGroup
     * @param triggerName
     * @param triggerGroupName
     * @throws SchedulerException
     */
    boolean removeJob(String jobName, String jobGroup,
                      String triggerName, String triggerGroupName)
            throws SchedulerException;

    /**
     * 暂停任务
     * 
     * @param jobName
     * @param jobGroup
     * @return
     * @throws SchedulerException
     */
    void pauseJob(String jobName, String jobGroup,
                  String triggerName, String triggerGroupName)
            throws SchedulerException;


    /**
     * 恢复任务
     * 
     * @param jobName
     * @param jobGroup
     * @return
     * @throws SchedulerException
     */
    void resumeJob(String jobName, String jobGroup,
                   String triggerName, String triggerGroupName)
            throws SchedulerException;

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171

2.QuartzServiceImpl.java

package xxx;

import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;
import java.text.ParseException;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import org.quartz.CronScheduleBuilder;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.ScheduleBuilder;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerKey;

import xxx.QuartzService;

public class QuartzServiceImpl implements QuartzService{
    private Scheduler sched;

    public void setSched(Scheduler sched) {
        this.sched = sched;
    }


    private Date addJob(String jobName, String jobGroup, String triggerName,
                        String triggerGroup, Job job, JobDataMap newJobDataMap,
                        ScheduleBuilder scheduleBuilder) throws SchedulerException, ParseException  {
        if (scheduleBuilder == null) {
            return null;
        }
        JobBuilder builder = newJob(job.getClass());
        builder.setJobData(newJobDataMap);
        JobDetail jobDetail = builder.withIdentity(jobName, jobGroup).build();
        // 触发器
        Trigger trigger = newTrigger().withIdentity(triggerName, triggerGroup)
                .withSchedule(scheduleBuilder)
                .build();
        Date date = sched.scheduleJob(jobDetail, trigger);
        // 启动
        if (!sched.isShutdown()) {
            sched.start();
        }
        return date;
    }

    private Date modifyJobScheduler(String triggerName, String triggerGroupName,
                                    ScheduleBuilder scheduleBuilder) throws SchedulerException, ParseException {
        if (scheduleBuilder == null) {
            return null;
        }
        TriggerKey key = new TriggerKey(triggerName, triggerGroupName);
        Trigger trigger = sched.getTrigger(key);
        if (trigger != null) {
            trigger.getTriggerBuilder()
                    .withSchedule(scheduleBuilder)
                    .build();
            return sched.rescheduleJob(key, trigger);
        }
        return null;
    }

    private SimpleScheduleBuilder intervalScheduleBuilder(Integer interval, TimeUnit timeUnit) {
        SimpleScheduleBuilder simpleScheduleBuilder = SimpleScheduleBuilder.simpleSchedule().repeatForever();

        switch (timeUnit) {
            case MINUTES:
                simpleScheduleBuilder.withIntervalInMinutes(interval);
                break;
            case HOURS:
                simpleScheduleBuilder.withIntervalInHours(interval);
                break;
            case DAYS:
                simpleScheduleBuilder.withIntervalInHours(interval * 24);
                break;
            default:
                return null;
        }
        return simpleScheduleBuilder;
    }

    @Override
    public Date addIntervalJob(String jobName, String jobGroup, String triggerName, String triggerGroup,
                               Job job, JobDataMap newJobDataMap,
                               Integer interval, TimeUnit timeUnit) throws SchedulerException, ParseException {

        return addJob(jobName, jobGroup, triggerName, triggerGroup, job, newJobDataMap,
                intervalScheduleBuilder(interval, timeUnit));
    }

    @Override
    public Date addIntervalJob(Job job, JobDataMap newJobDataMap,
                               Integer interval, TimeUnit timeUnit) throws SchedulerException, ParseException {
        String id=UUID.randomUUID().toString().replaceAll("-", "");
        return addIntervalJob(id, id, id, id, job, newJobDataMap, interval, timeUnit);
    }

    @Override
    public Date modifyIntervalJob(String jobName, String jobGroup, String triggerName, String triggerGroup,
                                  Job job, JobDataMap newJobDataMap,
                                  Integer interval, TimeUnit timeUnit) throws SchedulerException, ParseException {
        removeJob(jobName, jobGroup, triggerName, triggerGroup);
        return addIntervalJob(jobName, jobGroup, triggerName, triggerGroup, job, newJobDataMap, interval, timeUnit);
    }

    @Override
    public Date modifyJobInterval(String triggerName, String triggerGroup,
                                  Integer interval, TimeUnit timeUnit) throws SchedulerException, ParseException {
        return modifyJobScheduler(triggerName, triggerGroup, intervalScheduleBuilder(interval, timeUnit));
    }


    /**
     * 添加任务
     * 
     * @param jobName
     *            任务名称
     * @param jobGroup
     *            任务组名称
     * @param triggerName
     *            触发器名称
     * @param triggerGroup
     *            触发器组名称
     * @param job
     *            任务实例
     * @param cronExpression
     *            cron表达式
     * @throws SchedulerException
     * @throws ParseException
     */
    public Date addCronJob(String jobName, String jobGroup, String triggerName,
            String triggerGroup, Job job, JobDataMap newJobDataMap,
            String cronExpression) throws SchedulerException, ParseException {
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
        return addJob(jobName, jobGroup, triggerName, triggerGroup, job, newJobDataMap, cronScheduleBuilder);
    }


    @Override
    public Date addCronJob(Job job, JobDataMap newJobDataMap, String cronExpression)
            throws SchedulerException, ParseException {
        String id=UUID.randomUUID().toString().replaceAll("-", "");
        return addCronJob(id, id, id, id, job, newJobDataMap, cronExpression);
    }

    /**
     * 修改任务
     * 
     * @param jobName
     * @param jobGroup
     * @param triggerName
     * @param triggerGroup
     * @param job
     * @param cronExpression
     * @return
     * @throws SchedulerException
     * @throws ParseException
     */
    public Date modifyCronJob(String jobName, String jobGroup, String triggerName,
            String triggerGroup, Job job,JobDataMap newJobDataMap, String cronExpression)
            throws SchedulerException, ParseException {
        removeJob(jobName, jobGroup, triggerName, triggerGroup);
        return addCronJob(jobName, jobGroup, triggerName, triggerGroup, job, newJobDataMap,
                cronExpression);
    }

    /**
     * 修改一个任务的触发时间
     * 
     * @param triggerName
     * @param triggerGroupName
     * @param cronExpression
     * @throws SchedulerException
     * @throws ParseException
     */
    public Date modifyCronJobTime(String triggerName, String triggerGroupName,
            String cronExpression) throws SchedulerException, ParseException {
        return modifyJobScheduler(triggerName, triggerGroupName,
                CronScheduleBuilder.cronSchedule(cronExpression));
    }

    /**
     * 移除任务
     * 
     * @param jobName
     * @param jobGroup
     * @param triggerName
     * @param triggerGroupName
     * @throws SchedulerException
     */
    public boolean removeJob(String jobName, String jobGroup,
            String triggerName, String triggerGroupName)
            throws SchedulerException {
        TriggerKey key = new TriggerKey(triggerName, triggerGroupName);
        sched.pauseTrigger(key);// 停止触发器
        sched.unscheduleJob(key);// 移除触发器

        JobKey jobKey = new JobKey(jobName, jobGroup);
        return sched.deleteJob(jobKey);// 删除任务
    }

    /**
     * 暂停任务
     * 
     * @param jobName
     * @param jobGroup
     * @param triggerName
     * @param triggerGroupName
     * @throws SchedulerException
     */
    public void pauseJob(String jobName, String jobGroup, String triggerName,
            String triggerGroupName) throws SchedulerException {
        TriggerKey key = new TriggerKey(triggerName, triggerGroupName);
        sched.pauseTrigger(key);// 停止触发器

        JobKey jobKey = new JobKey(jobName, jobGroup);
        sched.pauseJob(jobKey);// 停止任务
    }

    /**
     * 恢复任务
     * 
     * @param jobName
     * @param jobGroup
     * @param triggerName
     * @param triggerGroupName
     * @throws SchedulerException
     */
    public void resumeJob(String jobName, String jobGroup, String triggerName,
            String triggerGroupName) throws SchedulerException {
        TriggerKey key = new TriggerKey(triggerName, triggerGroupName);
        sched.resumeTrigger(key);// 重启触发器

        JobKey jobKey = new JobKey(jobName, jobGroup);
        sched.resumeJob(jobKey);// 重启任务
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243

3.MassSmsJob.java （群发短信job）

package xxx.quartz.job;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;

import xxx.commons.exceptions.BusinessException;
import xxx.httpcommons.util.SpringContextUtil;
import xxx.service.SmsMassService;

/**
 * 群发短信job
 * @author Mingchenchen
 *
 */
public class MassSmsJob implements Job{
    public static final String SMS_MASS_JOB_GROUP = "smsMassJob"; // jobGroup
    public static final String SMS_MASS_TRIGGER_GROUP = "smsMassTrigger"; // triggerGroup

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDataMap datamap = context.getJobDetail().getJobDataMap();

        String smsMassUuid = datamap.getString("uuid");
        String title = datamap.getString("title");
        String message = datamap.getString("message");
        String phones = datamap.getString("phones");

        try {
            //此处就是定时任务实际执行的逻辑
            SmsMassService smsMassService = SpringContextUtil.getBean(SmsMassService.class);
            smsMassService.sendSms(smsMassUuid, title, message, phones);
        } catch (BusinessException e) {
            e.printStackTrace();
        }
    }

}

//业务逻辑 
public void sendSms(String smsMassUuid, String title,
        String message, String phones){
    //调用sms群发短信
    //TODO

    //修改数据库标志位为已经发送
    smsMassDao.setSended(smsMassUuid);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

4.CronExpressionUtils.java

package xxx.quartz.utils;

import java.util.Calendar;
import java.util.Date;

public class CronExpressionUtils {

    /**
     * 根据一个时间解析成cron表达式
     * @param date
     * @return
     */
    public static String getCronExpressionByDate(Date date){
        String cronExpression = "";

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1; //注意从0开始
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        int minute = calendar.get(Calendar.MINUTE);
        int second = calendar.get(Calendar.SECOND);

        // "30 10 1 20 10 ? 2011" 2011年10月20号1点10分30秒触发任务,?是第几周 不指定
        cronExpression = second + " " + minute + " " + hour + " "
                + day + " " + month + " ? " + year;
        return cronExpression;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

5.业务逻辑service调用 SmsMassServiceImpl.java

    @Value("${sms.mass.interval.minite:10}")
    private int smsMassInterval; //群发短信的间隔,默认是10分钟
    @Autowired
    private SmsMassDao smsMassDao;
    @Autowired
    private QuartzService quartzService;

    /**
     * 创建定时任务
     * @param uuid
     * @param title
     * @param message
     * @param sendTime
     * @param phones
     * @throws BusinessException
     */
    private void createSmsMassCronJob(SmsMassRecord record) throws BusinessException{
        MassSmsJob job = new MassSmsJob();
        JobDataMap dataMap = new JobDataMap();
        dataMap.put("uuid", record.getUuid());
        dataMap.put("title", record.getTitle());
        dataMap.put("message", record.getMessage());
        dataMap.put("phones", record.getPhones());

        String jobName = record.getUuid();
        String jobGroup = MassSmsJob.SMS_MASS_JOB_GROUP;
        String triggerName = record.getUuid();
        String triggerGroup = MassSmsJob.SMS_MASS_TRIGGER_GROUP;

        Date date = record.getSendTime();
        String cronExpression = CronExpressionUtils.getCronExpressionByDate(date);
        try {
            quartzService.addCronJob(jobName, jobGroup, triggerName, 
                    triggerGroup, job, dataMap, cronExpression);
        } catch (SchedulerException | ParseException e) {
            e.printStackTrace();
            throw new BusinessException(ResultCode.SYSTEM_EXCEPTION.code(), ResultCode.SYSTEM_EXCEPTION.message());
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

其他地方需要调用SpringContextUtil.getBean(QuartzService.class);即可


啊芽哟
关注
专栏目录
Spring+Quartz配置定时任务实现代码
08-19
Spring+Quartz配置定时任务实现代码 ...本文详细介绍了Spring+Quartz配置定时任务实现代码的详细实现过程，通过了Quartz的强大调度功能和Spring的灵活依赖注入机制，实现了灵活可配置的定时任务调度功能。
quartz-schedule SimpleScheduleBuilder
Yingtaozi_0的博客
07-01 1900
调度、quartz schedule、SimpleScheduleBuilder、ScheduleBuilder
SpringBoot 之 Quartz 使用
最新发布
程序员小明1024
02-10 2941
一、Quartz简介 用过Quartz的都懂，Quartz就是一个完全由java编写的开源作业调度框架。 1、组件简介 需要使用这个框架需要知道几个词。 Job Job是一个任务接口，开发者定义自己的任务须实现该接口，并重写execute(JobExecutionContext context)方法. Job中的任务有可能并发执行，例如任务的执行时间过长，而每次触发的时间间隔太短，则会导...
Springboot中的定时任务(@Scheduled和quartz类)
weixin_43597991的博客
05-09 2224
Springboot中的定时任务(@Scheduled和quartz类)
Quartz任务调度框架之最全Quartz系统参数配置详解
tms192407的博客
01-10 4938
quartz配置参数详解
spring+springMVC+mybatis+quartz动态定时任务创建
09-18
在IT行业中，构建高效、可扩展的Web应用是至关重要的，而"spring+springMVC+mybatis+quartz动态定时任务创建"就是一个常见的技术栈，用于实现这样的目标。这个组合充分利用了各组件的优势，提供了强大的后端服务支持...
Spring+quartz实现定时发送邮件功能实例
08-31
Spring+Quartz实现定时发送邮件功能实例 Spring框架提供的定时发送邮件功能一直深受广大Web开发者的喜爱。...Spring+Quartz实现定时发送邮件功能实例可以满足各种复杂的调度需求，实现灵活的任务调度和执行。
基于SSM+quartz的定时任务管理demo
05-10
本Demo以"基于SSM+quartz的定时任务管理"为主题，将展示如何在Spring、SpringMVC和MyBatis（SSM）框架基础上，集成Quartz作为调度引擎，实现高效灵活的定时任务管理。 **1. SSM框架简介** SSM是Spring、SpringMVC...
spring+quartz实现定时任务动态管理
06-09
本项目旨在实现对Quartz定时任务的动态管理，包括添加、停止和恢复等操作。前端采用jQuery和Bootstrap构建，提供用户友好的可视化界面，同时应用了MyBatis分页插件来优化数据查询性能。 首先，让我们详细了解一下...
定时任务框架Quartz(二)之数据库储存
m0_53151031的博客
02-17 6340
目录 一、数据库解析 1、先创建一个springBoot项目，勾选quartz scheduler​ 2.进入官网下载quartz内置表，进行测试的表 3、找到table_mysql的脚本在idea里面运行 ​ 4.运行sql脚本，新生成两个数据库表 6、新增模拟数据，进行测试 二、工具类分析 1、导入pom依赖 2、导入使用数据库存储的配置文件： 3、导入相关类...
java 定时器qz xm配置_Spring Boot集成quartz实现定时任务并支持切换任务数据源
weixin_31630667的博客
02-27 387
org.quartz实现定时任务并自定义切换任务数据源在工作中经常会需要使用到定时任务处理各种周期性的任务，org.quartz是处理此类定时任务的一个优秀框架。随着项目一点点推进，此时我们并不满足于任务仅仅是定时执行，我们还想要对任务进行更多的控制，随时能对任务进行人为干预，就需要对quartz有更深入的了解。而随着微服务的流行，项目中多数据源的情况也越来越常见，在定时任务中集成多数据源切换的功...
Quartz使用切换数据库源运行定时任务以及注意事项
梦寒君的博客
02-12 1464
Quartz使用切换数据库源运行定时任务以及注意事项
Quartz与Spring集成—— SchedulerFactoryBean的初始化分析
热门推荐
beliefer的博客
07-25 7万+
Quartz是一个开源的定时调度框架，支持集群部署。我们可以通过其Java API来使用它，或者通过Spring来配置与管理，也可以结合使用两种方式。本文重点分析Quartz与Spring集成时的初始化过程。
java quartz 数据库_SpringBoot+Quartz+数据库存储
weixin_33773670的博客
02-16 1192
Spring整合Quartza、quartz调度框架是有内置表的进入quartz的官网http://www.quartz-scheduler.org/，点击Downloads，下载后在目录\docs\dbTables下有常用数据库创建quartz表的脚本，例如：“tables_mysql.sql”table_mysql.sqltable_mysql_innodb.sqlorg.quartz-sch...
quartz动态定时器实现
qq_43227109的博客
03-22 302
今天完成一个定时器的动态实现 在修改数据库表定时器规则 定时器会自动改变 或者说在页面修改状态 定时器是否可用 首先是基础环境配置 quartz调度框架是有内置表的 进入quartz的官网http://www.quartz-scheduler.org/，点击Downloads， 下载后在目录\docs\dbTables下有常用数据库创建quartz表的脚本，例如：“tables_my...
quartz集群模式下qrtz_triggers表trigger_state变ERROR分析
Marshall_Ma的博客
07-30 8910
quartz集群模式下qrtz_triggers表trigger_state变ERROR分析
使用quartz集群开发定时任务整理
clCHY18296153110的博客
07-25 1051
在微服务环境下，定时任务也需要独立为一个服务。这里使用spring+quartz搭建定时任务开发环境。 在Config加载quartz.properties配置文件时，本地环境因为资源文件我们都存放在项目resource下，可使用ClassPathResource去拿到资源文件。可是在集成、测试、生产环境下，一般会把配置文件都拿出来统一放在项目外的一个文件中，而ClassPathResource...
spring+quartz实现定时任务
lovfyna的博客
06-08 509
1.准备工作 <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>${quartz_version}</version> </dependency>
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值