spring4 + quartz2初探

最新推荐文章于 2020-06-01 15:25:41 发布
最新推荐文章于 2020-06-01 15:25:41 发布
阅读量1.7k 收藏 1
点赞数 1
分类专栏： java 文章标签： spring quartz java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jtbrian/article/details/53966793
版权

1.准备工作，构建一个maven web工程
pom.xml如下：

<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.test.quartz</groupId>
    <artifactId>test-quartz</artifactId>
    <version>0.0.1</version>
    <packaging>jar</packaging>

    <name>test-quartz</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>  
            <groupId>com.alibaba</groupId>  
            <artifactId>druid</artifactId>  
            <version>1.0.27</version>  
        </dependency>  
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.7.2</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.7</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.8</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.1</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
            <type>jar</type>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>
        <!-- Transaction dependency is required with Quartz integration -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>4.3.5.RELEASE</version>
        </dependency>

        <!-- Quartz framework -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.3</version>
        </dependency>   
        <dependency>  
            <groupId>mysql</groupId>  
            <artifactId>mysql-connector-java</artifactId>  
            <version>5.1.40</version>  
        </dependency>  
    </dependencies>

    <build>
        <finalName>shaketv-game-quartz</finalName>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

有了工程之后还得有个有数据库，数据库的sql文件可以到官网下载
地址：http://www.quartz-scheduler.org/downloads/
解压后找到docs/dbTables,里面有各种数据库的sql文件，我这里选的是mysql

2.定义一个Job Model

public class ScheduleJob implements Serializable{
    private static final long serialVersionUID = 1L;
    private String jobId;
    private String jobName;
    private String jobGroup;
    private String jobStatus;
    private String cronExpression;
    private Date startTime;
    private String desc;
    private Object data;
    //set get .....
}

3.建一个Job 

import java.util.Date;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

//这里注解的意思是 任务是否可以并发 加上注解表示不可以并发
@DisallowConcurrentExecution
public class MyJob implements Job{

    @Override
    public void execute(JobExecutionContext context)
            throws JobExecutionException {
        //在任务里 可以通过getJobDataMap()传自己需要用的一些数据
        JobDataMap jdm = context.getJobDetail().getJobDataMap();
        //TODO
        System.out.println(jdm.get("data"));
        System.out.println("strat" + (new Date().getTime()));
    }

}

4.定义一个管理任务的类，里面包括增、删、改、查、暂停、恢复等方法
注：一般任务里使用的trigger有两种SimpleTrigger 和CronTrigger 

