精华内容
下载资源
问答
  • Quartz-计时器框架

    2019-10-18 16:51:04
    明白Quartz怎么用,首先要了解==Scheduler(调度)、Job(任务)和Trigger(触发器)==这3个核心的概念。 1.Scheduler: 代表一个Quartz的独立运行容器, Trigger和JobDetail可以注册到Scheduler中, 两者在Scheduler中...

    Quartz体系结构:

    明白Quartz怎么用,首先要了解==Scheduler(调度器)、Job(任务)和Trigger(触发器)==这3个核心的概念。

    1.Scheduler:

    代表一个Quartz的独立运行容器, Trigger和JobDetail可以注册到Scheduler中, 两者在Scheduler中拥有各自的组及名称, 组及名称是Scheduler查找定位容器中某一对象的依据, Trigger的组及名称必须唯一, JobDetail的组和名称也必须唯一(但可以和Trigger的组和名称相同,因为它们是不同类型的)。Scheduler定义了多个接口方法, 允许外部通过组及名称访问和控制容器中Trigger和JobDetail。
    Scheduler可以将Trigger绑定到某一JobDetail中, 这样当Trigger触发时, 对应的Job就被执行。一个Job可以对应多个Trigger, 但一个Trigger只能对应一个Job。可以通过SchedulerFactory创建一个Scheduler实例。Scheduler拥有一个SchedulerContext,它类似于ServletContext,保存着Scheduler上下文信息,Job和Trigger都可以访问SchedulerContext内的信息。SchedulerContext内部通过一个Map,以键值对的方式维护这些上下文数据,SchedulerContext为保存和获取数据提供了多个put()和getXxx()的方法。可以通过Scheduler# getContext()获取对应的SchedulerContext实例;

    2.Job:

    是一个接口,只定义一个方法execute(JobExecutionContext context),在实现接口的execute方法中编写所需要定时执行的Job(任务), JobExecutionContext类提供了调度应用的一些信息。Job运行时的信息保存在JobDataMap实例中;

    3. JobDetail:

    Quartz每次调度Job时, 都重新创建一个Job实例, 所以它不直接接受一个Job的实例,相反它接收一个Job实现类(JobDetail:描述Job的实现类及其它相关的静态信息,如Job名字、描述、关联监听器等信息),以便运行时通过newInstance()的反射机制实例化Job。

    4. Trigger:

    Trigger是一个类,描述触发Job执行的时间触发规则。主要有SimpleTrigger和CronTrigger这两个子类。当且仅当需调度一次或者以固定时间间隔周期执行调度,SimpleTrigger是最适合的选择;而CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度方案:如工作日周一到周五的15:00~16:00执行调度等;
    Cron表达式的格式:秒 分 时 日 月 周 年(可选)。
    在这里插入图片描述

    “?”字符:表示不确定的值
    “,”字符:指定数个值
    “-”字符:指定一个值的范围
    “/”字符:指定一个值的增加幅度。n/m表示从n开始,每次增加m
    “L”字符:用在日表示一个月中的最后一天,用在周表示该月最后一个星期X
    “W”字符:指定离给定日期最近的工作日(周一到周五)
    “#”字符:表示该月第几个周X。6#3表示该月第3个周五

    Cron表达式范例:
            每隔5秒执行一次:*/5 * * * * ?
            每隔1分钟执行一次:0 */1 * * * ?
            每天23点执行一次:0 0 23 * * ?
            每天凌晨1点执行一次:0 0 1 * * ?
            每月1号凌晨1点执行一次:0 0 1 1 * ?
            每月最后一天23点执行一次:0 0 23 L * ?
            每周星期六凌晨1点实行一次:0 0 1 ? * L
            在26分、29分、33分执行一次:0 26,29,33 * * * ?
            每天的0点、13点、18点、21点都执行一次:0 0 0,13,18,21 * * ?

    5. Calendar:

    org.quartz.Calendar和java.util.Calendar不同, 它是一些日历特定时间点的集合(可以简单地将org.quartz.Calendar看作java.util.Calendar的集合——java.util.Calendar代表一个日历时间点,无特殊说明后面的Calendar即指org.quartz.Calendar)。 一个Trigger可以和多个Calendar关联, 以便排除或包含某些时间点。
    假设,我们安排每周星期一早上10:00执行任务,但是如果碰到法定的节日,任务则不执行,这时就需要在Trigger触发机制的基础上使用Calendar进行定点排除。针对不同时间段类型,Quartz在org.quartz.impl.calendar包下提供了若干个Calendar的实现类,如AnnualCalendar、MonthlyCalendar、WeeklyCalendar分别针对每年、每月和每周进行定义;

    下图描述了Scheduler的内部组件结构,SchedulerContext提供Scheduler全局可见的上下文信息,每一个任务都对应一个JobDataMap,虚线表达的JobDataMap表示对应有状态的任务:
    在这里插入图片描述

    展开全文
  • Quartz2.2.1+Spring+MYSQL实现任务倒计时和任务持久

    前言:quartz 的资料以及数据库配置可以在http://blog.csdn.net/qq_30097433/article/details/60964968 中下载,如果你根据文档进行操作时,请先看这篇文章。
    本文demo下载:http://pan.baidu.com/s/1jIp2xwi
    防止被爬虫转载原文为:http://blog.csdn.net/qq_30097433/article/details/61201540
    1.创建maven项目:quartz
    2.引入相应的maven依赖

    <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>2.2.1</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>4.3.1.RELEASE</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>4.3.2.RELEASE</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>4.3.1.RELEASE</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>4.3.1.RELEASE</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-context-support -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>4.3.1.RELEASE</version>
            </dependency>
    
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>4.3.1.RELEASE</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>4.3.1.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>1.7.12</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>1.7.12</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>jstl</artifactId>
                <version>1.2</version>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>dom4j</groupId>
                <artifactId>dom4j</artifactId>
                <version>1.6.1</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-core</artifactId>
                <version>2.5.3</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>2.5.3</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.40</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
            <dependency>
                <groupId>c3p0</groupId>
                <artifactId>c3p0</artifactId>
                <version>0.9.1.2</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-core</artifactId>
                <version>2.5.3</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>2.5.3</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
            <dependency>
                <groupId>commons-beanutils</groupId>
                <artifactId>commons-beanutils</artifactId>
                <version>1.9.2</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/commons-collections/commons-collections -->
            <dependency>
                <groupId>commons-collections</groupId>
                <artifactId>commons-collections</artifactId>
                <version>3.2.2</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/commons-lang/commons-lang -->
            <dependency>
                <groupId>commons-lang</groupId>
                <artifactId>commons-lang</artifactId>
                <version>2.6</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
            <dependency>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
                <version>1.2</version>
            </dependency>
            <!--https://mvnrepository.com/artifact/net.sf.json-lib/json-lib -->
            <dependency>
                <groupId>net.sf.json-lib</groupId>
                <artifactId>json-lib</artifactId>
                <version>2.4</version>
            </dependency>
            <!--https://mvnrepository.com/artifact/commons-io/commons-io -->
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>2.5</version>
            </dependency>

    3.项目结构如下:
    这里写图片描述

    核心的配置文件如下:

    config.properties

    quartz.driverClassName=com.mysql.jdbc.Driver
    quartz.url=jdbc:mysql://localhost:3306/quartzdb?useUnicode=true&useSSL=false  
    quartz.username=root
    quartz.password=123456
    quartz.minPoolSize=7
    quartz.initialPoolSize=12 

    applicationContext.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" xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
                            http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/aop 
                            http://www.springframework.org/schema/aop/spring-aop.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.xsd">
        <!-- 配置扫描包 -->
        <context:component-scan base-package="com.test" />
        <!-- 启用注解 -->
        <context:annotation-config />
        <!-- 加载配置文件 -->
        <context:property-placeholder location="classpath:config.properties"
            ignore-unresolvable="true" />
    
    
        <!-- 配置quartz 数据源 -->
        <bean id="quartzDataSource"
            class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName" value="${quartz.driverClassName}" />
            <property name="url" value="${quartz.url}" />
            <property name="username" value="${quartz.username}" />
            <property name="password" value="${quartz.password}" />
        </bean>
    
        <!-- quartz持久化存储 -->
        <bean name="quartzScheduler"
            class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
            <property name="dataSource">
                <ref bean="quartzDataSource" />
            </property>
            <property name="applicationContextSchedulerContextKey" value="applicationContext" />
            <property name="quartzProperties">
                <props>
                    <prop key="org.quartz.scheduler.instanceName">CRMscheduler</prop>
                    <prop key="org.quartz.scheduler.instanceId">AUTO</prop>
                    <!-- 线程池配置 -->
                    <prop key="org.quartz.threadPool.class">org.quartz.simpl.SimpleThreadPool</prop>
                    <prop key="org.quartz.threadPool.threadCount">20</prop>
                    <prop key="org.quartz.threadPool.threadPriority">5</prop>
                    <prop key="org.quartz.jobStore.misfireThreshold">120000</prop>
                    <!-- JobStore 配置 -->
                    <prop key="org.quartz.jobStore.class">org.quartz.impl.jdbcjobstore.JobStoreTX</prop>
                    <!-- 集群配置 -->
                    <prop key="org.quartz.jobStore.isClustered">true</prop>
                    <prop key="org.quartz.jobStore.clusterCheckinInterval">15000</prop>
                    <prop key="org.quartz.jobStore.maxMisfiresToHandleAtATime">1</prop>
                    <!-- 数据表设置 -->
                    <prop key="org.quartz.jobStore.tablePrefix">qrtz_</prop>
                    <prop key="org.quartz.jobStore.dataSource">qzDS</prop>
                </props>
            </property>
        </bean>
    
    
    </beans>

    MyJob.java

    package com.test.util.quartz;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    import org.apache.log4j.Logger;
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    /**
     * 任务实现
     * @author Administrator
     */
    public class MyJob implements Job{  
        private static final Logger logger = Logger.getLogger(MyJob.class);    
        @Override  
        public void execute(JobExecutionContext context)  
                throws JobExecutionException {  
            System.out.println("Hello quzrtz  "+   new SimpleDateFormat("yyyy-MM-dd HH:mm:ss ").format(new Date()));  
    
        }  
    
    }

    QuartzTest.java

    package com.test.util.quartz;
    
    import java.util.Date;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import org.quartz.Job;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.JobKey;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.SimpleScheduleBuilder;
    import org.quartz.SimpleTrigger;
    import org.quartz.Trigger;
    import org.quartz.TriggerBuilder;
    import org.quartz.TriggerKey;
    import org.quartz.core.jmx.JobDetailSupport;
    import org.quartz.impl.StdSchedulerFactory;
    import org.quartz.impl.triggers.SimpleTriggerImpl;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    @Component
    public class QuartzTest {
        @Autowired
        private Scheduler scheduler;
        private static String JOB_GROUP_NAME = "ddlib";
        private static String TRIGGER_GROUP_NAME = "ddlibTrigger";
    
        /**
         * 添加任务
         * 
         * @param jobName
         *            任务名称
         * @param job
         *            任务处理类 需要继承Job
         * @param context
         *            处理任务可以获取的上下文
         *            通过context.getMergedJobDataMap().getString("context"); 获取
         * @param seconds
         *            间隔秒
         * @return 0 添加成功 1:任务已经存在 2:添加异常
         */
        public int addJob(String jobName, Class<? extends Job> job, Object task, int seconds, String jobGorupName) {
            try {
                // 判断任务是否存在
                JobKey jobKey = JobKey.jobKey(jobName, jobGorupName);
                if (scheduler.checkExists(jobKey)) {
                    return 1;// 任务已经存在
                }
                // 创建一个JobDetail实例,指定SimpleJob
                Map<String, Object> JobDetailmap = new HashMap<String, Object>();
                JobDetailmap.put("name", jobName);// 设置任务名字
                JobDetailmap.put("group", jobGorupName);// 设置任务组
                JobDetailmap.put("jobClass", job.getCanonicalName());// 指定执行类
                                                                        // Task.class.getCanonicalName()
                JobDetail jobDetail = JobDetailSupport.newJobDetail(JobDetailmap);
                // 添加数据内容
                jobDetail.getJobDataMap().put("task", task);// 传输的上下文
                // 通过SimpleTrigger定义调度规则:马上启动,每2秒运行一次,共运行100次 等。。。。
                SimpleTriggerImpl simpleTrigger = new SimpleTriggerImpl();
                simpleTrigger.setName(jobName);
                simpleTrigger.setGroup(TRIGGER_GROUP_NAME);
                // 什么时候开始执行
                simpleTrigger.setStartTime(new Date(new Date().getTime() + 1000 * seconds));
                // 间隔时间
                simpleTrigger.setRepeatInterval(1000 * seconds);
                // 最多执行次数 默认执行一次
                simpleTrigger.setRepeatCount(0);
                // 通过SchedulerFactory获取一个调度器实例
                scheduler.scheduleJob(jobDetail, simpleTrigger);//  注册并进行调度
                scheduler.start();// ⑤调度启动
                return 0;// 添加成功
            } catch (Exception e) {
                // e.printStackTrace();
                return 2;// 操作异常
            }
        }
    
        /**
         * 关闭任务调度
         * 
         * @param jobName
         *            任务名称
         * @return 0 关闭成功 1: 关闭失败 2:操作异常
         */
        public int closeJob(String jobName, String jobGorupName) {
            // 关闭任务调度
            try {
                JobKey jobKey = JobKey.jobKey(jobName, jobGorupName);
                return scheduler.deleteJob(jobKey) == true ? 0 : 1;
            } catch (SchedulerException e) {
                // e.printStackTrace();
                return 2;
            }
        }
    
        /**
         * 从数据库中找到已经存在的job,并重新开户调度
         */
        public void resumeJob() {
            try {
                scheduler.start();
            } catch (SchedulerException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    TestController.java

    package com.test.controller;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.test.util.quartz.MyJob;
    import com.test.util.quartz.QuartzTest;
    
    /**
     * 
     * @author niewei
     *
     */
    @RestController
    public class TestController {
        @Autowired
        QuartzTest q;
        //添加一个倒计时任务
        @RequestMapping("add")
        public Object add(String name) {
            return q.addJob(name, MyJob.class, "我是你的人", 20, "001");
        }
        //删除一个倒计时任务
        @RequestMapping("remove")
        public Object remove(String name) {
            return q.closeJob(name, "001");
        }
        //从数据库加载还未执行的任务(spring容器初始化的时候会自动加载)
        @RequestMapping("resume")
        public Object resume(String name) {
            q.resumeJob();
            return "OK";
        }
    }

    以上编写好启动无误后就可以测试了。访问controller的增删即可调试

    展开全文
  • java Web 计时器

    2021-03-16 01:17:13
    我用jsp+servlet+mysql搞...那么,如何设计一个计时器,在规定时间将触发,去更改相应的数据库表呢?Spring+quartz 做定时任务楼上提到java.util.Timer如果要使用,题主需要注意这种情况public class BadCaseOfTimer...

    我用

    jsp+servlet+mysql

    搞了一个众筹网站。当一个项目发起后,它有一个众筹时间,过了这个时间,项目就会从众筹状态转到另一个状态,当然,这需要在数据库中去操作。那么,如何设计一个计时器,在规定时间将触发,去更改相应的数据库表呢?

    Spring+quartz 做定时任务

    楼上提到

    java.util.Timer

    如果要使用,题主需要注意这种情况

    public class BadCaseOfTimer {

    public static void main(String[] args) {

    Timer timer = new Timer();

    timer.schedule(new ThrowTask(),1);

    timer.schedule(new ThrowTask(),1);

    }

    static class ThrowTask extends TimerTask{

    @Override

    public void run() {

    System.out.println("runnin.."+System.currentTimeMillis());

    throw new RuntimeException();

    }

    }

    }

    可以用java.util.Timer类的schedule方法

    有一个问题

    时间到了以后,从一个状态转到另一个状态,除了改变这个字段的值以外,还有其它需要触发进行的操作么?

    如果没有,很可能你不需要一个定时任务。

    只需要在数据库中记录项目发起时间和期限,在需要判断状态的时候根据这两个值和当前时间,决定项目的状态。

    类似于你的网站里记录用户的生日信息,在页面显示用户年龄。我想没有人会真的在数据库保存年龄然后每天刷新的。

    展开全文
  • commons-beanutils.ja、commons-collections.jar、commons-logging.jar、commons-digester.jar、quartz.jar包 第二步:在web.xml下配置监听 在web.xml下配置监听的目的是为了项目编译的时候就自动运行监听下配置的...

    第一步:下载所需的Jar包
    commons-beanutils.ja、commons-collections.jar、commons-logging.jar、commons-digester.jar、quartz.jar包
    第二步:在web.xml下配置监听
    在web.xml下配置监听的目的是为了项目编译的时候就自动运行监听下配置的业务类。

    <!--监听(作用就是启动项目的时候就会运行这个类,这个类需要实现ServletContextListener接口)-->
    <listener>     
           <listener-class>     
                com.qt.quartz.QuartzMain   
           </listener-class>     
    </listener>

    第三步:编写com.qt.quartz.QuartzMain类
    这个类只是作为启动类,调用QuartzLoad类的2个方法,因为这个类是静态的,所以可以用名称直接点出方法名称。

    package com.qt.quartz;
    import javax.servlet.ServletContextEvent;
    import javax.servlet.ServletContextListener;
    public class QuartzMain implements ServletContextListener {
        // 服务器启动时执行该事件
        @Override
        public void contextInitialized(ServletContextEvent arg0) {
            try {
                QuartzLoad.run();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        // 服务器停止时执行该事件
        @Override
        public void contextDestroyed(ServletContextEvent arg0) {
            try {
                QuartzLoad.stop();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    }

    第四步:编写com.qt.quartz.QuartzLoad类
    这个类里面有2个方法,一个是启动quartz的方法,一个是关闭方法,这个类里面可以定制每隔多少时间循环调用业务类一次。

    package com.qt.quartz;
    import org.quartz.CronTrigger;
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.impl.StdSchedulerFactory;
    
    public class QuartzLoad {
        private static Scheduler sched; 
        public static void run() throws Exception { 
            //创建LzstoneTimeTask的定时任务 
    //三个参数,第一个是自己取得名称、第二个是固定的、第三个是业务类
            JobDetail jobDetail = new JobDetail("lzstoneJob",sched.DEFAULT_GROUP,QuartzJob.class); 
     //三个参数,第一个是自己取得名称、第二个是触发器组名称、第三个是自定义时间
            CronTrigger trigger = new CronTrigger("lzstoneTrigger","lzstone","0/50 * * * * ?");  
            sched = new StdSchedulerFactory().getScheduler();  
            sched.scheduleJob(jobDetail,trigger);  
            sched.start();
        }
        //停止  
        public static void stop() throws Exception{  
               sched.shutdown();  
         }  
    }
    

    序号 说明 是否必填 允许填写的值 允许的通配符
    1 秒 是 0-59 , - * /
    2 分 是 0-59 , - * /
    3 小时 是 0-23 , - * /
    4 日 是 1-31 , - * ? / L W
    5 月 是 1-12 or JAN-DEC , - * /
    6 周 是 1-7 or SUN-SAT , - * ? / L #
    7 年 否 empty 或 1970-2099 , - * /

    第五步:编写QuartzJob.class类,自己的业务处理类

    package com.qt.quartz;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    
    public class QuartzJob implements Job{
        @Override
        public void execute(JobExecutionContext arg0) throws JobExecutionException {
             // TODO Auto-generated method stub
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS"); 
             System.out.println("时间表:"+sdf.format(new Date())); 
        }
    }
    展开全文
  • Java定时器 quartz jar包

    2017-11-02 17:41:17
    Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个,百个,甚至是好几万个Jobs这样复杂的程序。Jobs可以做成...
  • idea 使用spring自带的定时器quartz 使用的c3p0 v0.95.2所包含的jar 亲测可用
  • 最近在写一个导入工具时用到了一个新的东西Quartz 计时器 ,timer有的Quartz 基本都有,所以用Quartz 来写了下代码,并记录。 1、首先需要引用GuGet程序包,搜索' quartz' ,下载安装到程序。 2、直接上代码,创建...
  • quartz定时器

    千次阅读 2019-06-27 09:51:18
    一、关于 Quartz Quartz 是一个完全由 Java 编写的开源作业调度框架,为在 Java 应用程序中进行作业调度提供了简单却强大的机制。 Quartz 可以与 J2EE 与 J2SE 应用程序相结合也可以单独使用。 ...
  • Quartz定时器使用

    2020-09-23 16:30:04
    调度 Scheduler: 搭配 Trigger和Job 1.创建一个job类,用作要定时执行的方法: package quartz; import java.text.SimpleDateFormat; import java.util.Date; import org.quartz.DisallowConcurrentExecution...
  • 深入解读Quartz的原理

    2021-03-08 19:38:52
    Quartz是一个大名鼎鼎的Java版开源定时调度,功能强悍,使用方便。一、核心概念Quartz的原理不是很复杂,只要搞明白几个概念,然后知道如何去启动和关闭一个调度程序即可。1、Job表示一个工作,要执行的具体内容。...
  • quartz定时器的使用

    2020-03-04 21:29:12
    quartz定时器的使用一、quartz的介绍二、quartz的使用2.1 第一步:添加spring和quartz相关依赖2.2 第二步:创建任务类2.3 第三步:在spring配置文件中配置任务类2.4 第四步:在spring配置文件中配置JobDetail2.5 第...
  • 今天带来一个基于SpringBoot2.x整合Quartz定时器,也相当于给自己做个笔记。 项目优点:灵活插拔,接口编程,功能全面,MVC模式,方便管理 Quartz简介: Quartz是OpenSymphony开源组织在Job scheduling领域又一个...
  • spring和quartz的定时器的启动和停止例子
  • C#简易计时器WPF

    2021-12-21 16:31:10
    原文链接: C#简易计时器WPF 上一篇: ...
  • Quartz

    2020-06-30 16:02:33
    Quartz是要做定时任务的调度,设置好触发时间规则,以及相应的任务(Job)即可。 二、使用 1、导入依赖 <dependencies> <dependency> <groupId>org.quartz-scheduler</groupId> <...
  •  //注意,在此计时器调用的计时器任务的 run 方法内调用此方法,就可以绝对确保正在执行的任务是此计时器所执行的最后一个任务。  timer.cancel();  } } web.xml配置    org.lzstone....
  • 定时器跟闹钟的功能类似,可以定义一个时间来运行一段程序,比如实时的数据检测 或者是网上各种网站视频会员都是用计时器来提醒用户。 常见的定时器有 java.util包提供的Timer定时器 和 第三方提供的quzrtz定时器 ...
  • 在使用Timer类需要面对的问题:计时器没有持久化机制;计时器具有不灵活的计划(仅能设置开始时间和重复间隔,没有基于日期,时间等);计时器不使用线程池(每个定时器一个线程);计时器没有真正的管理方案 – 你...
  • ASP.NET中的三种Timer(计时器)的区别和用法卡卡 发表于 2014/12/5 13:02:00 | 分类标签: Timer 计时器 ASP.NET NET中有3个不同的定时器。这3个定时器分别是: 1.实现按用户定义的时间间隔引发事件的计时器。此计时...
  •  Quartz是基于Spring框架之上的更加强大的定时器,它不仅可以轻松的实现前面两种定时器的功能,还实现了非常繁复的时间触发执行的任务,Quartz有两种方式来调度定时任务, 一是使用Spring提供的  ...
  • 简单 Quartz定时器使用 入门Quartz...任务调度框架“Quartz”是OpenSymphony开源组织在Job scheduling领域又一个开源项目,是完全由java开发的一个开源的任务日程管理系统,“任务进度管理”就是一个在预先确定(...
  • Quartz.Net任务调度

    2018-08-13 15:53:26
    我相信在实际项目中经常会用到计时器控件,在这里我用了一个开源库Quartz.Net,直接运行即可!
  • (4)Quartz之调度 (1)调度:任务的实际执行者,负责粘合任务和触发器。 (2)通过JobDetail创建一个任务实例。 (3)使用SimpleTrigger创建一个触发器。 (4)创建一个调度。 具体的触发器和调度如以下代码 ...
  • quartz

    2021-03-17 15:13:57
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JXSiW1WU-1615965216146)(Pictures/Quartz_Logo_large.jpg)] Author:Exchanges Version:9.0.2 文章目录一、引言1.1 简介二、Quartz使用...
  • quartz定时器表达式详解

    千次阅读 2019-06-03 15:00:41
    一、结构  corn从左到右(用空格隔开):秒 分 小时 月份中的日期 月份 星期中的日期 年份  二、各字段的含义 字段 允许值 允许的特殊字符 秒(Seconds) 0~59的整数 , - * / 四个字符 ...
  • QuartzQuartz Enterprise Job Scheduler 是一个定时任务调度框架。比如你遇到这样的问题: 想在30分钟后,查看订单是否支付,未支付则取消订单 想在每月29号,信用卡自动还款 ... 想定时在...
  • QuartzQuartz Enterprise Job Scheduler 是一个定时任务调度框架。比如你遇到这样的问题: 想在30分钟后,查看订单是否支付,未支付则取消订单 想在每月29号,信用卡自动还款 ... 想定时在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,615
精华内容 646
关键字:

计时器quartz