若依 3.0

2018-10-07 14:16:47 +08:00
parent fed3aa8231
commit e166127c9f
438 changed files with 9987 additions and 3978 deletions
--- a/ruoyi-quartz/src/main/java/com/ruoyi/quartz/util/ScheduleJob.java
+++ b/ruoyi-quartz/src/main/java/com/ruoyi/quartz/util/ScheduleJob.java
@@ -0,0 +1,77 @@
+package com.ruoyi.quartz.util;
+
+import java.util.Date;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.scheduling.quartz.QuartzJobBean;
+import com.ruoyi.common.constant.Constants;
+import com.ruoyi.common.constant.ScheduleConstants;
+import com.ruoyi.common.utils.bean.BeanUtils;
+import com.ruoyi.quartz.domain.SysJob;
+import com.ruoyi.quartz.domain.SysJobLog;
+import com.ruoyi.quartz.service.ISysJobLogService;
+
+/**
+ * 定时任务处理
+ * 
+ * @author ruoyi
+ *
+ */
+public class ScheduleJob extends QuartzJobBean
+{
+    private static final Logger log = LoggerFactory.getLogger(ScheduleJob.class);
+
+    private ExecutorService service = Executors.newSingleThreadExecutor();
+
+    private final static ISysJobLogService jobLogService = (ISysJobLogService) SpringContextUtil.getBean("sysJobLogServiceImpl");
+
+    @Override
+    protected void executeInternal(JobExecutionContext context) throws JobExecutionException
+    {
+        SysJob job = new SysJob();
+        BeanUtils.copyBeanProp(job, context.getMergedJobDataMap().get(ScheduleConstants.TASK_PROPERTIES));
+
+        SysJobLog jobLog = new SysJobLog();
+        jobLog.setJobName(job.getJobName());
+        jobLog.setJobGroup(job.getJobGroup());
+        jobLog.setMethodName(job.getMethodName());
+        jobLog.setMethodParams(job.getMethodParams());
+        jobLog.setCreateTime(new Date());
+
+        long startTime = System.currentTimeMillis();
+
+        try
+        {
+            // 执行任务
+            log.info("任务开始执行 - 名称：{} 方法：{}", job.getJobName(), job.getMethodName());
+            ScheduleRunnable task = new ScheduleRunnable(job.getJobName(), job.getMethodName(), job.getMethodParams());
+            Future<?> future = service.submit(task);
+            future.get();
+            long times = System.currentTimeMillis() - startTime;
+            // 任务状态 0：成功 1：失败
+            jobLog.setStatus(Constants.SUCCESS);
+            jobLog.setJobMessage(job.getJobName() + " 总共耗时：" + times + "毫秒");
+
+            log.info("任务执行结束 - 名称：{} 耗时：{} 毫秒", job.getJobName(), times);
+        }
+        catch (Exception e)
+        {
+            log.info("任务执行失败 - 名称：{} 方法：{}", job.getJobName(), job.getMethodName());
+            log.error("任务执行异常  - ：", e);
+            long times = System.currentTimeMillis() - startTime;
+            jobLog.setJobMessage(job.getJobName() + " 总共耗时：" + times + "毫秒");
+            // 任务状态 0：成功 1：失败
+            jobLog.setStatus(Constants.FAIL);
+            jobLog.setExceptionInfo(e.toString());
+        }
+        finally
+        {
+            jobLogService.addJobLog(jobLog);
+        }
+    }
+}
--- a/ruoyi-quartz/src/main/java/com/ruoyi/quartz/util/ScheduleRunnable.java
+++ b/ruoyi-quartz/src/main/java/com/ruoyi/quartz/util/ScheduleRunnable.java
@@ -0,0 +1,59 @@
+package com.ruoyi.quartz.util;
+
+import java.lang.reflect.Method;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.util.ReflectionUtils;
+import com.ruoyi.common.utils.StringUtils;
+
+/**
+ * 执行定时任务
+ * 
+ * @author ruoyi
+ *
+ */
+public class ScheduleRunnable implements Runnable
+{
+    private static final Logger log = LoggerFactory.getLogger(ScheduleRunnable.class);
+
+    private Object target;
+    private Method method;
+    private String params;
+
+    public ScheduleRunnable(String beanName, String methodName, String params)
+            throws NoSuchMethodException, SecurityException
+    {
+        this.target = SpringContextUtil.getBean(beanName);
+        this.params = params;
+
+        if (StringUtils.isNotEmpty(params))
+        {
+            this.method = target.getClass().getDeclaredMethod(methodName, String.class);
+        }
+        else
+        {
+            this.method = target.getClass().getDeclaredMethod(methodName);
+        }
+    }
+
+    @Override
+    public void run()
+    {
+        try
+        {
+            ReflectionUtils.makeAccessible(method);
+            if (StringUtils.isNotEmpty(params))
+            {
+                method.invoke(target, params);
+            }
+            else
+            {
+                method.invoke(target);
+            }
+        }
+        catch (Exception e)
+        {
+            log.error("执行定时任务  - ：", e);
+        }
+    }
+}
--- a/ruoyi-quartz/src/main/java/com/ruoyi/quartz/util/ScheduleUtils.java
+++ b/ruoyi-quartz/src/main/java/com/ruoyi/quartz/util/ScheduleUtils.java
@@ -0,0 +1,225 @@
+package com.ruoyi.quartz.util;
+
+import org.quartz.CronScheduleBuilder;
+import org.quartz.CronTrigger;
+import org.quartz.JobBuilder;
+import org.quartz.JobDataMap;
+import org.quartz.JobDetail;
+import org.quartz.JobKey;
+import org.quartz.Scheduler;
+import org.quartz.SchedulerException;
+import org.quartz.TriggerBuilder;
+import org.quartz.TriggerKey;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import com.ruoyi.common.constant.ScheduleConstants;
+import com.ruoyi.common.exception.job.TaskException;
+import com.ruoyi.common.exception.job.TaskException.Code;
+import com.ruoyi.quartz.domain.SysJob;
+
+/**
+ * 定时任务工具类
+ * 
+ * @author ruoyi
+ *
+ */
+public class ScheduleUtils
+{
+    private static final Logger log = LoggerFactory.getLogger(ScheduleUtils.class);
+
+    /**
+     * 获取触发器key
+     */
+    public static TriggerKey getTriggerKey(Long jobId)
+    {
+        return TriggerKey.triggerKey(ScheduleConstants.TASK_CLASS_NAME + jobId);
+    }
+
+    /**
+     * 获取jobKey
+     */
+    public static JobKey getJobKey(Long jobId)
+    {
+        return JobKey.jobKey(ScheduleConstants.TASK_CLASS_NAME + jobId);
+    }
+
+    /**
+     * 获取表达式触发器
+     */
+    public static CronTrigger getCronTrigger(Scheduler scheduler, Long jobId)
+    {
+        try
+        {
+            return (CronTrigger) scheduler.getTrigger(getTriggerKey(jobId));
+        }
+        catch (SchedulerException e)
+        {
+            log.error("getCronTrigger 异常：", e);
+        }
+        return null;
+    }
+
+    /**
+     * 创建定时任务
+     */
+    public static void createScheduleJob(Scheduler scheduler, SysJob job)
+    {
+        try
+        {
+            // 构建job信息
+            JobDetail jobDetail = JobBuilder.newJob(ScheduleJob.class).withIdentity(getJobKey(job.getJobId())).build();
+
+            // 表达式调度构建器
+            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
+            cronScheduleBuilder = handleCronScheduleMisfirePolicy(job, cronScheduleBuilder);
+
+            // 按新的cronExpression表达式构建一个新的trigger
+            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(getTriggerKey(job.getJobId()))
+                    .withSchedule(cronScheduleBuilder).build();
+
+            // 放入参数，运行时的方法可以获取
+            jobDetail.getJobDataMap().put(ScheduleConstants.TASK_PROPERTIES, job);
+
+            scheduler.scheduleJob(jobDetail, trigger);
+
+            // 暂停任务
+            if (job.getStatus().equals(ScheduleConstants.Status.PAUSE.getValue()))
+            {
+                pauseJob(scheduler, job.getJobId());
+            }
+        }
+        catch (SchedulerException e)
+        {
+            log.error("createScheduleJob 异常：", e);
+        }
+        catch (TaskException e)
+        {
+            log.error("createScheduleJob 异常：", e);
+        }
+    }
+
+    /**
+     * 更新定时任务
+     */
+    public static void updateScheduleJob(Scheduler scheduler, SysJob job)
+    {
+        try
+        {
+            TriggerKey triggerKey = getTriggerKey(job.getJobId());
+
+            // 表达式调度构建器
+            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
+            cronScheduleBuilder = handleCronScheduleMisfirePolicy(job, cronScheduleBuilder);
+
+            CronTrigger trigger = getCronTrigger(scheduler, job.getJobId());
+
+            // 按新的cronExpression表达式重新构建trigger
+            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(cronScheduleBuilder).build();
+
+            // 参数
+            trigger.getJobDataMap().put(ScheduleConstants.TASK_PROPERTIES, job);
+
+            scheduler.rescheduleJob(triggerKey, trigger);
+
+            // 暂停任务
+            if (job.getStatus().equals(ScheduleConstants.Status.PAUSE.getValue()))
+            {
+                pauseJob(scheduler, job.getJobId());
+            }
+
+        }
+        catch (SchedulerException e)
+        {
+            log.error("SchedulerException 异常：", e);
+        }
+        catch (TaskException e)
+        {
+            log.error("SchedulerException 异常：", e);
+        }
+    }
+
+    /**
+     * 立即执行任务
+     */
+    public static int run(Scheduler scheduler, SysJob job)
+    {
+        int rows = 0;
+        try
+        {
+            // 参数
+            JobDataMap dataMap = new JobDataMap();
+            dataMap.put(ScheduleConstants.TASK_PROPERTIES, job);
+
+            scheduler.triggerJob(getJobKey(job.getJobId()), dataMap);
+            rows = 1;
+        }
+        catch (SchedulerException e)
+        {
+            log.error("run 异常：", e);
+        }
+        return rows;
+    }
+
+    /**
+     * 暂停任务
+     */
+    public static void pauseJob(Scheduler scheduler, Long jobId)
+    {
+        try
+        {
+            scheduler.pauseJob(getJobKey(jobId));
+        }
+        catch (SchedulerException e)
+        {
+            log.error("pauseJob 异常：", e);
+        }
+    }
+
+    /**
+     * 恢复任务
+     */
+    public static void resumeJob(Scheduler scheduler, Long jobId)
+    {
+        try
+        {
+            scheduler.resumeJob(getJobKey(jobId));
+        }
+        catch (SchedulerException e)
+        {
+            log.error("resumeJob 异常：", e);
+        }
+    }
+
+    /**
+     * 删除定时任务
+     */
+    public static void deleteScheduleJob(Scheduler scheduler, Long jobId)
+    {
+        try
+        {
+            scheduler.deleteJob(getJobKey(jobId));
+        }
+        catch (SchedulerException e)
+        {
+            log.error("deleteScheduleJob 异常：", e);
+        }
+    }
+
+    public static CronScheduleBuilder handleCronScheduleMisfirePolicy(SysJob job, CronScheduleBuilder cb)
+            throws TaskException
+    {
+        switch (job.getMisfirePolicy())
+        {
+            case ScheduleConstants.MISFIRE_DEFAULT:
+                return cb;
+            case ScheduleConstants.MISFIRE_IGNORE_MISFIRES:
+                return cb.withMisfireHandlingInstructionIgnoreMisfires();
+            case ScheduleConstants.MISFIRE_FIRE_AND_PROCEED:
+                return cb.withMisfireHandlingInstructionFireAndProceed();
+            case ScheduleConstants.MISFIRE_DO_NOTHING:
+                return cb.withMisfireHandlingInstructionDoNothing();
+            default:
+                throw new TaskException("The task misfire policy '" + job.getMisfirePolicy() + "' cannot be used in cron schedule tasks", Code.CONFIG_ERROR);
+        }
+    }
+}
--- a/ruoyi-quartz/src/main/java/com/ruoyi/quartz/util/SpringContextUtil.java
+++ b/ruoyi-quartz/src/main/java/com/ruoyi/quartz/util/SpringContextUtil.java
@@ -0,0 +1,49 @@
+package com.ruoyi.quartz.util;
+
+import org.springframework.beans.BeansException;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.stereotype.Service;
+
+/**
+ * spring管理环境中获取bean
+ * 
+ * @author yangzz
+ */
+@Service("springContextUtil")
+public class SpringContextUtil implements ApplicationContextAware
+{
+    // Spring应用上下文环境
+    private static ApplicationContext applicationContext;
+
+    /**
+     * 实现ApplicationContextAware接口的回调方法，设置上下文环境
+     * 
+     * @param applicationContext
+     */
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext)
+    {
+        SpringContextUtil.applicationContext = applicationContext;
+    }
+
+    /**
+     * @return ApplicationContext
+     */
+    public static ApplicationContext getApplicationContext()
+    {
+        return applicationContext;
+    }
+
+    /**
+     * 获取对象
+     * 
+     * @param name
+     * @return Object
+     * @throws BeansException
+     */
+    public static Object getBean(String name) throws BeansException
+    {
+        return applicationContext.getBean(name);
+    }
+}