JAVA 定时器框架

最新推荐文章于 2023-10-08 11:21:05 发布
最新推荐文章于 2023-10-08 11:21:05 发布
阅读量1k 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_36415076/article/details/53192672
版权

web.xml

<display-name>XXX Web Application</display-name>
<context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/conf/frame-spring.xml
        </param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
        <context-param>
        <param-name>configLoader</param-name>
        <param-value>
            /WEB-INF/conf/frame-spring.xml
        </param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.request.RequestContextListener
        </listener-class>
    </listener>

frame-spring.xml

<import resource="applicationContext-quartz.xml" />

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-3.2.xsd">

    <!--动态定时任务工厂-->
    <bean id="schedulerFactoryBean"  class="org.springframework.scheduling.quartz.SchedulerFactoryBean" scope="singleton" >
    </bean>

    <!--Tomcat启动之后加载定时（启用）任务运行-->
    <bean id="quartzInitListener" class="com.xxx.quartz.QuartzInitListener" scope="singleton" />

</beans>

QuartzInitListener.java

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;

/**
 * 任务加载类
 * Tomcat启动之后自动调用处于 运行中 的任务
 */
public class QuartzInitListener implements ApplicationListener<ContextRefreshedEvent> {
    protected static final Logger LOGGER = LoggerFactory.getLogger(QuartzInitListener.class);
    @SuppressWarnings("unchecked")
    @Override
    public void onApplicationEvent(ContextRefreshedEvent ev) {
        if("0".equals(DataProcessAtom.autoTaskSwitch)){
            //关闭了定时任务，不加载任务
        }else{
            //防止重复执行。
            if(ev.getApplicationContext().getParent() == null){
                DataExchangeAssembly dataExchange = new TaskInQurartz().getDataExchage();
                ReflectionUtil.reflectThrowExceptionClearly("SXXXXXX",dataExchange,null);
            }
        }
    }
}

SXXXXXX

    /**
     * 初始化运行中的任务
     * @param dataExchange
     * @return
     */
    public GenericResult initScheduleJob2acctDataProcess(DataExchangeAssembly dataExchange){
        try {
            try {
                //获取运行中的任务
                List<ScheduleJob> jobList = getDoingJobs(dataExchange);
                for (ScheduleJob job : jobList) {
                    TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());
                    //获取trigger，即在spring配置文件中定义的 bean id="myTrigger"
                    CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
                    //不存在，创建一个
                    if (null == trigger) {
                        JobDetail jobDetail = JobBuilder.newJob(QuartzJobFactory.class)
                                .withIdentity(job.getJobName(), job.getJobGroup()).build();
                        jobDetail.getJobDataMap().put("scheduleJob", job);
                        //表达式调度构建器
                        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
                                .getCronExpression());
                        //按新的cronExpression表达式构建一个新的trigger
                        trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();
                        scheduler.scheduleJob(jobDetail, trigger);
                    } else {
                        // Trigger已存在，那么更新相应的定时设置
                        //表达式调度构建器
                        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
                                .getCronExpression());
                        //按新的cronExpression表达式重新构建trigger
                        trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                                .withSchedule(scheduleBuilder).build();
                        //按新的trigger重新设置job执行
                        scheduler.rescheduleJob(triggerKey, trigger);
                    }
                }
                //提示码：0；提示信息：DIA_加载运行中的任务成功
                return new AtomResult(BusinessPrompt.ATOM_SUC_CODE, BusinessPrompt.START_SCHEDULE_JOB_SUC_MSG, null);
            }catch (Exception e){
                //提示码：-100326；提示信息：DIA_开启任务失败
                throw new AtomException(BusinessPrompt.START_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.START_SCHEDULE_JOB_FAIL_MSG+"，详细异常：【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
            }
        }catch (AtomException exception) {
            return new AtomResult(exception.getErrorCode(), exception.getMessage());
        }
    }

    private List<ScheduleJob> getDoingJobs(DataExchangeAssembly dataExchange) {
        Map<String, String> params = (Map<String, String>) dataExchange.getBusinessData("params");
        Map pm = new HashMap();
        pm.put("JOB_STATUS","1");
        dataExchange.setBusinessData("params",pm);
        List<ScheduleJob> ls = getJob(dataExchange);
        dataExchange.setBusinessData("params",params);
        return ls;
    }
