Quartz存储与持久化--mysql

版权声明：嘿嘿嘿 https://blog.csdn.net/luzhensmart/article/details/83002057

工程结构：

web.xml: 

<?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"
	id="WebApp_ID" version="3.0">
	<display-name>quartz</display-name>
	<filter>
		<filter-name>encoding</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>encoding</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:application*.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<servlet>
		<servlet-name>mvc</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:applicationMvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>mvc</servlet-name>
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>
</web-app>

applicationContext.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:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
						http://www.springframework.org/schema/beans/spring-beans.xsd
						http://www.springframework.org/schema/aop 
						http://www.springframework.org/schema/aop/spring-aop.xsd
						http://www.springframework.org/schema/context 
						http://www.springframework.org/schema/context/spring-context.xsd
						http://www.springframework.org/schema/tx 
						http://www.springframework.org/schema/tx/spring-tx.xsd">
	<!-- 配置扫描包 -->
	<context:component-scan base-package="com.test" />
	<!-- 启用注解 -->
	<context:annotation-config />

	<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="fileEncoding" value="utf-8" />
		<property name="locations">
			<list>
				<value>classpath*:config.properties</value>
				<!--<value>classpath*:quartz.properties</value>-->
			</list>
		</property>
	</bean>


	<!-- 配置quartz 数据源 -->
	<bean id="quartzDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="${quartz.driverClassName}" />
		<property name="url" value="${quartz.url}" />
		<property name="username" value="${quartz.username}" />
		<property name="password" value="${quartz.password}" />
	</bean>

	<!-- quartz持久化存储  -->
	<bean name="quartzScheduler"
		  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
                <!--采用对是Spring数据源 没有用quartz.properties配置文件中默认对数据源-->
		<property name="dataSource">
			<ref bean="quartzDataSource" />
		</property>
		<property name="applicationContextSchedulerContextKey" value="applicationContext" />
		<!--必须的，QuartzScheduler 延时启动，应用启动完后 QuartzScheduler 再启动 -->
		<property name="startupDelay" value="3" />
		<!-- 设置自动启动 -->
		<property name="autoStartup" value="true" />
		<property name="configLocation" value="classpath:quartz.properties" />
	</bean>


</beans>

applicationMvc.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:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
								http://www.springframework.org/schema/beans/spring-beans.xsd
								http://www.springframework.org/schema/context
								http://www.springframework.org/schema/context/spring-context.xsd
								http://www.springframework.org/schema/mvc 
								http://www.springframework.org/schema/mvc/spring-mvc.xsd">
	<mvc:annotation-driven/>
	<context:component-scan base-package="com.test.controller"/>
	<mvc:default-servlet-handler/>
	<!-- jsp 视图解析器 -->
	<bean id="jspViewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="viewClass"
			value="org.springframework.web.servlet.view.JstlView" />
		<property name="prefix" value="/WEB-INF/view/"/>
		<property name="suffix" value=".jsp"/>
	</bean>
</beans>

config.properties:

quartz.driverClassName=com.mysql.jdbc.Driver
quartz.url=jdbc:mysql://xxx.xxx.xxx.xx:3306/数据库名?useUnicode=true&characterEncoding=UTF-8
quartz.username=用户名
quartz.password=密码
quartz.minPoolSize=7
quartz.initialPoolSize=12 

log4j.properties：

#级别  控制台输出
log4j.rootLogger = WARN, console
#console out
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern = [%c{1}|%-6p@%d{HH\:mm\:ss.SSS}] %C{1} %L - %m%n
#custom logger  包级别输出
log4j.logger.com.sharebo = DEBUG

quartz.properties：

# 设置调度器的实例名(instanceName) 和实例ID (instanceId)
org.quartz.scheduler.instanceName=MyScheduler
#如果使用集群，instanceId必须唯一，设置成AUTO
#org.quartz.scheduler.instanceId: AUTO
org.quartz.scheduler.wrapJobExecutionInUserTransaction=false

org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount=3
org.quartz.threadPool.threadPriority=5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true

# 持久化配置（存储方式使用JobStoreTX，也就是数据库）
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
# 驱动器方言 mysql驱动
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#数据库中quartz表的表名前缀
org.quartz.jobStore.tablePrefix=qrtz_
#org.quartz.jobStore.dataSource=myDS
# 使用自己的配置文件
org.quartz.jobStore.useProperties=true
org.quartz.jobStore.isClustered=true

#org.quartz.dataSource.myDS.driver=com.mysql.jdbc.Driver
#org.quartz.dataSource.myDS.URL=jdbc:mysql://192.168.157.61:3306/xxl-job?useUnicode=true&characterEncoding=UTF-8
#org.quartz.dataSource.myDS.user=admin
#[email protected]
#org.quartz.dataSource.myDS.maxConnections=5

org.quartz.plugin.triggHistory.class = org.quartz.plugins.history.LoggingJobHistoryPlugin
org.quartz.plugin.shutdownhook.class = org.quartz.plugins.management.ShutdownHookPlugin
org.quartz.plugin.shutdownhook.cleanShutdown = true

package com.test.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.test.util.quartz.MyJob;
import com.test.util.quartz.QuartzTest;


@RestController
public class TestController {
	@Autowired
	QuartzTest q;
	//添加一个倒计时任务
	@RequestMapping("add")
	public void add(String name) {

		q.addJob2(name, MyJob.class, "ccc", 20, "004");
	}
	//删除一个倒计时任务
	@RequestMapping("remove")
	public Object remove(String name) {
		return q.closeJob(name, "001");
	}
	//从数据库加载还未执行的任务（spring容器初始化的时候会自动加载）
	@RequestMapping("resume")
	public Object resume(String name) {
		q.resumeJob();
		return "OK";
	}
}

