使用spring整合Quartz实现—定时器功能

使用spring整合Quartz实现—定时器(Maven项目做演示)

不基于特定的基类的方法

一,开发环境以及依赖的jar包

    Spring 4.2.6.RELEASE

    Maven 3.3.9

    Jdk 1.7

    Idea 15.04

二,不可少的jar依赖(添加在maven项目里面的pom.xml文件里面)

 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
 <version>4.2.6.RELEASE</version>
 </dependency>
 <dependency>
 <groupId>org.quartz-scheduler</groupId>
 <artifactId>quartz</artifactId>
 <version>2.2.1</version>
 </dependency>

三,实现定时器时使用到的文件:

     planWorkExcute.java    --定时器执行的类

     spring-plan.xml    --配置定时器信息的xml

四,实现定时器步骤:

   1,创建 planWorkExcute.java文件  ,在   cc.royao.plantask   包下。      

package cc.royao.plantask;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.apache.log4j.Logger;//可以删除
import org.springframework.beans.factory.annotation.Autowired;
public class PlanWorkExecute {
 Logger logger = Logger.getLogger(this.getClass());//logger打印日志,可以去掉
 /**
 * 定时器执行的方法
 */
 public synchronized void withdrawNoAuditTask() {
 SimpleDateFormat outFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
 System.out.println("开始提现免审核任务-------------------------------" + outFormat.format(new Date()));
 logger.info("开始提现免审核任务-------------------------------");
 System.out.println("结束提现免审核任务-------------------------------" + outFormat.format(new Date()));
 logger.info("结束提现免审核任务-------------------------------");
 }
}

  2,创建spring-plan.xml  配置文件  注:创建一个定时器的配置文件就行,如果需要多个定时器,直接在spring-plan.xml添加 bean和定义定时器类的方法就行,不需要创建多个xml,

      · 关于那个定时器多久执行的   Cron表达式 可以参考://www.jb51.net/article/138900.htm

      ·有在线生成表达式的网址:http://cron.qqe2.com/

<?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-2.5.xsd"
default-lazy-init="false">
<bean id="job1" class="cc.royao.plantask.PlanWorkExecute" /><!-- 修改为你的定时类的路径 -->
<!-- 可以创建多个定时bean -->
<bean id="jobDetail_1"
 class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
 <property name="targetObject">
 <ref bean="job1" />
 </property>
 <property name="targetMethod">
 <value>withdrawNoAuditTask</value><!-- 定时器类的方法名-->
 </property>
</bean>
<bean id="cronTrigger_1"
 class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
 <property name="jobDetail">
 <ref bean="jobDetail_1" /> <!-- 这里对应上面bean-->
 </property>
 <property name="cronExpression">
 <value>0/2 * * * * ?</value><!-- 0 10 0 * * ? 每天0:10执行 -->
 </property>
</bean>
<bean
 class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
 <property name="triggers">
 <list>
 <ref local="cronTrigger_1" /> <!-- 每加一个定时器这里也要加-->
 </list>
 </property>