import java.util.List;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
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.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.matchers.GroupMatcher;
import org.quartz.impl.triggers.SimpleTriggerImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class JobService {
    static ApplicationContext context = new ClassPathXmlApplicationContext(
            "spring-main.xml");
    static Scheduler scheduler = (Scheduler) context.getBean("scheduler");

    /**
     * 添加或修改任务
     * @param job
     * @param jobClass
     * @throws SchedulerException
     */
    public static void addOrUpdateJob(ScheduleJob job, Class<? extends Job> jobClass)
            throws SchedulerException {
        TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(),job.getJobGroup());
        // 获取trigger
        //CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        SimpleTriggerImpl  trigger =  (SimpleTriggerImpl) scheduler.getTrigger(triggerKey);
        // 不存在，创建一个
        if (null == trigger) {
            System.out.println("new");
            JobDetail jobDetail = JobBuilder.newJob(jobClass)
                    .withIdentity(job.getJobName(), job.getJobGroup()).build();

            jobDetail.getJobDataMap().put("data", job.getData());
            // 表达式调度构建器
//          CronScheduleBuilder scheduleBuilder = CronScheduleBuilder
//                  .cronSchedule(job.getCronExpression());
            // 按新的cronExpression表达式构建一个新的trigger
//          trigger = TriggerBuilder.newTrigger()
//                  .withIdentity(job.getJobName(), job.getJobGroup())
//                  .withSchedule(scheduleBuilder).build();
            ScheduleBuilder<?> schedBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(R.TIME_INTERVAL).withRepeatCount(-1);
            trigger = (SimpleTriggerImpl) TriggerBuilder.newTrigger()
            .withIdentity(job.getJobName(), job.getJobGroup()).startAt(job.getStartTime()).withSchedule(schedBuilder).build();
            scheduler.scheduleJob(jobDetail, trigger);

        } else {
            System.out.println("reset");
            // Trigger已存在，那么更新相应的定时设置
            // 表达式调度构建器
//          CronScheduleBuilder scheduleBuilder = CronScheduleBuilder
//                  .cronSchedule(job.getCronExpression());
            // 按新的cronExpression表达式重新构建trigger
//          trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
//                  .withSchedule(scheduleBuilder).build();
            ScheduleBuilder<?> schedBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(R.TIME_INTERVAL).withRepeatCount(-1);
            trigger = (SimpleTriggerImpl) TriggerBuilder.newTrigger()
                    .withIdentity(job.getJobName(), job.getJobGroup()).startAt(job.getStartTime()).withSchedule(schedBuilder).build();

            // 按新的trigger重新设置job执行
            JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
            scheduler.getJobDetail(jobKey).getJobDataMap().put("data", job.getData());
            scheduler.rescheduleJob(triggerKey, trigger);


        }
    }

    /**
     * 暂停任务
     * @param job
     * @throws SchedulerException
     */
    public static void pauseJob(ScheduleJob job) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
        scheduler.pauseJob(jobKey);
    }

    /**
     * 恢复单个任务 
     * @param job
     * @throws SchedulerException
     */
    public static void recoveryJob(ScheduleJob job) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
        scheduler.resumeJob(jobKey);
    }

    /**
     * 全部恢复
     * @param job
     * @throws SchedulerException
     */
    public static void resumeAll() throws SchedulerException{
        scheduler.resumeAll();
    }

    /**
     * 查询任务信息
     * @throws SchedulerException
     */
    public static void queryJob() throws SchedulerException {
        for (String groupName : scheduler.getJobGroupNames()) {
            for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {
                String jobName = jobKey.getName();
                String jobGroup = jobKey.getGroup();
                List<Trigger> triggers = (List<Trigger>) scheduler.getTriggersOfJob(jobKey);
                Trigger trigger = triggers.get(0);
                System.out.println("[jobName] : " + jobName 
                        + " [groupName] : "+ jobGroup 
                        + " [nextFireTime]: " + trigger.getNextFireTime()
                        );
            }
        }
    }

    /**
     * 删除任务
     * @param job
     * @throws SchedulerException
     */
    public static void delelteJob(ScheduleJob job) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
        scheduler.deleteJob(jobKey);
    }

        /**
     * 同时删除任务和定时器
     * @param job
     * @throws SchedulerException
     */
    public static void delelteJobAndTrigger(ScheduleJob job) throws SchedulerException {
         JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
         TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(),job.getJobGroup());
         scheduler.pauseTrigger(triggerKey);
         scheduler.unscheduleJob(triggerKey);
         scheduler.deleteJob(jobKey);
    }
    /**
     * 立即执行
     * @param job
     * @throws SchedulerException
     */
    public static void triggerNow(ScheduleJob job) throws SchedulerException{
        JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
        scheduler.triggerJob(jobKey);
    }


    /**
     * 立即执行
     * @param job
     * @throws SchedulerException
     */
    public static void triggerNow(ScheduleJob job,JobDataMap data) throws SchedulerException{
        JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
        scheduler.triggerJob(jobKey,data);
    }
}