public List<ScheduleJob> getJob(DataExchangeAssembly dataExchange) {
        //根据任务标识获取任务(从数据库中拿)
        List<Map> jobMaps = queryScheduleJob2acctDataProcess(dataExchange).getDataList();
        List<ScheduleJob> list = new ArrayList<ScheduleJob>();
        for (int i = 0,len=jobMaps.size(); i < len; i++) {
            ScheduleJob job = new ScheduleJob();
            Map jobMap = jobMaps.get(i);
            String execNo = ObjectUtils.toString(jobMap.get("EXEC_NO")).trim();
            job.setJobId(ObjectUtils.toString(jobMap.get("JOB_ID")));
            job.setJobName(ObjectUtils.toString(jobMap.get("JOB_NAME")));
            job.setJobGroup(ObjectUtils.toString(jobMap.get("JOB_GROUP")));
            job.setJobStatus(ObjectUtils.toString(jobMap.get("JOB_STATUS")));
            job.setCronExpression(ObjectUtils.toString(jobMap.get("CRON_EXPRESSION")));
            job.setDesc(ObjectUtils.toString(jobMap.get("JOB_DESC")));
            job.setExecNo(execNo);
            job.setDataExchange(dataExchange);
            job.setBusinessArea(dataExchange.getBusinessArea());
            job.setServiceArea(dataExchange.getServiceArea());
            job.setDataProcessAtom(this);
            list.add(job);
        }
        return list;
    }
    public int queryScheduleJob2acctDataProcessBiz(Map<String, String> params, Map<String, String> commParams, GenericResult result) {
        int iRetCode = 0;
        try {
            iRetCode = FrameDao.doBexCall("queryScheduleJob2acctDataProcessBex", params, commParams, result);
            if (iRetCode != FrameErrorCode.ISUCCESS_CODE) {
                //错误码：-200273；错误信息：DIA_计划任务信息查询数据操作失败。
                throw new AtomException(BusinessPrompt.QUERY_SCHEDULE_JOB_ERROR_CODE, BusinessPrompt.QUERY_SCHEDULE_JOB_ERROR_MSG, FrameworkConstants.BIZ_LVL);
            }
        } catch (AtomException exception) {
            iRetCode = exception.getErrorCode();
        }
        return iRetCode;
    }