package com.test.util.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.log4j.Logger;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class MyJob implements Job{  
    private static final Logger logger = Logger.getLogger(MyJob.class);    
    @Override  
    public void execute(JobExecutionContext context)  
            throws JobExecutionException {  
        System.out.println("Hello quzrtz  "+   new SimpleDateFormat("yyyy-MM-dd HH:mm:ss ").format(new Date()));  
          
    }  
  
}

package com.test.util.quartz;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.quartz.*;
import org.quartz.core.jmx.JobDetailSupport;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.triggers.SimpleTriggerImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class QuartzTest {
	@Autowired
	private Scheduler scheduler;
	private static String JOB_GROUP_NAME = "ddlib";
	private static String TRIGGER_GROUP_NAME = "ddlibTrigger";

	/**
	 * 注意：此种方式由于用到的是SimpleTriggerImpl 任务跑的过程中会存入表中,任务执行完成后,会自动删除表中的数据 如:触发器信息等
	 * 添加任务
	 *
	 * @param jobName
	 *            任务名称
	 * @param job
	 *            任务处理类 需要继承Job
	 *            处理任务可以获取的上下文
	 *            通过context.getMergedJobDataMap().getString("context"); 获取
	 * @param seconds
	 *            间隔秒
	 * @return 0 添加成功 1：任务已经存在 2：添加异常
	 */
	public int addJob(String jobName, Class<? extends Job> job, Object task, int seconds, String jobGorupName) {
		try {
			// 判断任务是否存在
			JobKey jobKey = JobKey.jobKey(jobName, jobGorupName);
			if (scheduler.checkExists(jobKey)) {
				return 1;// 任务已经存在
			}
			// 创建一个JobDetail实例，指定SimpleJob
			Map<String, Object> JobDetailmap = new HashMap<String, Object>();
			JobDetailmap.put("name", jobName);// 设置任务名字
			JobDetailmap.put("group", jobGorupName);// 设置任务组
			JobDetailmap.put("jobClass", job.getCanonicalName());// 指定执行类
			// Task.class.getCanonicalName()
			JobDetail jobDetail = JobDetailSupport.newJobDetail(JobDetailmap);
			// 添加数据内容
			jobDetail.getJobDataMap().put("task", task);// 传输的上下文
			// 通过SimpleTrigger定义调度规则：马上启动，每2秒运行一次，共运行100次 等。。。。
			SimpleTriggerImpl simpleTrigger = new SimpleTriggerImpl();
			simpleTrigger.setName(jobName);
			simpleTrigger.setGroup(TRIGGER_GROUP_NAME);
			// 什么时候开始执行
			simpleTrigger.setStartTime(new Date());
			// 间隔时间
			simpleTrigger.setRepeatInterval(1000);
			// 最多执行次数 默认执行一次
			simpleTrigger.setRepeatCount(10);
			// 通过SchedulerFactory获取一个调度器实例
			scheduler.scheduleJob(jobDetail, simpleTrigger);//  注册并进行调度
			scheduler.start();// ⑤调度启动
			return 0;// 添加成功
		} catch (Exception e) {
			// e.printStackTrace();
			return 2;// 操作异常
		}
	}

	/**
	 * 注意：此种方式由于用到的是CronScheduleBuilder 任务跑的过程中会存入表中,任务执行完成后,不会自动删除表中的数据 会存于表中,
	 * 下次重启程序后  会继续按照cron表达式 执行任务如:触发器信息等
	 * @param jobName
	 * @param job
	 * @param task
	 * @param seconds
	 * @param jobGorupName
	 * @return
	 */
    public int addJob2(String jobName, Class<? extends Job> job, Object task, int seconds, String jobGorupName) {
        try {
            // 判断任务是否存在
            JobKey jobKey = JobKey.jobKey(jobName, jobGorupName);
            if (scheduler.checkExists(jobKey)) {
                return 1;// 任务已经存在
            }
            // 创建一个JobDetail实例，指定SimpleJob
            Map<String, Object> JobDetailmap = new HashMap<String, Object>();
            JobDetailmap.put("name", jobName);// 设置任务名字
            JobDetailmap.put("group", jobGorupName);// 设置任务组
            JobDetailmap.put("jobClass", job.getCanonicalName());// 指定执行类
            // Task.class.getCanonicalName()
            JobDetail jobDetail = JobDetailSupport.newJobDetail(JobDetailmap);
            // 添加数据内容
            jobDetail.getJobDataMap().put("task", task);// 传输的上下文
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/3 * * * * ?");
            CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("trigger_1", "tGroup1")
                    .withSchedule(cronScheduleBuilder).build();

            // 通过SchedulerFactory获取一个调度器实例
            scheduler.scheduleJob(jobDetail, cronTrigger);//  注册并进行调度
            scheduler.start();// ⑤调度启动
            return 0;// 添加成功
        } catch (Exception e) {
            // e.printStackTrace();
            return 2;// 操作异常
        }
    }

	/**
	 * 关闭任务调度
	 *
	 * @param jobName
	 *            任务名称
	 * @return 0 关闭成功 1： 关闭失败 2：操作异常
	 */
	public int closeJob(String jobName, String jobGorupName) {
		// 关闭任务调度
		try {
			JobKey jobKey = JobKey.jobKey(jobName, jobGorupName);
			return scheduler.deleteJob(jobKey) == true ? 0 : 1;
		} catch (SchedulerException e) {
			// e.printStackTrace();
			return 2;
		}
	}

	/**
	 * 从数据库中找到已经存在的job，并重新开户调度
	 */
	public void resumeJob() {
		try {
			scheduler.start();
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

index.jsp: 

<html>
<body>
<h2>Hello World!</h2>
</body>
</html>

运行结果：

用CronScheduleBuilder后，数据库中表中数据的信息：

 

等等