5.spring配置：spring-main.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:p="http://www.springframework.org/schema/p"  
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:task="http://www.springframework.org/schema/task"  
    xsi:schemaLocation="  
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd  
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd  
            http://www.springframework.org/schema/context  
            http://www.springframework.org/schema/context/spring-context-4.0.xsd  
            http://www.springframework.org/schema/task  
            http://www.springframework.org/schema/task/spring-task-4.0.xsd">  

    <context:annotation-config />  

    <bean id="DataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">  
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />  
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/quartz" />  
        <property name="username" value="root" />  
        <property name="password" value="12345678" />  
        <!-- 连接池最大使用连接数量 -->  
        <property name="maxActive" value="100" />  
        <!-- 初始化大小 -->  
        <property name="initialSize" value="10" />  
        <!-- 获取连接最大等待时间 -->  
        <property name="maxWait" value="60000" />  
        <!-- 连接池最小空闲 -->  
        <property name="minIdle" value="5" />  
        <!-- 逐出连接的检测时间间隔 -->  
        <property name="timeBetweenEvictionRunsMillis" value="3000" />  
        <!-- 最小逐出时间 -->  
        <property name="minEvictableIdleTimeMillis" value="300000" />  
        <!-- 测试有效用的SQL Query -->  
        <property name="validationQuery" value="SELECT 'x'" />  
        <!-- 连接空闲时测试是否有效 -->  
        <property name="testWhileIdle" value="true" />  
        <!-- 获取连接时测试是否有效 -->  
        <property name="testOnBorrow" value="false" />  
        <!-- 归还连接时是否测试有效 -->  
        <property name="testOnReturn" value="false" />  
    </bean>  

    <!-- 声明工厂 -->  
    <bean id="scheduler" autowire="no" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
        <property name="dataSource" ref="DataSource" />  
        <property name="configLocation" value="classpath:quartz.properties" />  
        <!--applicationContextSchedulerContextKey：   
        是org.springframework.scheduling.quartz.SchedulerFactoryBean这个类中  
       把spring上下 文以key/value的方式存放在了quartz的上下文中了，  
        可以用applicationContextSchedulerContextKey所定义的key得到对应的spring上下文-->    
        <property name="applicationContextSchedulerContextKey" value="applicationContextKey"/>       
    </bean>  
</beans>

6.quartz配置 quartz.properties

org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX #job存储方式
org.quartz.jobStore.misfireThreshold = 60000 #超时时间

org.quartz.scheduler.instanceName = DefaultQuartzScheduler  
org.quartz.scheduler.rmi.export = false  
org.quartz.scheduler.rmi.proxy = false  
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false  

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool  
org.quartz.threadPool.threadCount = 10  #线程数量
org.quartz.threadPool.threadPriority = 5  #优先线程数量
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

##orgorg.quartz.jobStore.class = org.quartz.simpl.RAMJobStore  
#orgorg.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX  
#orgorg.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.HSQLDBDelegate  
#orgorg.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate  
#org.quartz.jobStore.useProperties = false  
#org.quartz.jobStore.tablePrefix = QRTZ_   
#org.quartz.jobStore.isClustered = false   
#org.quartz.jobStore.maxMisfiresToHandleAtATime=1

更多的配置文件信息可以进官网查看：
http://www.quartz-scheduler.org/documentation/quartz-2.2.x/configuration/

7.最后就可以写一个测试类进行测试了 

import org.quartz.SchedulerException;
public class Test {