其他任务操作

  StdScheduler scheduler =(StdScheduler)ConfigLoadUtil.applicationContext.getBean("schedulerFactoryBean");

    /**
     *  添加任务,运行
     * @param dataExchange
     */
    public void addAutoTask(DataExchangeAssembly dataExchange){
        try {
            //这里获取任务信息数据
            List<ScheduleJob> jobList = getJob(dataExchange);
            for (ScheduleJob job : jobList) {
                TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());
                //获取trigger，即在spring配置文件中定义的 bean id="myTrigger"
                CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
                //不存在，创建一个
                if (null == trigger) {
                    JobDetail jobDetail = JobBuilder.newJob(QuartzJobFactory.class)
                            .withIdentity(job.getJobName(), job.getJobGroup()).build();
                    jobDetail.getJobDataMap().put("scheduleJob", job);
                    //表达式调度构建器
                    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
                            .getCronExpression());
                    //按新的cronExpression表达式构建一个新的trigger
                    trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();
                    scheduler.scheduleJob(jobDetail, trigger);
                } else {
                    // Trigger已存在，那么更新相应的定时设置
                    //表达式调度构建器
                    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
                            .getCronExpression());
                    //按新的cronExpression表达式重新构建trigger
                    trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                            .withSchedule(scheduleBuilder).build();
                    //按新的trigger重新设置job执行
                    scheduler.rescheduleJob(triggerKey, trigger);
                }
            }
        }catch (Exception e){
            //提示码：-100326；提示信息：DIA_开启任务失败
            throw new AtomException(BusinessPrompt.START_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.START_SCHEDULE_JOB_FAIL_MSG+"，详细异常：【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
        }
    }


    /**
     * 删除任务(终止任务)
     * @param dataExchange
     */
    public void removeAutoTask(DataExchangeAssembly dataExchange){
        //这里获取任务信息数据
        List<ScheduleJob> jobList = getJob(dataExchange);
        try {
            for (ScheduleJob job : jobList) {
                JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
                scheduler.deleteJob(jobKey);
            }
        }catch (Exception e){
            //提示码：-100327；提示信息：DIA_恢复任务失败
            throw new AtomException(BusinessPrompt.RESUME_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.RESUME_SCHEDULE_JOB_FAIL_MSG+"，详细信息【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
        }
    }

    /**
     *  开启任务
     * @param dataExchange
     */
    public void execAutoTask(DataExchangeAssembly dataExchange) {
        removeAutoTask(dataExchange);
        addAutoTask(dataExchange);
    }

    /**
     * 恢复任务
     * @param dataExchange
     */
    public void resumeAutoTask(DataExchangeAssembly dataExchange){
        //这里获取任务信息数据
        List<ScheduleJob> jobList = getJob(dataExchange);
        try {
            for (ScheduleJob job : jobList) {
                JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
                scheduler.resumeJob(jobKey);
            }
        }catch (Exception e){
            //提示码：-100327；提示信息：DIA_恢复任务失败
            throw new AtomException(BusinessPrompt.RESUME_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.RESUME_SCHEDULE_JOB_FAIL_MSG+"，详细信息【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
        }
    }

    /**
     * 暂停任务
     * @param dataExchange
     */
    public void stopAutoTask(DataExchangeAssembly dataExchange) {
        //这里获取任务信息数据
        List<ScheduleJob> jobList = getJob(dataExchange);
        try {
            for (ScheduleJob job : jobList) {
                JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
                scheduler.pauseJob(jobKey);
            }
        }catch (Exception e){
            //提示码：-100323；提示信息：DIA_暂停任务失败
            throw new AtomException(BusinessPrompt.STOP_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.STOP_SCHEDULE_JOB_FAIL_MSG+"，详细信息【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
        }
    }

    /**
     * 获取已经添加到quartz调度器的任务(计划中的任务)
     * @param dataExchange
     */
    public List<ScheduleJob> qryToDoTasks(DataExchangeAssembly dataExchange) {
        List<ScheduleJob> jobList = new ArrayList<ScheduleJob>();
        try {
            GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
            Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
            for (JobKey jobKey : jobKeys) {
                List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
                for (Trigger trigger : triggers) {
                    ScheduleJob job = new ScheduleJob();
                    job.setJobName(jobKey.getName());
                    job.setJobGroup(jobKey.getGroup());
                    job.setDesc("触发器:" + trigger.getKey());
                    Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                    job.setJobStatus(triggerState.name());
                    if (trigger instanceof CronTrigger) {
                        CronTrigger cronTrigger = (CronTrigger) trigger;
                        String cronExpression = cronTrigger.getCronExpression();
                        job.setCronExpression(cronExpression);
                    }
                    jobList.add(job);
                }
            }
        }catch (Exception e){
            //提示码：-100324；提示信息：DIA_查询计划中的任务失败
            throw new AtomException(BusinessPrompt.QUERY_TODO_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.QUERY_TODO_SCHEDULE_JOB_FAIL_MSG+"，详细异常：【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
        }finally {
            return  jobList;
        }
    }

    /**
     * 获取运行中的任务（这里的运行中是正在调用对应的接口）
     * @param dataExchange
     * @return
     */
    public List<ScheduleJob> qryDoingTasks(DataExchangeAssembly dataExchange) {
        List<ScheduleJob> jobList = new ArrayList<ScheduleJob>();
        try {
            List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
            jobList = new ArrayList<ScheduleJob>(executingJobs.size());
            for (JobExecutionContext executingJob : executingJobs) {
                ScheduleJob job = new ScheduleJob();
                JobDetail jobDetail = executingJob.getJobDetail();
                JobKey jobKey = jobDetail.getKey();
                Trigger trigger = executingJob.getTrigger();
                job.setJobName(jobKey.getName());
                job.setJobGroup(jobKey.getGroup());
                job.setDesc("触发器:" + trigger.getKey());
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                job.setJobStatus(triggerState.name());
                if (trigger instanceof CronTrigger) {
                    CronTrigger cronTrigger = (CronTrigger) trigger;
                    String cronExpression = cronTrigger.getCronExpression();
                    job.setCronExpression(cronExpression);
                }
                jobList.add(job);
            }
        }catch (Exception e){
            //提示码：-100325；提示信息：DIA_查询运行中的任务失败
            throw new AtomException(BusinessPrompt.QUERY_DOING_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.QUERY_DOING_SCHEDULE_JOB_FAIL_MSG+"，详细异常：【"+e.getMessage()+"】", FrameworkConstants.ATOM_LVL);
        }finally {
            return  jobList;
        }
    }

    public GenericResult startScheduleJob2acctDataProcess(DataExchangeAssembly dataExchange) {
        try {
            if("0".equals(autoTaskSwitch)){
                throw new AtomException(BusinessPrompt.COLSED_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.COLSED_SCHEDULE_JOB_FAIL_MSG, FrameworkConstants.ATOM_LVL);
            }
            Map<String, String> params = (Map<String, String>) dataExchange.getBusinessData("params");
            Map<String, String> commParams = (Map<String, String>) dataExchange.getBusinessData("commParams");
            int iRetCode = 0;
            Uresult result = new Uresult();
            params.put("JOB_STATUS","1");
            iRetCode = dataProcessBiz.updateScheduleJob2acctDataProcessBiz(params, commParams, result);
            if (iRetCode != FrameErrorCode.ISUCCESS_CODE) {
                //提示码：-100320；提示信息：DIA_计划任务信息修改失败
                throw new AtomException(BusinessPrompt.UPDATE_SCHEDULE_JOB_FAIL_CODE, BusinessPrompt.UPDATE_SCHEDULE_JOB_FAIL_MSG, FrameworkConstants.ATOM_LVL);
            }
            execAutoTask(dataExchange);
            //提示码：0；提示信息：DIA_计划任务信息删除成功
            return new AtomResult(BusinessPrompt.ATOM_SUC_CODE, BusinessPrompt.DELETE_SCHEDULE_JOB_SUC_MSG, result.getDataList());
        } catch (AtomException exception) {
            return new AtomResult(exception.getErrorCode(), exception.getMessage());
        }
    }
行一米
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文搞懂，java中常用的定时任务框架-单体
weixin_64314555的博客
12-20 892
一、阅读收获 ✔️1. 了解常用的单体应用定时任务框架 ✔️2. 掌握定时任务在单体中如何使用 二、Timer+TimerTask 这是jdk自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。 使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行,一般用的较少。 /** * @Description: 1. Timer+TimerTask：（jdk自带） * 这是java自带的java.util.Timer类，这个类允许..
java 定时任务管理框架
09-06
可以通过少量修改直接融入到已有的java项目，有维护定时器的界面，包括新增修改删除，立即执行，暂停，恢复等功能，省去了项目中大量配置定时器的繁琐,而且便于维护
Java定时器框架(Quartz)
12-23
有助于你快速的查找您要使用的类对象及其方法。
一个java定时器框架
weixin_33753845的博客
02-25 79
ScheduleIterator接口 import java.util.Date;public interface ScheduleIterator {    public Date next();//获取下一个触发的时间点} Scheduler类 import java.util.Date;import java.util.Timer;import java.util.TimerTask;...
java 定时器框架_java定时器
weixin_39648539的博客
02-24 166
java定时器什么是Java定时器？Java 定时器就是在给定的间隔时间执行自己的任务; Java实现定时器有以下几种:通过Timer来实现定时任务Timer 是来自 java.util.Timer指定时间执行任务/*** @author spp* @date 2020-10-14 09:04**/public class TimerTest {public static void main(St...
java定时器框架_一个java定时器框架
weixin_34471838的博客
02-12 200
ScheduleIterator接口import java.util.Date;public interface ScheduleIterator{public Date next();//获取下一个触发的时间点}Scheduler类import java.util.Date;import java.util.Timer;import java.util.TimerTask;public clas...
java 定时器框架_一个java定时器框架
weixin_42367557的博客
02-16 72
ScheduleIterator接口importjava.util.Date;publicinterfaceScheduleIterator{publicDatenext();//获取下一个触发的时间点}Scheduler类importjava.util.Date;importjava.util.Timer;importjava.util.TimerTask;publicclas...
java定时器设置及停止的方法
06-17
如果你在Spring框架中工作，还可以利用Spring的定时任务支持，如Quartz或Spring Task。Quartz是一个强大且高度可配置的调度器，它可以按指定时间或频率执行任务。在Spring中使用Quartz，你需要创建一个作业类（Job）...
Java定时器Timer简述
08-31
Java定时器Timer是Java语言中用于执行定时任务的类，它位于`java.util`包下。Timer类提供了在指定时间或周期性执行任务的能力，但需要注意的是，它并不保证任务的实时执行，也就是说，任务的实际执行时间可能会受到...
JAVA定时器JAVA定时器.pdf
10-08
JAVA定时器是一种基于Quartz框架的任务调度器，用于在指定的时间执行特定的任务。在 Spring 框架中，JAVA定时器可以与Quartz框架集成，实现自动执行任务的功能。 1. JAVA定时器的基本概念 JAVA定时器是基于Quartz...
Java定时器.pdf
10-08
Java定时器框架主要由`java.util.Timer`和`java.util.TimerTask`组成，这两个类提供了在Java中安排一次性或重复性任务的能力。然而，这个框架存在一定的局限性，例如无法直接处理夏令时变化导致的时间跳跃问题，对于...
有关Java 计时器框架
hd_dream的专栏
06-11 189
写一个调度器,来周期性地执行一些操作,我首先想到的是java.util.Timer类,但又不太了解,就google一下. java.util.Timer 和 java.util.TimerTask 统称为 Java 计时器框架. 实例: 调用类 [code="java"]import java.util.Timer; public class Test { public ...
Java并发——定时器框架
zhm1563550235的博客
11-20 726
1. 定时器框架 类Timer和TimerTask组成了Timer框架。 Timer是jdk中提供的一个定时器工具，使用的时候会在主线程之外起一个单独的线程执行指定的计划任务，可以指定执行一次或者反复执行多次。 TimerTask是一个实现了Runnable接口的抽象类，代表一个可以被Timer执行的任务。 import java.util.Timer; import java.util...
java定时任务框架有哪些
weixin_35755562的博客
12-27 1000
Java有许多定时任务框架可供选择。常见的定时任务框架有： Quartz：强大的定时任务框架，支持多种调度策略和集群部署。 Timer和TimerTask：Java自带的定时任务框架，使用简单但功能有限。 Spring Task：Spring框架的定时任务模块，使用简单，支持注解配置。 cron4j：一个基于cron表达式的定时任务框架。 java.util.concurrent包中的S...
Java定时任务框架整理
AVATAR
12-30 6068
再见 Spring Task，这个定时任务框架真香！ 目录 再见 Spring Task，这个定时任务框架真香！ 为什么需要定时任务？ 单机定时任务技术选型 Timer ScheduledExecutorService Spring Task 时间轮 分布式定时任务技术选型 Quartz Elastic-Job XXL-JOB PowerJob 总结 以下文章来源于JavaGuide，作者Guide哥 JavaGuide. 专注Java后端学习和大厂面试的公众号！开源.
Java定时任务及常见框架
最新发布
weixin_45734473的博客
10-08 2268
Java定时任务及常见框架
java定时器框架_java Quartz定时器任务与Spring task定时的几种实现,
weixin_39977488的博客
02-12 82
public classJob2 {public voiddoJob2() {System.out.println("不继承QuartzJobBean方式-调度进行中...");}}可以看出，这就是一个普通的类，并且有一个方法。第二步：配置作业类class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBe...
quartz 一个Java的定时器框架 入门心得
巴休特的风之剑
10-23 262
quartz是一个定时器框架，可以用它在java里做些什么？ 比如，每天 00.00.00 时服务器刷新缓存，清除已过期的数据，或是每到各种节日，固定给user发送祝福消息提醒。 话不多说，首先下载jar包： //定时器 quartz compile group: 'org.quartz-scheduler', name: 'quartz', version: '2.3.0...
Java 定时器框架，可视化，可查看错误及异常信息 有没有推荐的
07-11
对于Java定时器框架，我可以向您推荐Quartz。Quartz是一个功能强大且广泛使用的开源定时任务调度框架，它允许您创建基于时间的作业并在预定时间执行它们。Quartz提供了丰富的功能，包括可视化管理界面和错误/异常信息的记录和查看。 Quartz的可视化管理界面允许您方便地配置和管理定时任务。您可以使用这个界面创建、编辑和删除作业，设置触发器，查看作业执行历史等等。这个界面使得管理和监控定时任务变得更加简单和直观。 Quartz还提供了日志记录功能，您可以使用它来记录定时任务执行过程中的错误和异常信息。通过配置日志记录器，您可以将错误和异常信息输出到日志文件中，以便后续查看和分析。您可以根据需要调整日志级别，以便详细记录或只记录特定级别的信息。 总结来说，Quartz是一个强大且易于使用的Java定时器框架，提供了可视化管理界面和错误/异常信息的记录和查看功能。您可以在项目中使用Quartz来实现各种定时任务需求，并方便地监控和管理这些任务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值