`
hzywy
  • 浏览: 168601 次
  • 性别: Icon_minigender_1
  • 来自: 长沙
社区版块
存档分类
最新评论

定时器(quartz+spring)读取数据库配置

阅读更多

    今天把项目中的一部分移出来,主要是实现定时器任务,定时任务是从数据库配置的的,所以采用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>





分享到:
评论
1 楼 单v纯微笑 2016-10-23  
您好,能把dbsyn_config_quartz这个表发给我一份吗?最好是有几条数据的。谢谢!

相关推荐

    Spingboot+Quartz基于数据库的作业任务调度

    这样,Quartz将在启动时读取数据库中的配置并安排任务。 5. **数据库表**:Quartz需要一些特定的数据库表来存储任务和触发器信息。如果使用的是默认配置,需要根据Quartz提供的SQL脚本在数据库中创建这些表。 6. *...

    定时器 quartz 和 spring

    标题 "定时器 quartz 和 spring" 涉及到的是两个在Java开发中非常重要的框架——Quartz和Spring。Quartz是一个开源的工作调度框架,它允许开发者创建、调度和执行任务,而Spring则是一个功能丰富的应用程序框架,...

    定时器quartz的使用方法

    本教程将详细讲解如何使用Quartz实现一个简单的定时器功能。 首先,我们需要引入Quartz的依赖库到项目中。如果你使用的是Maven,可以在pom.xml文件中添加以下依赖: ```xml &lt;groupId&gt;org.quartz-scheduler ...

    springmvc+hibernate+定时器配置实例

    首先,你需要在SpringMVC的配置文件中添加定时任务的配置,比如使用Spring的TaskExecutor或Scheduler,或者集成Quartz库。然后,定义一个定时任务类,这个类中包含执行定时任务的方法,并且这个方法内部可以使用...

    springmvc基本配置及定时任务配置修改

    2. **配置 Spring**:在 Spring 配置文件中,定义 `SchedulerFactoryBean` 来创建和管理 Quartz Scheduler 实例。同时,你可以配置 Job 和 Trigger 的 bean,通过 `@DisallowConcurrentExecution` 或 `@...

    spring 定时器

    下面将详细阐述Spring定时器的工作原理、配置方法以及使用场景。 1. **工作原理**: Spring定时器基于`java.util.concurrent.ScheduledExecutorService`接口,它是一个线程池服务,可以用来安排在未来某个时间点...

    详解spring batch的使用和定时器Quart的使用

    Spring Batch是一个基于Spring的企业级批处理框架,它通过配合定时器Quartz来轻易实现大批量的数据读取或插入,并且全程自动化,无需人员管理。在使用Spring Batch之前,需要对Spring Batch的流程有一个基本了解。 ...

    spring-quartz

    【描述】"spring-quartz整合,实现定时器的动态开启(从数据库读取)" 提示我们这个项目不仅涉及Spring和Quartz的基本整合,还包含了一个关键特性:定时任务的配置可以从数据库中读取。这意味着系统可以动态地添加、...

    spring定时器的一个简单应用.doc

    1. **配置Spring定时器**:在Spring配置文件(如`applicationContext.xml`)中,你需要定义一个`TaskScheduler`的bean,通常使用`ThreadPoolTaskScheduler`实现。例如: ```xml ...

    Java定时操作数据库测试Demo

    在实际项目中,可能还需要考虑异常处理、连接池管理(如C3P0或HikariCP)、数据库事务控制以及定时任务的灵活性和可扩展性,比如使用Spring的`@Scheduled`注解或Quartz等更强大的定时任务框架。 至于压缩包中的...

    springboot 定时任务加layui的界面版

    根据描述,我们将从数据库读取定时任务信息,这意味着我们需要一个数据库模型来存储任务的配置,如cron表达式、任务名称等。可以创建一个`JobInfo`实体类,包含这些字段,并添加相应的CRUD操作。 四、Layui界面集成...

    application定时器

    【application定时器】,在Java Web应用程序中,定时任务的实现常常依赖于强大的调度框架,如Spring定时器或Quartz。本话题主要聚焦于Quartz,这是一个开源的、功能丰富的调度库,尤其适合用于Web应用中执行定时任务...

    boot+mybatis、mybatis中枚举转换器、前后端分离项目统一返回格式、boot集成quraz框架实现定时任务

    接着,创建一个继承自`org.springframework.scheduling.quartz.ScheduledTaskRegistrar`的配置类,并重写`initTasks`方法,用以添加定时任务。在该方法中,可以使用`Scheduler`对象的`scheduleJob`方法来安排任务,...

    org.springframework.batch-2.0.0.RELEASE-with-dependencies

    - 依赖包括但不限于 Spring Framework、JDBC 驱动、JPA、Quartz 定时器等,为批处理提供了全面的支持。 7. **集成与扩展** - Spring Batch 可与 Spring 其他模块无缝集成,如 Spring JDBC、Spring Integration 等...

    springboot+mybatis示例代码

    【标题】"springboot+mybatis示例代码"是一个典型的Java开发示例,它结合了...同时,【压缩包子文件的文件名称列表】中的"info"可能包含更详细的项目说明,例如数据库配置、具体代码实现等,可以帮助深入理解这个示例。

    SpringMVC+Mybatis 框架,非Mven版本,自带基本功能和教复杂的表单样例

    自己搞的,赚点积分。下载的人,不会觉得亏。亏了私信我。 【前端框架】 基于bootstrap的AdminLte2.4 ...2、封装了可配置的Quartz定时器;分两个版本:一个基于xml的配置版,一个是读取SQL 3、轻量级缓存 4、页面优美。

    SpringBoot集成常用开发中间件,分库分表,缓存,消息队列,定时器,权限管理等组件

    SpringBoot结合Quartz或Spring Task可以实现定时任务的调度。通过@Scheduled注解,开发者可以方便地定义定时任务的执行周期和行为。 最后,"权限管理"涉及到用户认证(Authentication)和授权(Authorization)。...

Global site tag (gtag.js) - Google Analytics