精华内容
参与话题
问答
  • 现在的web项目中很多场景下都有要执行定时任务的需求,比如说每隔5秒将redis中的统计当天注册用户数持久化到数据库。现在项目中实现这一功能,一般用quartz这一工具框架,但是这个对于一个新手来说比较麻烦,各种查...

    人工智能,零基础入门!http://www.captainbed.net/inner

    现在的web项目中很多场景下都有要执行定时任务的需求,比如说每隔5秒将redis中的统计当天注册用户数持久化到数据库。现在项目中实现这一功能,一般用quartz这一工具框架,但是这个对于一个新手来说比较麻烦,各种查资料配置之类的。后面我接触到一种比较方便快速实现job任务的方法,总结下来:

    一、项目文件结构

    【1】pom.xml依赖文件,加入HuTool工具类依赖。

    【2】JobTest类为定时任务执行目标方法类;

    【3】resources/config/cron.setting为定时规则配置;

    【4】InitConfig类为初始化配置类;


    二、添加依赖

    导入HuTool这个国产工具类包,这里含有很多工具类,CronUtil是其中的一个用来做定时任务的工具类,里面还有很多其他很方便的工具类可以自己去研究,官方文档:https://www.hutool.cn/

    <dependency>
       <groupId>cn.hutool</groupId>
       <artifactId>hutool-all</artifactId>
       <version>4.2.1</version>
    </dependency>

    三、编写目标方法和制定定时规则

    【1】目标方法就是要被定时执行的方法,示例如下【方法体自定义】:


    【2】使用 CronUtil ,需要在 src/main/resources/config 下放入 cron.setting 文件(默认是这个路径的这个文件),然后在文件中放入定时规则,如:

    [com.qunawan.home.job]
    JobTest.doJob = 0/5 0/1 * * * ? *

    这表示:每隔 5秒钟执行一遍 com.qunawan.home.job 包下的 JobTest 类中的 doJob 方法。

    对于定时任务的cron表达式不太会写的同学,可以参考这篇博客:https://blog.csdn.net/qq_35860138/article/details/82738215


    四、初始化

    在SpringBoot项目中,加一个初始化配置类,让定时器在项目启动就打开,下面是配置类代码:

    @Component
    public class InitConfig {
    
        private static final Logger log = LoggerFactory.getLogger(InitConfig.class);
    
        @PostConstruct
        public void initTimer() {
            log.info("项目启动,开启定时任务……");
            CronUtil.setMatchSecond(true);
            CronUtil.start();
        }
    }

    这样就会每隔 5 秒中去执行一下目标方法。代码中的 setMatchSecond(true) 是设置支持秒级别定时任务,这么做是为了兼容 Quartz 表达式,5位表达式、6位表达式都兼容。


     

    展开全文
  • Spring整合Quartz 实现定时job任务

    千次阅读 2017-07-12 20:56:42
    接触定时轮循任务也有半年了,也不太常用,就记录下来做个备注,今天重新搭建的环境,一步步从头来,又发现几点新东西。实现定时轮循的 方式有两种,一种是用:MethodInvokingJobDetailFactoryBean,两一种是用:...

    接触定时轮循任务也有半年了,也不太常用,就记录下来做个备注,今天重新搭建的环境,一步步从头来,又发现几点新东西。实现定时轮循的方式有两种,一种是用:MethodInvokingJobDetailFactoryBean,两一种是用:JobDetailBean.这里就对着两种的使用情况进行具体应用。最后给上二者的区别点。

    环境:maven3.0+spring4.0.+quartz1.8.5+jdk1.7

    本例的目录结构先给上供参考:

    这里写图片描述

    1.搭建maven项目后,引入pom.xm对项目的支持。这里需要引入的spring jar包有这三个,缺一不可。spring-context-support,spring-web,spring-tx。

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>com.zhanglf.cn</groupId>
        <artifactId>springQuarztDemo</artifactId>
        <packaging>war</packaging>
        <version>0.0.1-SNAPSHOT</version>
        <name>springQuarztDemo Maven Webapp</name>
        <url>http://maven.apache.org</url>
    
        <properties>
            <spring.version>4.0.2.RELEASE</spring.version>
        </properties>
        <dependencies>
            <!--引入定时任务quartz依赖 -->
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>1.8.5</version>
            </dependency>
    
            <!-- Spring-context的扩展支持,用于MVC方面 -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${spring.version}</version>
            </dependency>
        </dependencies>
        <build>
            <finalName>springQuarztDemo</finalName>
        </build>
    </project>
    

    2.引入定时任务的配置quartz-job.xml.这里配置了上述的两种方式的job任务。也便于区分二者配置上的不同点。本项目配置不多,加上web.xml上有一些引入spring容器用来注入和加载我们的quartz-job.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:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
     http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context-4.1.xsd">
    
        <!-- 扫包,注入service层 -->
        <context:component-scan base-package="com.zhanglf" />
    
        <!--*******************@第一种job********************** -->
        <!-- 我定义了一个对象和它对象的方法,如果我们需要把它封装成一个job,就把类名和对应的方法穿进去就行了,这里用name或者id来唯一标志一个bean都是可以的。 -->
        <bean name="printJob" class="com.zhanglf.quartz.MethodInvokingJobDetileFactoryBeanPrintJob"></bean>
        <!-- 第一种定时轮循的方法是用 MethodInvokingJobDetileFactoryBean。这种是最简单的 -->
        <bean name="autoPrintJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
            <property name="targetObject">
                <ref bean="printJob" /><!-- 指定自定义类 -->
            </property>
            <property name="targetMethod">
                <value>sayHello</value><!-- 指定方法名 -->
            </property>
            <!-- 配置是否阻塞线程,即一个一个的调用,还是不等第一个完成就可以执行第二个,false表示阻塞执行。多个job不会并发执行,第二个不会再第一个job完成前执行 ,第二种方式没有这种配置-->
            <property name="concurrent" value="false" />
        </bean>
    
        <!-- 定时触发器 -->
        <bean id="autoPrintJobCronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
            <property name="jobDetail">
                <ref bean="autoPrintJob" />
            </property>
            <property name="cronExpression">
                <value>0/20 * * * * ?</value><!-- 每20秒执行一次 -->
            </property>
        </bean>
        <!--*******************@第一种job********************** 自定义任务类,这里就做个打印吧 -->
    
        <!-- 第二种定时轮循的方法是用 JobDetileBean。这种不用单独声明自定义类了。直接在属性中赋值为对应类,然后就会走默认的实现方法executeInternal。 -->
        <bean name="autoShowJob" class="org.springframework.scheduling.quartz.JobDetailBean">
            <property name="jobClass">
                <value>com.zhanglf.quartz.JobDetileBeanPrintJob</value><!-- 指定自定义类 -->
            </property>
            <property name="jobDataAsMap">
                <map>
                    <entry key="showService" value-ref="showService" /><!-- 如果需要其他层的注入,则在这里进行注入配,然后给上set方法完成注入。 -->
                </map>
            </property>
            <!-- 使用JobDetailBean不支持这种并发操作 -->
            <!-- <property name="concurrent" value="false"/> -->
        </bean>
    
        <!-- 定时触发器 -->
        <bean id="autoShowJobCronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
            <property name="jobDetail">
                <ref bean="autoShowJob" />
            </property>
            <property name="cronExpression">
                <value>0/20 * * * * ?</value><!-- 每20秒执行一次 -->
            </property>
        </bean>
        <!-- 第二种定时轮循的方法是用 JobDetileBean。这种不用单独声明自定义类了。直接在属性中赋值为对应类,然后就会走默认的实现方法executeInternal。 -->
    
    
        <!-- 任务调度器 -->
        <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
            <property name="triggers">
                <list>
                    <ref bean="autoPrintJobCronTrigger" />
                    <ref bean="autoShowJobCronTrigger" />
                </list>
            </property>
        </bean>
    
    </beans>
    

    3.在web.xml中引入配置和引入spring容器。

    <?xml version="1.0" encoding="UTF-8"?>  
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xmlns="http://java.sun.com/xml/ns/javaee"  
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  
        version="3.0">  
        <display-name>Archetype Created Web Application</display-name>  
        <!-- Spring和mybatis的配置文件 -->  
        <context-param>  
            <param-name>contextConfigLocation</param-name>  
            <param-value>classpath:/MATE-INF/quartz/quartz-job.xml</param-value>  
        </context-param>
    
        <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
    </web-app>
    

    4.quartz/JobDetileBeanPrintJob.java 和MethodInvokingJobDetileFactoryBeanPrintJob.java类

    package com.zhanglf.quartz;
    
    import javax.annotation.Resource;
    
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.springframework.scheduling.quartz.QuartzJobBean;
    import org.springframework.stereotype.Component;
    
    import com.zhanglf.service.IShowService;
    @Component
    public class JobDetileBeanPrintJob extends QuartzJobBean {
        //这里的注入只能是set方法注入好使,使用註解不行!这也是和MethodInvokingJobDetileFactoryBean的区别之一。
    //  @Resource(name=IShowService.SERVICEID)
        private IShowService showService;
    
        public void setShowService(IShowService showService) {
            this.showService = showService;
        }
    
        @Override
        protected void executeInternal(JobExecutionContext context)
                throws JobExecutionException {
            show();
        }
    
        public void show(){
            showService.print("JobDetileBeanPrintJob");
        }
    
    }
    
    package com.zhanglf.quartz;
    
    import javax.annotation.Resource;
    
    import org.springframework.stereotype.Component;
    
    import com.zhanglf.service.IShowService;
    
    @Component
    public class MethodInvokingJobDetileFactoryBeanPrintJob {
    
        @Resource(name=IShowService.SERVICEID)
        private IShowService showService;
    
        public void sayHello(){
            showService.print("MethodInvokingJobDetileFactoryBeanPrintJob");
        }
    }
    



    为了结合spring的注入,我们引入了service层来说明二者的区别:MethodInvokingJobDetileFactoryBeanPrintJob不会影响spring对各层的bean管理,通过注解方式即可完成注入,但是JobDetileBeanPrintJob会影响spring对继承了这个类的spring注入。@Resource注解在JobDetileBeanPrintJob类中起不到bean注入的作用,而只能用set方法来注入。


    5.service/IShowService.java接口和其实现类ShowServiceImpl.java

    package com.zhanglf.service;
    
    public interface IShowService {
        final String SERVICEID="showService";
        public void print(String name);
    }
    
    package com.zhanglf.service;
    
    import org.springframework.stereotype.Service;
    
    @Service(IShowService.SERVICEID)
    public class ShowServiceImpl implements IShowService{
        public void print(String name){
            System.out.println("你好  "+name);
        }
    }
    

    这就搭建完成了。启动项目,可以看到控制台每个20秒打印出的结果。

    这里写图片描述

    总结:
    1.定时轮循的任务实现方式有两种:MethodInvokinJobDetailFactoryBean 简称为@M, JobDetailBean 简称为@J.简称有利于我后面的总结。其中第一种@M这种简单易操作。建议使用这种方式的定时任务。

    2.在配置文件中@M的配置分为四步:
    a. 自定义任务类声明-给上id/name来唯一标识,便后面配置引用。
    b.将自定义类封装称job–把对应的自定义id和方法名传入即可。
    c.将封装成的job引入定时触发器。
    d.将触发器加入调度器进行调度任务。

    @J的配置分为三步,省略了@M的第一步。二者主要区别在封装称job这里,三四步是相同的。
    a.将自定义类封装称job–对应的类路径+类名(调用的方法是固定的,就是@J的实现方法executeInternal)和自定义类中需要注入的别的层的类的实例(比如本例的private IShowService showService;)。
    b.将封装成的job引入定时触发器。
    c.将触发器加入调度器进行调度任务。

    3.由于结合了spring容器管理。所以需要加入扫描注解的配置和在web.xml中加入spring容器的监听器,以便web容器初始化就会初始化spring容器。

    4.重点注意@J的自定义job任务类:JobDetileBeanPrintJob是要继承 QuartzJobBean 类,重写父类的executeInternal方法,则调度器就会调用这个方法。
    如果方法要使用别的层的方法,则注入的方式只能是set方法,注解不好使,这个父类影响了spring的注入方式。:

    //  @Resource(name=IShowService.SERVICEID)
    private IShowService showService;
        public void setShowService(IShowService showService) {
            this.showService = showService;
        }

    @M的自定义任务类是不用继承,实现任何别的类。就是纯净的自定义类,自定义的无参方法。然后依据你在job的配置文件里指定调用那个方法,就会走那个方法。且不影响spring的注入。

    5.注意这里的job调用的方法均为无参的方法。

    展开全文
  • 【xxl-job】spring*定时任务

    千次阅读 热门讨论 2018-05-30 10:06:07
    【前言】 还记得当前湖畔的xxl-job与elastic-job 当然这篇只是个人的看法,对应xxl-job还是比较推荐的,昨天也终于注册并且写了一个jobHandler(算是一个任务吧)下面就写一下记录一下【正文】 先搬来官网镇一下...

    【前言】

        还记得当前湖畔的xxl-job与elastic-job 当然这篇只是个人的看法,对应xxl-job还是比较推荐的,昨天也终于注册并且写了一个jobHandler(算是一个任务吧)下面就写一下记录一下,再说一下为什么是标题是spring*呐,以为这个代码spring、springboot(估计springcloud也在)内都是可以使用的,可能配置的形式不一样、核心相同

    【正文】

       先搬来官网镇一下本blog,这个使用文档写的特别详细所以就有些长,但是长度还是不足以衬托他的深度,雪里大神真是厉害,而且也很有耐心,进入正文

        首先下载代码,官网中有地址点击去直接下载就可以了,下载下来的结构,突然发现原来自己也是在抄官网,不过是截取片段


    就使用来说最关键的是找准配置文件中的xxl.job.admin.addresses

        官网说将admin打包放到tomcat下,开始我感觉这样挺麻烦的,直接用idea起来项目,结果嘞这个addresses就几个月前误打误撞对了一次,这次试了几次之后还是逃脱不了失败的命运,索性放到tomcat下吧,复制一份tomcat、改改端口号,打好的jar放进入、启动、浏览器输入网址:完美

        spring例子中配置文件中address改成浏览器刚才输入的网址,修改xxl.job.executor.appname、ip空着、port貌似空的会报错最好写个端口吧,启动,在


    添加任务管理器,AppName是刚才修改的appname,写好名称方便区分,选择自动注册(前提ip是空)保存,等会OnLine机器这一列应该就会多一个值,这样便可以轻易添加任务了


    具体的模式、corn还是自行搜索吧,这些任务新建之后也是可以更该的,所以灵活性一下子就上去了吐舌头


    怎么样执行自己的java代码呐?其实也是很简单的,嗯~还是上官网的图片吧:

     - 1、继承"IJobHandler":“com.xxl.job.core.handler.IJobHandler”;
     - 2、注册到Spring容器:添加“@Component”注解,被Spring容器扫描为Bean实例;
     - 3、注册到执行器工厂:添加“@JobHandler(value="自定义jobhandler名称")”注解,注解value值对应的是调度中心新建任务的JobHandler属性的值。
     - 4、执行日志:需要通过 "XxlJobLogger.log" 打印执行日志;
    (可参考Sample示例执行器中的DemoJobHandler,见下图)

    新建任务时运行模式选中 "BEAN模式",JobHandler属性填写任务注解“@JobHandler”中定义的值;

    还是复制一下任务配置属性的说明吧:具体的还是要看官网的

    - 执行器:任务的绑定的执行器,任务触发调度时将会自动发现注册成功的执行器, 实现任务自动发现功能; 另一方面也可以方便的进行任务分组。每个任务必须绑定一个执行器, 可在 "执行器管理" 进行设置;
    - 描述:任务的描述信息,便于任务管理;
    - 路由策略:当执行器集群部署时,提供丰富的路由策略,包括;
        FIRST(第一个):固定选择第一个机器;
        LAST(最后一个):固定选择最后一个机器;
        ROUND(轮询):;
        RANDOM(随机):随机选择在线的机器;
        CONSISTENT_HASH(一致性HASH):每个任务按照Hash算法固定选择某一台机器,且所有任务均匀散列在不同机器上。
        LEAST_FREQUENTLY_USED(最不经常使用):使用频率最低的机器优先被选举;
        LEAST_RECENTLY_USED(最近最久未使用):最久为使用的机器优先被选举;
        FAILOVER(故障转移):按照顺序依次进行心跳检测,第一个心跳检测成功的机器选定为目标执行器并发起调度;
        BUSYOVER(忙碌转移):按照顺序依次进行空闲检测,第一个空闲检测成功的机器选定为目标执行器并发起调度;
        SHARDING_BROADCAST(分片广播):广播触发对应集群中所有机器执行一次任务,同时传递分片参数;可根据分片参数开发分片任务;
    
    - Cron:触发任务执行的Cron表达式;
    - 运行模式:
        BEAN模式:任务以JobHandler方式维护在执行器端;需要结合 "JobHandler" 属性匹配执行器中任务;
        GLUE模式(Java):任务以源码方式维护在调度中心;该模式的任务实际上是一段继承自IJobHandler的Java类代码并 "groovy" 源码方式维护,它在执行器项目中运行,可使用@Resource/@Autowire注入执行器里中的其他服务;
        GLUE模式(Shell):任务以源码方式维护在调度中心;该模式的任务实际上是一段 "shell" 脚本;
        GLUE模式(Python):任务以源码方式维护在调度中心;该模式的任务实际上是一段 "python" 脚本;
        GLUE模式(NodeJS):任务以源码方式维护在调度中心;该模式的任务实际上是一段 "nodejs" 脚本;
    - JobHandler:运行模式为 "BEAN模式" 时生效,对应执行器中新开发的JobHandler类“@JobHandler”注解自定义的value值;
    - 子任务:每个任务都拥有一个唯一的任务ID(任务ID可以从任务列表获取),当本任务执行结束并且执行成功时,将会触发子任务ID所对应的任务的一次主动调度。
    - 阻塞处理策略:调度过于密集执行器来不及处理时的处理策略;
        单机串行(默认):调度请求进入单机执行器后,调度请求进入FIFO队列并以串行方式运行;
        丢弃后续调度:调度请求进入单机执行器后,发现执行器存在运行的调度任务,本次请求将会被丢弃并标记为失败;
        覆盖之前调度:调度请求进入单机执行器后,发现执行器存在运行的调度任务,将会终止运行中的调度任务并清空队列,然后运行本地调度任务;
    - 失败处理策略;调度失败时的处理策略;
        失败告警(默认):调度失败和执行失败时,都将会触发失败报警,默认会发送报警邮件;
        失败重试:调度失败时,除了进行失败告警之外,将会自动重试一次;注意在执行失败时不会重试,而是根据回调返回值判断是否重试;
    - 执行参数:任务执行所需的参数,多个参数时用逗号分隔,任务执行时将会把多个参数转换成数组传入;
    - 报警邮件:任务调度失败时邮件通知的邮箱地址,支持配置多邮箱地址,配置多个邮箱地址时用逗号分隔;
    - 负责人:任务的负责人;

    看、经历数次失败、不是经过不懈努力之后,本宝的任务成功φ(0 ̄*)啦啦啦_φ(* ̄0 ̄)′,有一些遗憾就是admin是放到tomcat中启动的,早晚要放到tomcat里面所以 那就这样吧  ♪(^∇^*)  

    【后语】

        文中大部分图片均来自于官网(除了最后一张),谢谢雪里大神的无私奉献及热心帮助

       雪里大神微博 拥抱开源、乐于分享

    最后上一张xxl-job-admin的主界面吧,大神还是一个很细致滴银


    展开全文
  • Oracle JOB 定时任务

    2011-12-18 14:51:19
    Oracle JOB 定时任务 定时执行存储过程
  • java中定时任务Job的使用总结

    千次阅读 2019-05-27 08:53:54
    Job的原理,参考: http://www.cnblogs.com/Dorae/p/9357180.html job的使用,参考: https://blog.csdn.net/u010996565/article/details/78591054 https://blog.csdn.net/hfut_wowo/article/details/64434664 实例...

    Job的原理,参考:
    http://www.cnblogs.com/Dorae/p/9357180.html

    job的使用,参考:
    https://blog.csdn.net/u010996565/article/details/78591054
    https://blog.csdn.net/hfut_wowo/article/details/64434664

    实例,创建一个job,每天凌晨3点执行:

    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Date;
    
    import javax.annotation.Resource;
    
    import org.quartz.CronScheduleBuilder;
    import org.quartz.CronTrigger;
    import org.quartz.Job;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.quartz.Scheduler;
    import org.quartz.TriggerBuilder;
    import org.quartz.impl.StdSchedulerFactory;
    
    public class SumFinancialJob implements Job
    {
    
    	public SumFinancialJob()
    	{
    	}
    
    	public void execute(JobExecutionContext context) throws JobExecutionException
    	{
    		//得到一个Calendar实例
    		Calendar calendar = Calendar.getInstance();
    		//calendar的日期设为今天
    		calendar.setTime(new Date());
    		//设置calendar为昨天
    		calendar.add(Calendar.DATE, -1);
    		//calendar.add(Calendar.YEAR, -1);//前一年
    		//calendar.add(Calendar.MONTH, -1);//前一月
    
    		Date yesterday = calendar.getTime();
    
    		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		//前一天的字符串
    		String pre = simpleDateFormat.format(yesterday);
    		//前一天凌晨0点的字符串
    		String startTime = pre.substring(0, 10) + " 00:00:00";
    		//前一天午夜24点的字符串
    		String endTime = pre.substring(0, 10) + " 24:00:00";
    
    		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    		//获取前一天的日期字符串
    		String preDate = dateFormat.format(yesterday);
    
    		//获取外部传来的参数
    		//JobDataMap map = context.getJobDetail().getJobDataMap();
    		//String ywbDate = map.getString("ywbDate");
    		进行操作……
    	}
    
    	public static void schedulerJob()
    	{
    		try
    		{
    			// 创建一个jobDetail的实例 quartz 2.xx版本
    			JobDetail jobDetail = JobBuilder.newJob(SumFinancialJob.class).withIdentity("train-financial-Job").build();
    			// 创建一个Trigger触发器的实例,每天凌晨3点运行
    			CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity("train-financial-Trigger").startNow().withSchedule(CronScheduleBuilder.cronSchedule("0 0 3 * * ?")).build();
    			// 创建schedule实例
    			Scheduler scheduler = new StdSchedulerFactory().getScheduler();
    			// 添加一个job
    			scheduler.scheduleJob(jobDetail, trigger);
    			// 开启一个job
    			scheduler.start();
    		}
    		catch (Exception e)
    		{
    			System.err.println("创建定时任务失败" + e);
    		}
    	}
    }
    
    

    job的使用实例参考:

    https://blog.csdn.net/u010996565/article/details/78591054

    package com.qua.test;
     
    import java.util.Date;
     
    import org.quartz.CronTrigger;
    import org.quartz.JobDataMap;
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerFactory;
    import org.quartz.SimpleTrigger;
    import org.quartz.impl.StdSchedulerFactory;
     
    import com.qua.job.PlanJob;
     
    public class Test {
    	public static void main(String[] args) throws Exception {
    		//创建job
    		JobDetail detail=new JobDetail("myJob", "myGroup", PlanJob.class);
    		//向程序内部传入参数
    		JobDataMap map=detail.getJobDataMap();
    		map.put("username", "张三");
    		//这里的触犯器是规定的时间间隔内做的事,不是很常用
    //		//创建触发器
    //		SimpleTrigger trigger=new SimpleTrigger("myTrigger",SimpleTrigger.REPEAT_INDEFINITELY, 3000);
    //		//设置开始执行时间
    //		trigger.setStartTime(new Date(System.currentTimeMillis()+1000));
    		//下面这个是在指定时间做的事,在日常开发中是比较常用的
    		//指定时间
    		CronTrigger trigger=new CronTrigger("myCron", "myGroup", "40 10 11 * * ?");//这里有三个参数(1.触发器的名称2.触发器的组3.时间表达式)
    		
    		//创建调度工厂
    		SchedulerFactory factory=new StdSchedulerFactory();
    		//创建调度器
    		Scheduler scheduler=factory.getScheduler();
    		
    		//绑定job 和触发器
    		scheduler.scheduleJob(detail, trigger);
    		//启动
    		scheduler.start();
    //		//停止定时任务
    //		scheduler.shutdown();
    	}
    }
    
    
    

    Cron表示式示例

    https://blog.csdn.net/zzq900503/article/details/38020573/)

    "0 0 12 * * ? "

    每天12点运行

    “0 15 10 ? * *”

    每天10:15运行

    “0 15 10 * * ?”

    每天10:15运行

    “0 15 10 * * ? *”

    每天10:15运行

    “0 15 10 * * ? 2008”

    在2008年的每天10:15运行

    “0 * 14 * * ?”

    每天14点到15点之间每分钟运行一次,开始于14:00,结束于14:59。

    “0 0/5 14 * * ?”

    每天14点到15点每5分钟运行一次,开始于14:00,结束于14:55。

    “0 0/5 14,18 * * ?”

    每天14点到15点每5分钟运行一次,此外每天18点到19点每5钟也运行一次。

    “0 0-5 14 * * ?”

    每天14:00点到14:05,每分钟运行一次。

    “0 10,44 14 ? 3 WED”

    3月每周三的14:10分到14:44,每分钟运行一次。

    “0 15 10 ? * MON-FRI”

    每周一,二,三,四,五的10:15分运行。

    “0 15 10 15 * ?”

    每月15日10:15分运行。

    “0 15 10 L * ?”

    每月最后一天10:15分运行。

    “0 15 10 ? * 6L”

    每月最后一个星期五10:15分运行。

    “0 15 10 ? * 6L 2007-2009”

    在2007,2008,2009年每个月的最后一个星期五的10:15分运行。

    “0 15 10 ? * 6#3”

    每月第三个星期五的10:15分运行。

    展开全文
  • 第一篇文章中 我们对每个用户创建一个定时任务 如果用户量很大 代价有点颇大 第二篇文章是对第一篇文章做优化 思路: 能否所有用户公用一个定时器 1 创建一个定时器 【把一小时内的数据 查询出来 放入内存中】 2 ...
  • 一、job 定时任务的创建方式 1、使用线程创建 job 定时任务 /** * TODO 使用线程创建 job 定时任务 * @author 王松 * @date 2019/9/14 0014 22:12 */ public class JobThread { public static class Demo01 { ...
  • java实现job功能,定时开启任务

    万次阅读 2014-11-20 17:12:28
    在开发的过程中,有时候需要java实现job功能,定时开启或者每个一段
  • xxl-job定时任务更优雅

    千次阅读 2020-06-01 09:55:00
    一、xxl-job确实一个比较好的定时任务管理软件,我特别喜欢它的界面,而且如果嵌入公司内部项目管理系统也是非常简单,记录下学习路径。 1、xuxueli老师的xxl-job的git地址,下载下来研究,里面主要关注xxl-job-...
  • oracle中的job能为你做的就是在你规定的时间格式里执行存储过程,定时执行一个任务 。下面是一个小案例,定时每15分钟向一张表插入一条数据 一 1.创建一张测试表 -- Create table create table A8 ( a1 ...
  • Java 定时任务JOB

    千次阅读 2019-07-19 10:49:58
    Java 定时任务JOB创建过程 1.创建QuartzManager管理类。 如果需要可根据自身的需要对此类的方法进行重载,以符合自生业务 import org.quartz.CronTrigger; import org.quartz.JobDataMap; import org.quartz....
  • Elastic Job定时任务

    2019-01-02 22:19:51
    Elastic Job分为主要分为Elastic-Job-Lite和Elastic-Job-Cloud两个子项目。其中,Elastic-Job-Lite定位为轻量级无中心化解决方案,使用jar包的形式提供分布式任务的协调服务。...(1)定时任务:基于成熟的定时...
  • Elastic-JOB 定时任务

    千次阅读 2018-01-23 17:22:18
    开发指南 代码开发 作业类型 ...目前提供3种作业类型,分别是Simple, DataFlow和Script。...DataFlow类型用于处理数据流,它又提供2种作业类型,分别是ThroughputDataFlow和SequenceDataFlow。...
  • springboot配置xxl-job定时任务

    千次阅读 2018-10-17 20:03:13
    配置xxl-job定时任务 一、配置xxl-job页面调度器 先下载1.9.2版本xxl-job的源码,地址:https://github.com/xuxueli/xxl-job 下载完,用idea打开,配置jdk1.8、配置maven, 导入MySQL数据库xxl-job的一些表,导入的...
  • XXL-JOB分布式定时任务入门使用

    千次阅读 2019-05-08 14:33:34
    XXL-JOB是一个轻量级分布式任务调度平台,其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线,开箱即用。 1.2 特性 1、简单:支持通过Web页面对任务进行CRUD操作,...
  • 定时任务需要设置运行时间:用于计算下一运行时间的表达式 INTERVAL参数常用值示例 1、每3秒钟执行一次 ‘sysdate+3/(246060)’ 2、每2分钟执行一次 ‘sysdate+2/(24*60)’ 3、每天午夜12点 ‘‘TRUNC(SYSDATE + 1)...
  • job的Interval设置的sysdate+1,Next date 设置的2018-11-26 8:00:00 ...当Interval设置为sysdate+1时,执行完这个定时任务后设置Next date时间加上一天,这样每天的执行都会延迟,延迟越来越长...
  • ORACLE定时执行Job任务

    千次阅读 2018-07-23 12:09:44
    因为是统计周月数据,便想到了数据库定时Job任务创建。 在百度上,找到了一篇好文章,跟大家分享:http://langgufu.iteye.com/blog/1179235 另一篇文章是关于ORACLE时间间隔书写:...
  • Timer ScheduledExecutorService ...XXL-JOB elastic-job 各种对比和比较 https://www.ibm.com/developerworks/cn/java/j-lo-taskschedule/ https://www.cnblogs.com/aishangJava/p/7587020.html ...
  • MySQL job 定时任务

    千次阅读 2018-06-07 11:20:18
    DROP EVENT IF EXISTS JOB_COUNT; CREATE EVENT JOB_COUNT ONSCHEDULE EVERY 10 MINUTE DO BEGIN IF(date_format(current_time(),'%H')=0) THEN CALL CountSkyDDSAuditByDay('skydds_transfer_log_cou...

空空如也

1 2 3 4 5 ... 20
收藏数 45,394
精华内容 18,157
关键字:

job定时任务