    public static void getJobDataFromQueue(){
        ScheduleJob job = new ScheduleJob();
        job.setJobId("10001" );
        job.setJobName("test1");
        job.setJobGroup("test-group");
        //时间可以自己设置
        job.setStartTime(new Date());
        job.setData("这里是传入job的数据");

        try {
            JobService.addOrUpdateJob(job, MyJob.class);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        getJobDataFromQueue();
    }
}

测试时遇到的问题：
1.在测试过程中循环建了1000个任务，然后同时执行，发现有漏掉任务，这个可以通过调整线程数量（org.quartz.threadPool.threadCount）和超时时间（org.quartz.jobStore.misfireThreshold）来解决

2.SimpleTrigger和CronTrigger之间不能互转，开始建了一个任务使用的是CronTrigger，任务信息保存到数据库中，然后下次启动服务的时候想修改成SimpleTrigger，会报错，这种情况只能先删除该任务，然后重建。

3.不能创建已过期的任务，比如现在是2017-1-1 14:30:00,不能创建这个时间之前的任务

4.时间间隔这种CronTrigger不能很好的处理，使用SimpleTrigger，比如从现在开始隔90分钟执行一次，CronTrigger没法实现

jtbrian
关注
专栏目录
activity工作流初探及疑问（一）
小小开发者
10-10 1103
写在前面：一直想学习activity工作流，实现一些流程审批功能，今天终于着手开始，在接下来的博客中，会讲解整合步骤及我之后的疑问，也希望路过的大神能指点一下，我会把大神的指点去验证，并将大佬ID及验证结果写在下一篇博客中。 项目架构：jdk1.8+springboot+springcloud+springsecurity+mybatisplus+redis+activity+jwt+mysql 因为是希望在我自己写的demo项目中来学习并集成，所以用到了这些技术,本系列文章将只针对activity来写
SpringBoot
最新发布
Healerjy的博客
05-18 387
学过javaweb的同学就知道，开发一个web应用，从最初开始接触Servlet结合Tomcat，跑出一个Hello Wolrld程序，是要经历特别多的步骤；后来就用了框架Struts，再后来是SpringMVC，到了现在的SpringBoot，过一两年又会有其他web框架出现；不知道你有没经历过框架不断的演进，然后自己开发项目所有的技术也在不断的变化、改造。
Spring4集成quartz2.2.1
04-20
Spring4集成quartz2.2.1，可打包成可执行jar或者war。
Spring定时任务，Spring4整合quartz2.2，quartz-scheduler定时任务
weixin_34072637的博客
07-05 275
Spring4整合quartz2.2，quartz-scheduler定时任务，Spring定时任务   &gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&
Spring4 Quartz2 动态任务，Spring4整合quartz2.2.3简单动态任务
weixin_34221036的博客
09-06 127
 Spring4 Quartz2 动态任务 Spring4整合quartz2.2.3简单动态任务， Quartz2.2.3简单动态定时任务二， SimpleScheduleBuilder简单定时任务   &gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&a
spring4+quartz2基本配置及应用
guoningyan_nihao的专栏
09-20 494
spring4+quartz2基本配置及应用 1、新建maven工程，添加spring4.0及quartz2.2依赖，pom.xml文件内容如下 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=
Spring4实战（二）-Quartz 2.2 集成
wozhengtao的博客
08-14 463
前面一篇文章介绍了 Quartz的简单用法，Spring提供了一些类来简化Quartz的使用。本篇文章将介绍如何在Spring中集成Quartz。 涉及的开发工具与技术 Spring 4.2.4.RELEASE Quartz 2.2.2 Maven 3 JDK 1.7 Eclipse JUNO Project目录结构 Eclipse Maven Project最终目录结构如下：  ...
Spring Boot 初探 | 第一篇：第一个Spring Boot程序(示例程序)
01-15
**Spring Boot 初探：构建你的第一个应用** Spring Boot 是由 Pivotal 团队提供的全新框架，旨在简化 Spring 应用程序的初始搭建以及开发过程。它集成了大量常用的第三方库配置，如 JDBC、MongoDB、JPA、RabbitMQ、...
开源框架 Spring Gossip
07-16
第一个 Spring 程式 BeanFactory、 ApplicationContext Type 2 IoC、Type 3 IoC 属性参考 自动绑定 集合物件注入 Bean 的生命周期 Bean 进阶管理 理想上对于 Bean 来说，它不...
记录SpringBoot学习之旅
qq_41385887的博客
06-01 2017
文章目录SpringBoot感谢秦老师 指路: [秦老师](https://www.bilibili.com/video/BV1PE411i7CV)什么是SpringSpring是如何简化Java开发的什么 SpringBoot微服务什么是微服务?单体应用架构微服务架构如何构建微服务第一个SpringBoot程序自动装配原理初探pom.xml启动器:主程序注解@Conditional扩展注解结论:SpringApplicationspringboot启动流程关于springboot,谈谈你的理解Spring
Spring-Quartz
04-22
NULL 博文链接：https://z18022893621.iteye.com/blog/1950079
Spring 3整合Quartz 2实现定时任务一：常规整合
iteye_19426的博客
02-04 126
http://www.meiriyouke.net/?p=82 最近工作中需要用到定时任务的功能，虽然Spring3也自带了一个轻量级的定时任务实现，但感觉不够灵活，功能也不够强大。在考虑之后，决定整合更为专业的Quartz来实现定时任务功能。 首先，当然是添加依赖的jar文件，我的项目是maven管理的，以下的我项目的依赖： org.spri...
Spring4+quartz2的配置和代码方式调度
Try My Best 尽力而为
04-23 188
前言：这些天简直被quartz虐哭。。因为quartz 2.x版本相比quartz1.x版本的API改动太多，所以，只好自己去查阅底层API……   quartz定时任务必须搞清楚几个概念： JobDetail——处理类 Trigger——触发器，指定触发时间，必须要有JobDetail属性，即触发对象 Scheduler——调度器，组织处理类和触发器，配置方式一般只需指定触发器（因...
Spring quartz
zhongyangjian的专栏
07-27 206
本文摘自http://www.blogjava.net/mikechen/archive/2012/07/03/382090.html 由于本人看到这篇文章很多帮助，欣喜之下，转之，希望更多人看到，谢谢作者！   一：quartz简介       OpenSymphony 的Quartz提供了一个比较完美的任务调度解决方案。        Quartz 是个开源的作业调度框架，定时调度...
Spring中Quartz的配置实例
VirgooooS
10-13 123
Quartz是一个强大的企业级任务调度框架，Spring中继承并简化了Quartz，下面就看看在Spring中怎样配置Quartz： 首先我们来写一个被调度的类： [code="java"]package com.kay.quartz; public class QuartzJob { public void work() { System.out.pr...
Quartz入门实例12-Spring4和quartz2的集群
胡小海丶
08-04 9933
使用spring4.0.6 和 quartz 2.2.1 整合进行集群
spring4与quartz2.2集群配置
冷雨夜@leon
09-18 2913
1.引入quartz2.2的maven依赖 <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.2.3</version> </dependency> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz-jobs</artifactId>
Spring4 + Quartz-2.2.0集成实例
总有刁民害寡人
12-01 843
一、准备对应JAR包 quartz-2.2.2.jar 二、编写MyJob类package com.fh.quartz;import java.util.Date;public class MyJob { public void work() { System.out.println("date:" + new Date().toString()); }
Quartz在Spring中集群
曾文锋开发日志
10-12 231
概述虽然单个Quartz实例能给予你很好的Job调度能力，但它不能满足典型的企业需求，如可伸缩性、高可靠性满足。假如你需要故障转移的能力并能运行日益增多的 Job，Quartz集群势必成为你应用的一部分了。使用 Quartz 的集群能力可以更好的支持你的业务需求，并且即使是其中一台机器在最糟的时间崩溃了也能确保所有的 Job 得到执行。Quartz 中集群如何工作一个 Quartz 集群中的每个...
使用Spring+Quartz实现分布式定时任务
"该文章主要探讨了如何在Spring框架中结合Quartz实现分布式定时任务，以解决在集群环境中定时任务重复执行的问题。文章首先介绍了公司早期在单服务器和集群环境下的定时任务处理方式，然后指出了现有伪分布式方案的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值