</bean>
</beans>

  3,需要在  applicationContext.xml 中引入  spring-plan.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:jee="http://www.springframework.org/schema/jee"
 xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop" xmlns:mvc="http://www.springframework.org/schema/mvc"
 xmlns:cache="http://www.springframework.org/schema/cache"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.2.xsd"
 default-lazy-init="true">
 <!-- 加载系统properties文件配置 -->
 <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
 <property name="locations">
  <list>
  <value>WEB-INF/jdbc.properties</value>
  <!-- <value>WEB-INF/sms.properties</value> -->
  </list>
 </property>
 </bean>
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
 <property name="driverClassName">
  <value>${jdbc.driverClass}</value>
 </property>
 <!--<property name="defaultAutoCommit" value="false"/>-->
 <property name="url">
  <value>jdbc:mysql://192.168.14.239:3306/test?useUnicode=true&characterEncoding=utf-8</value>
 </property>
 <property name="username">
  <value>${jdbc.username}</value>
 </property>
 <property name="password">
  <value>${jdbc.password}</value>
 </property>
 <property name="maxActive">
  <value>20</value>
 </property>
 <property name="maxIdle">
  <value>60</value>
 </property>
 <property name="maxWait">
  <value>20000</value>
  <!-- 0 -->
 </property>
 <property name="removeAbandoned">
  <value>true</value>
 </property>
 <property name="removeAbandonedTimeout">
  <value>6000000</value>
  <!-- 180 -->
 </property>
 <!-- add -->
 <property name="validationQuery" value="SELECT 1"></property>
 <property name="testWhileIdle" value="true"></property>
 <property name="testOnBorrow" value="true"></property>
 <property name="timeBetweenEvictionRunsMillis" value="3600000"></property>
 <property name="numTestsPerEvictionRun" value="50"></property>
 <property name="minEvictableIdleTimeMillis" value="120000"></property>
 <!-- add -->
 </bean>
 <!-- SqlSessionFactory -->
 <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
 <property name="dataSource" ref="dataSource"/>
 </bean>
 <bean id="threadPoolTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
 <property name="corePoolSize" value="1"/>
 <property name="maxPoolSize" value="10"/>
 <property name="keepAliveSeconds" value="300"/>
 <property name="queueCapacity" value="50"/>
 <property name="WaitForTasksToCompleteOnShutdown" value="true"/>
 </bean>
 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <property name="dataSource" ref="dataSource"></property>
 </bean>
 <!--<!– 自动扫描service实现 –>-->
 <!--<context:component-scan base-package="com.royao">-->
 <!--<context:include-filter type="regex"-->
 <!--expression="com.royao.services.*" />-->
 <!--</context:component-scan>-->
 <aop:config proxy-target-class="true">
 <aop:pointcut id="serviceOperation" expression="execution(* cc.royao.mana.auth.service.*.impl.*ServiceImpl.*(..))"/>
 <aop:advisor pointcut-ref="serviceOperation" advice-ref="txAdvice"/>
 </aop:config>
 <!-- 配置事务通知 -->
 <tx:advice id="txAdvice" transaction-manager="transactionManager">
 <tx:attributes>
  <tx:method name="*" rollback-for="Exception"/>
 </tx:attributes>
 </tx:advice>
 <tx:advice id="transactionManagerAdivice" transaction-manager="transactionManager">
 <tx:attributes>
  <tx:method name="*insert*" propagation="REQUIRED"/>
  <tx:method name="*add*" propagation="REQUIRED"/>
  <tx:method name="*update*" propagation="REQUIRED"/>
  <tx:method name="*Update*" propagation="REQUIRED"/>
  <tx:method name="*del*" propagation="REQUIRED"/>
  <tx:method name="*create*" propagation="REQUIRED"/>
  <tx:method name="doApproved" propagation="REQUIRED"/>
  <tx:method name="batchDelFm" propagation="REQUIRED"/>
  <tx:method name="editTemplate" propagation="REQUIRED"/>
  <tx:method name="dummyDelete" propagation="REQUIRED"/>
  <tx:method name="batchDelUser" propagation="REQUIRED"/>
  <!--<tx:method name="*" propagation="REQUIRED"/>-->
 </tx:attributes>
 </tx:advice>
 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
 <property name="basePackage">
  <value>cc.royao.mana.auth.mapper.*</value>
 </property>
 <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
 </bean>
 <import resource="application-servlet.xml"/>
  <!-- 重点在这里 ,我把整个xml文件内容复制出来,怕你们不知道插入在哪里-->
 <import resource="spring-plan.xml"/>
</beans>

总结

以上所述是小编给大家介绍的使用spring整合Quartz实现—定时器功能,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对我们网站的支持!

(0)

