- 浏览: 165666 次
- 性别:
- 来自: 长沙
-
文章分类
最新评论
-
单v纯微笑：
您好，能把dbsyn_config_quartz这个表发给我一 ...
定时器（quartz+spring）读取数据库配置 -
fenglingabc：
我用了comet4j 结果因为推送比较频繁（基本上1秒一次）， ...
comet4j轮询 -
NeverGiveUpToChange：
nice,还不错哦，谢谢啦！！！
springmvc上传 -
ralfsqual：
自定义的线程中的逻辑每次都是被执行两次，不知道为什么啊。比如打 ...
comet4j轮询 -
goll2012：
我倒，原来要配置tomcat。。。果然是高手，对于只看不动手的 ...
comet4j轮询
今天把项目中的一部分移出来，主要是实现定时器任务，定时任务是从数据库配置的的，所以采用spring读取数据库配置文件来实现定时器。
需要的JAR包 见上传文件
数据建立 见上传文件
数据库映射类：
package com.quartz;
public class DbsynConfigQuartz {
// Fields
private String triggername;
private String cronexpression;
private String jobdetailname;
private String targetobject;
private String methodname;
private String concurrent;
private String state;
private String readme;
private String isspringbean;
// Constructors
/** default constructor */
public DbsynConfigQuartz() {
}
/** minimal constructor */
public DbsynConfigQuartz(String triggername, String jobdetailname,
String targetobject, String concurrent, String state,String isspringbean) {
this.triggername = triggername;
this.jobdetailname = jobdetailname;
this.targetobject = targetobject;
this.concurrent = concurrent;
this.state = state;
this.isspringbean=isspringbean;
}
/** full constructor */
public DbsynConfigQuartz(String triggername, String cronexpression,
String jobdetailname, String targetobject, String methodname,
String concurrent, String state, String readme,String isspringbean) {
this.triggername = triggername;
this.cronexpression = cronexpression;
this.jobdetailname = jobdetailname;
this.targetobject = targetobject;
this.methodname = methodname;
this.concurrent = concurrent;
this.state = state;
this.readme = readme;
this.isspringbean=isspringbean;
}
// Property accessors
public String getTriggername() {
return this.triggername;
}
public void setTriggername(String triggername) {
this.triggername = triggername;
}
public String getCronexpression() {
return this.cronexpression;
}
public void setCronexpression(String cronexpression) {
this.cronexpression = cronexpression;
}
public String getJobdetailname() {
return this.jobdetailname;
}
public void setJobdetailname(String jobdetailname) {
this.jobdetailname = jobdetailname;
}
public String getTargetobject() {
return this.targetobject;
}
public void setTargetobject(String targetobject) {
this.targetobject = targetobject;
}
public String getMethodname() {
return this.methodname;
}
public void setMethodname(String methodname) {
this.methodname = methodname;
}
public String getConcurrent() {
return this.concurrent;
}
public void setConcurrent(String concurrent) {
this.concurrent = concurrent;
}
public String getState() {
return this.state;
}
public void setState(String state) {
this.state = state;
}
public String getReadme() {
return this.readme;
}
public void setReadme(String readme) {
this.readme = readme;
}
public String getIsspringbean() {
return isspringbean;
}
public void setIsspringbean(String isspringbean) {
this.isspringbean = isspringbean;
}
}
连接数据库公共方法：
package com.util;
import java.io.File;
import java.sql.BatchUpdateException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
public class Connect {
private static int tag1 = 0;
private static Logger log = Logger.getLogger(Connect.class);
private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
/**
* 获得数据连接
*
* @return
*/
public static Connection getCon(String name) {
Connection connection = null;
try {// 保证只进行一次初始化
if (tag1 == 0) {
tag1++;
Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
}
connection = DriverManager.getConnection("proxool." + name);
} catch (Exception e) {
e.printStackTrace();
}
return connection;
}
}
读取定时器触发类：
package com.quartz;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.apache.log4j.Logger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.scheduling.quartz.CronTriggerBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
import com.util.Connect;
public class QuartzManager implements BeanFactoryAware {
private Logger log = Logger.getLogger(QuartzManager.class);
private Scheduler scheduler;
private static BeanFactory beanFactory = null;
// private ApplicationContext apc;
@SuppressWarnings("unused")
private void reScheduleJob() throws Exception, ParseException {
// 通过查询数据库里计划任务来配置计划任务
DbsynConfigQuartz d= new DbsynConfigQuartz();
List<DbsynConfigQuartz> quartzList = this.getConfigQuartz();
if (quartzList != null && quartzList.size() > 0) {
for (DbsynConfigQuartz tbcq : quartzList) {
configQuatrz(tbcq);
}
}
}
public boolean configQuatrz(DbsynConfigQuartz tbcq) {
boolean result = false;
try {
// 运行时可通过动态注入的scheduler得到trigger
CronTriggerBean trigger = (CronTriggerBean) scheduler.getTrigger(
tbcq.getTriggername(), Scheduler.DEFAULT_GROUP);
// 如果计划任务已存在则调用修改方法
if (trigger != null) {
change(tbcq, trigger);
} else {
// 如果计划任务不存在并且数据库里的任务状态为可用时,则创建计划任务
if (tbcq.getState().equals("1")) {
this.createCronTriggerBean(tbcq);
}
}
result = true;
} catch (Exception e) {
result = false;
e.printStackTrace();
}
return result;
}
public void change(DbsynConfigQuartz tbcq, CronTriggerBean trigger)
throws Exception {
// 如果任务为可用
if (tbcq.getState().equals("1")) {
// 判断从DB中取得的任务时间和现在的quartz线程中的任务时间是否相等
// 如果相等，则表示用户并没有重新设定数据库中的任务时间，这种情况不需要重新rescheduleJob
if (!trigger.getCronExpression().equalsIgnoreCase(
tbcq.getCronexpression())) {
trigger.setCronExpression(tbcq.getCronexpression());
scheduler.rescheduleJob(tbcq.getTriggername(),
Scheduler.DEFAULT_GROUP, trigger);
log.info(new Date() + ": 更新" + tbcq.getTriggername() + "计划任务");
}
} else {
// 不可用
scheduler.pauseTrigger(trigger.getName(), trigger.getGroup());// 停止触发器
scheduler.unscheduleJob(trigger.getName(), trigger.getGroup());// 移除触发器
scheduler.deleteJob(trigger.getJobName(), trigger.getJobGroup());// 删除任务
log.info(new Date() + ": 删除" + tbcq.getTriggername() + "计划任务");
}
}
/**
* 创建/添加计划任务
*
* @param tbcq
* 计划任务配置对象
* @throws Exception
*/
public void createCronTriggerBean(DbsynConfigQuartz tbcq) throws Exception {
// 新建一个基于Spring的管理Job类
MethodInvokingJobDetailFactoryBean mjdfb = new MethodInvokingJobDetailFactoryBean();
mjdfb.setName(tbcq.getJobdetailname());// 设置Job名称
// 如果定义的任务类为Spring的定义的Bean则调用 getBean方法
if (tbcq.getIsspringbean().equals("1")) {
mjdfb.setTargetObject(beanFactory.getBean(tbcq.getTargetobject()));// 设置任务类
} else {
// 否则直接new对象
mjdfb.setTargetObject(Class.forName(tbcq.getTargetobject())
.newInstance());// 设置任务类
}
mjdfb.setTargetMethod(tbcq.getMethodname());// 设置任务方法
mjdfb.setConcurrent(tbcq.getConcurrent().equals("0") ? false : true); // 设置是否并发启动任务
mjdfb.afterPropertiesSet();// 将管理Job类提交到计划管理类
// 将Spring的管理Job类转为Quartz管理Job类
JobDetail jobDetail = new JobDetail();
jobDetail = (JobDetail) mjdfb.getObject();
jobDetail.setName(tbcq.getJobdetailname());
scheduler.addJob(jobDetail, true); // 将Job添加到管理类
// 新一个基于Spring的时间类
CronTriggerBean c = new CronTriggerBean();
c.setCronExpression(tbcq.getCronexpression());// 设置时间表达式
c.setName(tbcq.getTriggername());// 设置名称
c.setJobDetail(jobDetail);// 注入Job
c.setJobName(tbcq.getJobdetailname());// 设置Job名称
scheduler.scheduleJob(c);// 注入到管理类
scheduler.rescheduleJob(tbcq.getTriggername(), Scheduler.DEFAULT_GROUP,
c);// 刷新管理类
log.info(new Date() + ": 新建" + tbcq.getTriggername() + "计划任务");
}
/**
* 查询数据库任务设置,返回列表
*
* @return 数据库任务设置列表
*/
public List<DbsynConfigQuartz> getConfigQuartz() {
List<DbsynConfigQuartz> result = new ArrayList<DbsynConfigQuartz>();
Connection con = null;
Statement smt = null;
ResultSet rs = null;
con = Connect.getCon("sys");
try {
if(con!=null) {
smt = con.createStatement();
con.setAutoCommit(false);
rs = smt
.executeQuery("select triggername,cronexpression,jobdetailname,targetobject,methodname,concurrent,state,readme,isspringbean from dbsyn_config_quartz");
while (rs.next()) {
DbsynConfigQuartz tbcq = new DbsynConfigQuartz();
tbcq.setTriggername(rs.getString("triggername"));
tbcq.setCronexpression(rs.getString("cronexpression"));
tbcq.setJobdetailname(rs.getString("jobdetailname"));
tbcq.setTargetobject(rs.getString("targetobject"));
tbcq.setMethodname(rs.getString("methodname"));
tbcq.setConcurrent(rs.getString("concurrent"));
tbcq.setState(rs.getString("state"));
tbcq.setReadme(rs.getString("readme"));
tbcq.setIsspringbean(rs.getString("isspringbean"));
result.add(tbcq);
}
rs.close();
}
}catch (SQLException e) {
e.printStackTrace();
}finally{
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return result;
}
public Scheduler getScheduler() {
return scheduler;
}
public void setScheduler(Scheduler scheduler) {
this.scheduler = scheduler;
}
/*
* public ApplicationContext getApc() { return apc; }
*
* public void setApc(ApplicationContext apc) { this.apc = apc; }
*/
public void setBeanFactory(BeanFactory factory) throws BeansException {
this.beanFactory = factory;
}
public BeanFactory getBeanFactory() {
return beanFactory;
}
}
定时器调用方法类：
package com.client;
import org.apache.log4j.Logger;
public class DrvServiceImpl {
private static Logger log = Logger.getLogger(DrvServiceImpl.class);
public void getHz() {
System.out.println("调用成功");
return;
}
}
applicationContext-quartz.xml 配置定时器的spring文件
<?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:context="http://www.springframework.org/schema/context"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<bean id="quartzManagerBean" class="com.quartz.QuartzManager">
<property name="scheduler" ref="schedulerManager" />
</bean>
<bean id="quartzManagerJobDetail"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="quartzManagerBean" />
<property name="targetMethod" value="reScheduleJob" />
<property name="concurrent" value="false" />
</bean>
<!-- 主定时计划 -->
<bean id="quartzManagerTrigger"
class="org.springframework.scheduling.quartz.SimpleTriggerBean">
<property name="jobDetail" ref="quartzManagerJobDetail" />
<!-- 延时1分钟 执行任务 -->
<property name="startDelay" value="1000" />
<!-- 任务执行周期 5分钟 -->
<property name="repeatInterval" value="6000" />
</bean>
<!-- 总管理类 如果将lazy-init='false'那么容器启动就会执行调度程序 -->
<bean id="schedulerManager" lazy-init="false" autowire="no"
class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="quartzManagerTrigger" />
</list>
</property>
</bean>
</beans>
proxool.xml数据库配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<something-else-entirely>
<proxool>
<alias>sys</alias>
<driver-url>
jdbc:oracle:thin:@localhost:1521:ajhz
</driver-url>
<driver-class>oracle.jdbc.driver.OracleDriver</driver-class>
<driver-properties>
<property name="user" value="ajhz" />
<property name="password" value="ajhz" />
<property name="autoReconnect" value="true" />
</driver-properties>
<maximum-connection-count>70</maximum-connection-count>
<minimum-connection-count>10</minimum-connection-count>
<house-keeping-sleep-time>90000</house-keeping-sleep-time>
<simultaneous-build-throttle>10</simultaneous-build-throttle>
<prototype-count>5</prototype-count>
<test-before-use>true</test-before-use>
<house-keeping-test-sql>
select sysdate from dual
</house-keeping-test-sql>
<verbose>true</verbose>
<statistics>10s,1m,1d</statistics>
<statistics-log-level>ERROR</statistics-log-level>
</proxool>
</something-else-entirely>
log4j.properties日志配置文件：
log4j.rootLogger= info,logfile
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - <%m>%n
log4j.appender.logfile=org.apache.log4j.RollingFileAppender
#log4j.appender.logfile.File=${catalina.base}/webapps/zdin/zdin.log
log4j.appender.logfile.MaxFileSize=512KB
log4j.appender.logfile.MaxBackupIndex=100
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n
web.xml配置文件
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<!-- proxool连接池 -->
<servlet>
<servlet-name>ServletConfigurator</servlet-name>
<servlet-class>
org.logicalcobwebs.proxool.configuration.ServletConfigurator
</servlet-class>
<init-param>
<param-name>xmlFile</param-name>
<param-value>WEB-INF/classes/proxool.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet>
<servlet-name>Admin</servlet-name>
<servlet-class>
org.logicalcobwebs.proxool.admin.servlet.AdminServlet
</servlet-class>
</servlet>
<servlet>
<servlet-name>contextConfigLocation</servlet-name>
<servlet-class>
org.springframework.web.context.ContextLoaderServlet
</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext*.xml</param-value>
</context-param>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
- quartz项目资料.rar (4.6 MB)
- 下载次数: 539
发表评论
-
生成webservices代理类方法
2013-12-15 21:06 660根据wsdl成生客户端信息: 在D盘下新建一个src目录 ... -
自动补全-jquery.autocomplete.js
2013-07-08 13:58 13680研究了三天自动补全jquery.autocomplete ... -
js设置cookie
2013-06-17 13:52 1279这几天用到cookie，所以在网上搜了一下js设置cook ... -
java 获取mac地址
2013-03-20 14:20 1346一下是用java来获取mac地址，一般可用作接口权限控制 ... -
oracle数据库-使用proxool进行中断重连
2013-02-17 11:03 3124（1）proxool.xml配置项参数 <?xml ... -
jsp自定义错误页
2013-02-17 11:00 939为了给浏览者一个友好的错误提示页面，我们可以象IIS一样自定义 ... -
Spring对Hibernate事务管理的配置
2013-01-09 15:11 957声明式事务配置主要分以下几步： 声明式事务配置 •配置 ... -
md5
2013-01-08 10:37 1052MD5是一种常用的加密算法，在项目中经常用到，我参考了网上一些 ... -
axis 自动生成webservices客户端代理类
2012-11-18 11:16 28131．新建wsdltojava.bat文件，放到C盘，文件内容如 ... -
ztree 小实例
2012-08-03 09:55 2457今天搞了一下ztree这个开源的东东，感觉很不错，很强大 ... -
java 读取.properties文件 最简单方式
2012-07-25 08:45 1043param.properties 内容如下： url ... -
Quartz入门示例
2012-05-14 17:28 955文章出处 http://www.cnblogs.com ... -
struts2.2.3 + spring3.1.0 + mybatis3.1.0集成简单demo
2012-04-19 09:25 17331、导入相应的jar包 -
Struts2访问request，session，application的四种方式
2012-04-19 09:10 1530方式1--》访问Map类型的： package cn ... -
struts.xml动态返回结果
2012-04-11 15:51 1004今天有个难题，被我解决啦。详细的问题我就不多说了，用到的 ... -
springmvc上传
2012-04-05 15:55 5273最近一直在网上看资料，今天我在网上发现一个demo,是 ... -
jsoup解析网页
2012-03-31 09:24 4347jsoup功能很强大，我用它来解析网页很轻松。但我只用了 ... -
fileupload多文件上传
2012-03-31 09:16 1095以前做过单文件的 ... -
解析百度输入框（在线查询）
2012-03-28 14:51 1836百度大家都会用，但是相信大家用百度的时候在输入框中随便输 ... -
ajax struts实现在线查询功能
2012-03-27 11:58 1156我用的是ajax 和struts实现的一个在线查询功能， ...
相关推荐
Quartz + spring简单配置多个任务调度 spring配置文件 简单配置
Quartz + spring的开发步骤Quartz + spring的开发步骤
Spring Boot+Apache Shiro+Spring MVC+MyBatis+Quartz+Druid DEMO
自己写的Quartz+Sping定时触发器例子，包含全部jar包，可直接运行。注释完整，适合初学者学习。
定时器的配置文件（两种方式：springmvc自带定时,Quartz与spring结合的定时）
spring+quartz配置的定时器 可以动态添加任务
quartz+spring示例,一个完整的配置实例
Quartz+spring所需要的jar quarts1.5.2
Quartz+spring实例应用 导入项目直接可以运行，注释详细
Spring+Quartz 从数据库中获取定时任务和定时时间，动态实现对定时任务的增删改查，部署到tomcat即可看到定时任务执行效果。本人亲测，可用！
quartz+spring集成完整开发富含文档cron表达式的配置说明，执行系统的定时器任务。可以直接集成到你的SSH框架中，完成复杂的定时器功能
本案例是基于quartz+spring做的定时任务，包含所有jar包，可以直接运行
以SpringBoot 为中心，模块化开发系统，用户可以随意删减除权限...复用，组装性强主要应用技术：spring Security+Ehcache+quartz+swagger2+Mysql5.6+springjdbc+druid+spring social+spring session + layerui+vue.js
springtask 和 quartz +ssh简单示例springtask 和 quartz +ssh简单示例springtask 和 quartz +ssh简单示例springtask 和 quartz +ssh简单示例
Spring中的Quartz配置-Spring-定时器-java定时器.doc
本文介绍的是JDBC-Jobstore基于数据库的集群，里面已包含有详细的文档和继承案例，请各位技术追求者门笑纳
本人花费多日时间，亲测有效。所需文件代码完整，只需导入常用开发IDE和mysql数据库即可正常使用。
我做的是 spring + quartz+ mysql and oracle 持久层 ibatis and hibernate 项目用eclipse 导入 不同的数据库 请在数据库运行不同的SQL 脚本 用hibernate 时注意 是什么数据库 hibernate.properties 文件第一二行...