相关推荐

  • SpringBoot定时任务两种(Spring Schedule 与 Quartz 整合 )实现方法

    前言 最近在项目中使用到定时任务,之前一直都是使用Quartz 来实现,最近看Spring 基础发现其实Spring 提供 Spring Schedule 可以帮助我们实现简单的定时任务功能. 下面说一下两种方式在Spring Boot 项目中的使用. Spring Schedule 实现定时任务 Spring Schedule 实现定时任务有两种方式 1. 使用XML配置定时任务, 2. 使用 @Scheduled 注解. 因为是Spring Boot 项目 可能尽量避免使用XML配置的形式,

  • spring boot整合quartz实现多个定时任务的方法

    最近收到了很多封邮件,都是想知道spring boot整合quartz如何实现多个定时任务的,由于本人生产上并没有使用到多个定时任务,这里给个实现的思路. 1.新建两个定时任务,如下: public class ScheduledJob implements Job{ @Override public void execute(JobExecutionContext context) throws JobExecutionException { System.out.println("sched

  • Spring整合Quartz实现动态定时器的示例代码

    一.版本说明 spring3.1以下的版本必须使用quartz1.x系列,3.1以上的版本才支持quartz 2.x,不然会出错. 原因:spring对于quartz的支持实现,org.springframework.scheduling.quartz.CronTriggerBean继承了org.quartz.CronTrigger,在quartz1.x系列中org.quartz.CronTrigger是个类,而在quartz2.x系列中org.quartz.CronTrigger变成了接口,从

  • 在Java的Spring框架中配置Quartz的教程

    Spring中配置Quartz的过程: 1.导入JAR包 quartz需要的JAR包,已经包含在spring中,位置在spring解压后目录的 \lib\quartz 下的quartz-all-1.6.1.jar, 将其拷贝到工程 的 WEB-INF/lib 下就行了. 2.配置web.xml,让spring启动时加载quartz的配置文件 <?xml version="1.0" encoding="UTF-8"?> <web-app versio

  • 详解Spring整合Quartz实现动态定时任务

    最近项目中需要用到定时任务的功能,虽然spring 也自带了一个轻量级的定时任务实现,但感觉不够灵活,功能也不够强大.在考虑之后,决定整合更为专业的Quartz来实现定时任务功能. 普通定时任务 首先,当然是添加依赖的jar文件,我的项目是maven管理的,以下的我项目的依赖: <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring

  • 使用spring整合Quartz实现—定时器功能

    使用spring整合Quartz实现-定时器(Maven项目做演示) 不基于特定的基类的方法 一,开发环境以及依赖的jar包 Spring 4.2.6.RELEASE Maven 3.3.9 Jdk 1.7 Idea 15.04 二,不可少的jar依赖(添加在maven项目里面的pom.xml文件里面) <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context

  • Spring整合Quartz Job以及Spring Task的实现方法

    Spring中常用的定时任务的主要有两种 1.Spring整合Quartz Job 2.Spring 3.0以后自带的Task 一.两种定时任务的实现方式 Quartz job 1.首先编写任务类 package com.yjf.job; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * @author yjf */ public class ExampleJob { private static final Logge

  • spring整合Quartz框架过程详解

    这篇文章主要介绍了spring整合Quartz框架过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1.Quartz框架简介 Quartz是一个完全由Java编写的开源任务调度的框架,通过触发器设置作业定时运行规则,控制作业的运行时间.其中quartz集群通过故障切换和负载平衡的功能,能给调度器带来高可用性和伸缩性.主要用来执行定时任务,如:定时发送信息.定时生成报表等等. Quartz框架的主要特点: · 强大的调度功能,例如丰富多样的

  • Spring整合Quartz实现定时任务调度的方法

    最近项目中需要实现定时执行任务,比如定时计算会员的积分.调用第三方接口等,由于项目采用spring框架,所以这里结合spring框架来介绍. 编写作业类 即普通的pojo,如下: package com.pcmall.task; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class TaskA { private static Logger logger = LoggerFactory.getLogger(Ta

  • Spring整合Quartz分布式调度的示例代码

    前言 为了保证应用的高可用和高并发性,一般都会部署多个节点:对于定时任务,如果每个节点都执行自己的定时任务,一方面耗费了系统资源, 另一方面有些任务多次执行,可能引发应用逻辑问题,所以需要一个分布式的调度系统,来协调每个节点执行定时任务. Spring整合Quartz Quartz是一个成熟的任务调度系统,Spring对Quartz做了兼容,方便开发,下面看看具体如何整合: 1.Maven依赖文件 <dependencies> <dependency> <groupId>

  • Spring整合Quartz开发代码实例

    我们使用Spring整合Quartz开发,本实例采用数据库模式的demo. 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

  • Spring整合quartz做定时任务的示例代码

    今天我们来分享一波在spring项目使用quartz做定时任务. 首先我这里的项目已经是一个可以跑起来的完整项目,web.xml里面的配置我就不贴出来了. 1.新建一个类ConfigConsts 我们用来放cron表达式: ​​更多cron表达式​​ package com.aowang.quartz; public abstract class ConfigConsts { /** 30分钟执行一次 */ public static final String quartzInterval =

  • Java中Spring使用Quartz任务调度定时器

    Quartz 任务调度是什么 Quartz 是 OpenSymphony 开源组织在 Job scheduling 领域又一个开源项目,它可以与 J2EE 与 J2SE 应用程序相结合也可以单独使用.Quartz 是一个完全由 Java 编写的开源作业调度框架.不要让作业调度这个术语吓着你.尽管Quartz框架整合了许多额外功能,但就其简易形式看,你会发现它易用得简直让人受不了! 其实,他还是没有解释明白,我简单说一下:Quartz 作业调度就是可以实现定时任务.它可以实现类似 Windows

随机推荐