Spring+SpringMVC+Quartz 持久化存储与数据源配置

最新推荐文章于 2022-06-30 00:29:33 发布
最新推荐文章于 2022-06-30 00:29:33 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： 框架搭建研讨 java代码应用 文章标签： mysql spring mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26430717/article/details/108715748
版权

一、前言

最近工作需求，需要整合一个quartz框架的管理界面，要求数据持久化，前端界面管理。方便管理所有的定时任务，同时进行任务状态的监控。

相关技术：

spring

springMvc

mybatis【这个看你们自己使用的数据源】

quartz

二、前端界面

 前端界面各位请自行查找，不管是使用jquery还是vue。只要能实现请求发送就行。界面要实现基础的增删查改，暂停启动。

具体可以参考这篇文档，界面可以直接参照使用。
https://blog.csdn.net/u012907049/article/details/70273080
该博客介绍了一种持久化存储方式，不过由于没有采用spring装配bean的方式的方式。导致每次都要新建对象，而且无法指定调度器，所以兼容性不太适用。

三、持久化存储

首先quartz是提供了一套功能强大的持久化存储方案的。通过使用这个套框架，所有对job的增删改操作，都会记录到数据库中。

PS:查询按照需求自行写，查数据库

1：搭建基础的springMvc工程，确保正常启动，这里不做详细说明。

2：在搭建好的spring工程中加入下面两个quartz依赖。

这两个就是quartz框架需要的所有依赖

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
  </dependency>

  <dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz-jobs</artifactId>
    <version>2.3.2</version>
  </dependency>

3：配置bean

在spring的配置文件【就是你web.xml配置指向的文件，如applicationContext.xml】中声明一个SchedulerFactoryBean 

如果你想要和其他区分开来，你把id和name都改成叫scheduler_test都行。

<!-- quartz持久化存储  -->
	 <bean id="scheduler" name="scheduler"
        class="org.springframework.scheduling.quartz.SchedulerFactoryBean" >  
  
        <property name="dataSource" ref="dataSource" />
      
        <property name="configLocation" value="classpath:scan-quartz.properties" />
        <property name="applicationContextSchedulerContextKey"  
            value="applicationContextKey" />  
        <property name="autoStartup" value="true" />  
    </bean>

这里解释下，首先

1：我们声明了一个scheduler ,这个就是我们之后将要操作的对象。所有对这个对象的操作都会反馈到数据库中

2：我们对这个对象 声明了一个数据库  <property name="dataSource" ref="dataSource" />。这个数据源自行配置。

比如我使用mybatis的数据库，id为dataSource。这个就是我提供给scheduler_test 的数据源。这里就是第一种数据源配置方式，也是最灵活的一种方式。

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<!-- <property name="driverClassName" value="com.mysql.jdbc.Driver" /> -->
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/test" />
		<property name="username" value="root" />
		<property name="password" value="123456" />
		<!-- 初始化连接大小 -->
		<property name="initialSize" value="0"></property>
		<!-- 连接池最大数量 -->
		<property name="maxActive" value="20"></property>
		<!-- 连接池最大空闲 -->
		<property name="maxIdle" value="20"></property>
		<!-- 连接池最小空闲 -->
		<property name="minIdle" value="1"></property>
		<!-- 获取连接最大等待时间 -->
		<property name="maxWait" value="6000"></property>
	</bean>

	<!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<!-- 自动扫描mapping.xml文件 -->
		<property name="mapperLocations" value="classpath:com/example/demo/mapper/*.xml"></property>
	</bean>

	<!-- DAO接口所在包名，Spring会自动查找其下的类 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="com.example.demo.dao" />
		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
	</bean>

	<!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

3：我们配置 <property name="autoStartup" value="true" />   ，这个会让任务在程序启动时加载

4：我们配置具体的quarzt的任务参数，指明需要读取的文件 <property name="configLocation" value="classpath:scan-quartz.properties" />

4：配置scan-quartz.properties

在bean的声明里我们读取了一个配置文件 

 <property name="configLocation" value="classpath:scan-quartz.properties" />

我们在项目的资源文件路径下放了一个 scan-quartz.properties。这个就是我们持久化配置的关键文件。

具体如下：

这里讲几个主要的参数，

org.quartz.scheduler.instanceName = DefaultQuartzScheduler  调度器名称，默认名称，假如是使用上面bean加载的方式，那么调度器名称将会是bean的名称

org.quartz.threadPool.threadCount = 5  并发个数，最小为1，否则会报错，但不能配置过大，比如100什么的，太多的闲置线程将影响工程的性能，

org.quartz.threadPool.threadPriority = 5 优先级

org.quartz.jobStore.tablePrefix = QRTZ_  数据表前缀，改这个你能自定义一套自己的数据表，


org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore # 默认存储在内存中，启用这个代表不使用持久化，定时任务的生命周期和工程的开启结束一致


org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX #持久化存储，和内存存储只能启用一个，好处是配置的任务能永久保存。

# 固定前缀org.quartz
# 主要分为scheduler、threadPool、jobStore、plugin等部分
#
#
org.quartz.scheduler.instanceName = DefaultQuartzScheduler
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false

# 实例化ThreadPool时，使用的线程类为SimpleThreadPool
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool

# threadCount和threadPriority将以setter的形式注入ThreadPool实例
# 并发个数
org.quartz.threadPool.threadCount = 5
# 优先级
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

org.quartz.jobStore.misfireThreshold = 5000

# 默认存储在内存中
#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

#持久化
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX

org.quartz.jobStore.tablePrefix = QRTZ_


#org.quartz.jobStore.dataSource = qzDS1

#org.quartz.dataSource.qzDS1.connectionProvider.class=com.SpringConnectionProvider

org.quartz.jobStore.dataSource = qzDS

#假如已经在bean里声明了数据源，以下四句可以直接注释掉，二选一配置数据源
#org.quartz.dataSource.qzDS.driver = com.mysql.jdbc.Driver
#org.quartz.dataSource.qzDS.URL = jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8
#org.quartz.dataSource.qzDS.user = root
#org.quartz.dataSource.qzDS.password = 123456

其中这里的数据源可以自行配置，这就是第二种配置数据源的方式，假如已经在bean里声明了数据源，以下四句可以直接注释掉，二选一配置数据源

#org.quartz.dataSource.qzDS.driver = com.mysql.jdbc.Driver
#org.quartz.dataSource.qzDS.URL = jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf-8
#org.quartz.dataSource.qzDS.user = root
#org.quartz.dataSource.qzDS.password = 123456

 

第三种配置数据源的方式，同样的将其他配置数据源的代码注释掉，启用如下

org.quartz.jobStore.dataSource = qzDS1

org.quartz.dataSource.qzDS1.connectionProvider.class=com.SpringConnectionProvider

这里自定义了一个数据源名称为  qzDS1 ，数据源指向了com.SpringConnectionProvider

具体数据源配置为  com.SpringConnectionProvider 这个是类的路径名称。如下：

具体代码如下：

这种好处是，你可以在这里添加些你自己的处理逻辑

package com;

import java.sql.Connection;
import java.sql.SQLException;


import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;
import org.quartz.utils.ConnectionProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SpringConnectionProvider implements ConnectionProvider {  
    private static final Logger LOG = LoggerFactory.getLogger(SpringConnectionProvider.class);  
  
    
    private DataSource dataSource;  
      
 
    public Connection getConnection() throws SQLException {  
        return dataSource.getConnection();  
    }  
  
    public void shutdown() throws SQLException {  
        LOG.debug("==========do shutdown===========");  
        dataSource = null;  
    }  
  
    public void initialize() throws SQLException {  
        LOG.debug("==========do initialize===========使用配置中心定义的数据源");  
    	BasicDataSource da = new BasicDataSource();
    	da.setDriverClassName("com.mysql.jdbc.Driver");
    	da.setUrl("jdbc:mysql://10.10.0.239:3306/lhywzx_dev?characterEncoding=utf8");
    	da.setUsername("taxcp");
    	da.setPassword("taxcp1234");
    	this.dataSource = da; 
    }  
    
  
}

四、创建数据库

官方数据库，下面是mysql的

CREATE TABLE QRTZ_JOB_DETAILS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    JOB_NAME  VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    JOB_CLASS_NAME   VARCHAR(250) NOT NULL,
    IS_DURABLE VARCHAR(1) NOT NULL,
    IS_NONCONCURRENT VARCHAR(1) NOT NULL,
    IS_UPDATE_DATA VARCHAR(1) NOT NULL,
    REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
);

CREATE TABLE QRTZ_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    JOB_NAME  VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    NEXT_FIRE_TIME BIGINT(13) NULL,
    PREV_FIRE_TIME BIGINT(13) NULL,
    PRIORITY INTEGER NULL,
    TRIGGER_STATE VARCHAR(16) NOT NULL,
    TRIGGER_TYPE VARCHAR(8) NOT NULL,
    START_TIME BIGINT(13) NOT NULL,
    END_TIME BIGINT(13) NULL,
    CALENDAR_NAME VARCHAR(200) NULL,
    MISFIRE_INSTR SMALLINT(2) NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
        REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)
);

CREATE TABLE QRTZ_SIMPLE_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    REPEAT_COUNT BIGINT(7) NOT NULL,
    REPEAT_INTERVAL BIGINT(12) NOT NULL,
    TIMES_TRIGGERED BIGINT(10) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_CRON_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    CRON_EXPRESSION VARCHAR(200) NOT NULL,
    TIME_ZONE_ID VARCHAR(80),
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (          
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_BLOB_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    BLOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_CALENDARS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    CALENDAR_NAME  VARCHAR(200) NOT NULL,
    CALENDAR BLOB NOT NULL,
    PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
);

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_GROUP  VARCHAR(200) NOT NULL, 
    PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_FIRED_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    ENTRY_ID VARCHAR(95) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    FIRED_TIME BIGINT(13) NOT NULL,
    SCHED_TIME BIGINT(13) NOT NULL,
    PRIORITY INTEGER NOT NULL,
    STATE VARCHAR(16) NOT NULL,
    JOB_NAME VARCHAR(200) NULL,
    JOB_GROUP VARCHAR(200) NULL,
    IS_NONCONCURRENT VARCHAR(1) NULL,
    REQUESTS_RECOVERY VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,ENTRY_ID)
);

CREATE TABLE QRTZ_SCHEDULER_STATE
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
    CHECKIN_INTERVAL BIGINT(13) NOT NULL,
    PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
);

CREATE TABLE QRTZ_LOCKS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    LOCK_NAME  VARCHAR(40) NOT NULL, 
    PRIMARY KEY (SCHED_NAME,LOCK_NAME)
);

commit;

 

5：进行增删查改等操作

其实就是最基本的增删改的操作，和其他人的差不多，有微调

首先我们这里使用我们注入之前配置的bean, 如果你想要和其他区分开来，你叫scheduler_test都行。

@Autowired
 private Scheduler scheduler;

package com;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.alibaba.fastjson.JSONObject;
import com.example.demo.entity.JobAndTrigger;
import com.example.demo.job.BaseJob;
import com.example.demo.service.IJobAndTriggerService;
import com.github.pagehelper.PageInfo;


@Controller
@RequestMapping(value="/job")
public class JobController
{


	@Autowired
	private Scheduler scheduler;
	
	private static Logger log = LoggerFactory.getLogger(JobController.class);  
	
	@ResponseBody
	@RequestMapping(value="/addjob")
	public void addjob(@RequestParam(value="jobClassName")String jobClassName, 
			@RequestParam(value="jobGroupName")String jobGroupName, 
			@RequestParam(value="cronExpression")String cronExpression) throws Exception
	{			
		addJob(jobClassName, jobGroupName, cronExpression);
	}
	
	@ResponseBody
	@RequestMapping(value="/getindex.do")
	public String getindex() throws Exception
	{			
		return "index";
	}
	
	public void addJob(String jobClassName, String jobGroupName, String cronExpression)throws Exception{
        
        
        // 启动调度器  
		scheduler.start(); 
		
		//构建job信息
		JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName).getClass()).withIdentity(jobClassName, jobGroupName).build();
		
		//表达式调度构建器(即任务执行的时间)
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

        //按新的cronExpression表达式构建一个新的trigger
        CronTrigger trigger = TriggerBuilder.newTrigger()
            .withSchedule(scheduleBuilder).build();
        
        try {
        	scheduler.scheduleJob(jobDetail, trigger);
            
        } catch (SchedulerException e) {
            System.out.println("创建定时任务失败"+e);
            throw new Exception("创建定时任务失败");
        }
	}


	@ResponseBody
	@RequestMapping(value="/pausejob")
	public void pausejob(@RequestParam(value="jobClassName")String jobClassName, @RequestParam(value="jobGroupName")String jobGroupName) throws Exception
	{			
		jobPause(jobClassName, jobGroupName);
	}
	
	public void jobPause(String jobClassName, String jobGroupName) throws Exception
	{	
		scheduler.pauseJob(JobKey.jobKey(jobClassName, jobGroupName));
	}
	

	@ResponseBody
	@RequestMapping(value="/resumejob")
	public void resumejob(@RequestParam(value="jobClassName")String jobClassName, @RequestParam(value="jobGroupName")String jobGroupName) throws Exception
	{			
		jobresume(jobClassName, jobGroupName);
	}
	
	public void jobresume(String jobClassName, String jobGroupName) throws Exception
	{
		scheduler.resumeJob(JobKey.jobKey(jobClassName, jobGroupName));
	}
	
	
	@ResponseBody
	@RequestMapping(value="/reschedulejob")
	public void rescheduleJob(@RequestParam(value="jobClassName")String jobClassName, 
			@RequestParam(value="jobGroupName")String jobGroupName,
			@RequestParam(value="cronExpression")String cronExpression) throws Exception
	{			
		jobreschedule(jobClassName, jobGroupName, cronExpression);
	}
	
	public void jobreschedule(String jobClassName, String jobGroupName, String cronExpression) throws Exception
	{				
		
		try {
			TriggerKey triggerKey = TriggerKey.triggerKey(jobClassName, jobGroupName);
			// 表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

			CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

			// 按新的cronExpression表达式重新构建trigger
			trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

			// 按新的trigger重新设置job执行
			scheduler.rescheduleJob(triggerKey, trigger);
		} catch (SchedulerException e) {
			System.out.println("更新定时任务失败"+e);
			throw new Exception("更新定时任务失败");
		}
	}
	
	
	@ResponseBody
	@RequestMapping(value="/deletejob")
	public void deletejob(@RequestParam(value="jobClassName")String jobClassName, @RequestParam(value="jobGroupName")String jobGroupName) throws Exception
	{			
		jobdelete(jobClassName, jobGroupName);
	}
	
	public void jobdelete(String jobClassName, String jobGroupName) throws Exception
	{		
		scheduler.pauseTrigger(TriggerKey.triggerKey(jobClassName, jobGroupName));
		scheduler.unscheduleJob(TriggerKey.triggerKey(jobClassName, jobGroupName));
		scheduler.deleteJob(JobKey.jobKey(jobClassName, jobGroupName));				
	}
	
	
	
	public static BaseJob getClass(String classname) throws Exception 
	{
		Class<?> class1 = Class.forName(classname);
		return (BaseJob)class1.newInstance();
	}
	
	
}

查看数据库结果，正常写入，所有动作都被监听到了

 

星河之砂
关注
专栏目录
Spring+SpringMVC+MyBatis框架的整合+注解
thinkhi9999的博客
08-24 2333
标准主流现在编程方式都是采用MVC综合设计模式，MVC本身不属于设计模式的一种，它描述的是一种结构，最终目的达到解耦，解耦说的意思是你更改某一层代码，不会影响我其它层代码，如果你会像Spring这样的框架，你会了解面向接口编程，表示层调用控制层，控制层调用业务层，业务层调用数据访问层。如果不使用任何框架，而单纯使用Servlet和JDBC技术，甚至只用JSP技术，同样可以实现JAVAWEB的项目开发，但这样的项目具体工作码量大，代码之间的耦合性极强，如果需要调整某一功能 ，出于连锁反应，可能要修改所有的源代
【动态任务-八】SpringMvc+quartz 整合Job（可使用依赖注入@Autowired）
程序猿开发日志【学习永无止境】
10-23 1110
在我们的任务类里面，我们需要使用到springioc依赖注入的接口实现类 因为我们是Springmvc，我们需要在xml做一下配置，一般是spring-application.xml加入spring-quartz.xml <import resource="spring-quartz.xml"/> 这个spring-quartz.xml我们新建一个，如下 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns=..
SpringMVC利用Quartz实现可配置的定时器
04-22
待完善。简单的例子，免费下载。参考http://www.meiriyouke.net/?p=82 谢谢原作者 也谢谢ZJ
【Quartz】Quartz存储与持久化-基于quartz.properties的配置
杜海的博客
11-18 2088
林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka 一、   Quartz存储与持久化          Quartz提供两种基本作业存储类型。第一种类型叫做RAMJobStore，第二种类型叫做JDBC作业存储。在默认情况下Quartz将任务调度的运行信息保存在内存中，这种方法提供了最佳的性能，因为内存中数据访问最快。不足之处是缺乏数据的
SpringMvc+quartz
chensuifeng的专栏
05-10 778
今天使用了SpringMvc4.1+quartz进行java调度，一开始的时候使用quartz2.0的包运行一直报错，提示nested exception is java.lang.NoSuchMethodError: org.quartz.JobDataMap.put(Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object异常，后来在网上找了
spring mvc 集成quartz
root
06-12 676
首先quartz配置文件    # Default Properties file for use by StdSchedulerFactory # to create a Quartz Scheduler Instance, if a different # properties file is not explicitly specified. # #====================...
SpringMvc+quartz整合
inspurs06的博客
09-02 3514
一、简介：Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.0。 二、因为定时调度，在很多业务上面都会涉及，想要根据...
spring+springmvc+hibernate/金融类项目源码，针对对账业务
06-16
8. 多数据源管理：对于复杂的金融系统，多数据源配置能确保系统在不同数据库间无缝切换，适应高并发和大数据量的需求。 以上就是关于“Spring+SpringMVC+Hibernate/金融类项目源码，针对对账业务”的主要知识点和...
Java基于SSM（Spring+SpringMVC+MyBatis）学生智能选课系统.zip
最新发布
03-02
Spring还提供了数据源配置、连接池管理等功能，为数据库操作提供了便利。 其次，SpringMVC是Spring框架的Web MVC模块，负责处理HTTP请求和响应。它通过DispatcherServlet接收请求，映射到对应的Controller，...
springmvc+spring+hibernate
08-07
3. **配置Spring**：在src/main/resources下创建applicationContext.xml文件，配置Spring的核心容器，包括Bean定义、数据源、事务管理器等。例如，使用DataSource来连接Oracle数据库，使用...
springMVC+quartz任务调度
06-10
代码版 springMVC+quartz任务调度
spring+mvc+quartz.rar
06-04
Spring4.3.15 + Quartz2.2 + Spring MVC管理可以管理任务的暂停，启动、立即执行一次、根据表达式重新调度等功能
spring+springMVC+hibernate+cxf+定时器+ehcache个人整合
11-05
Hibernate提供了自动持久化、事务管理和查询语言HQL，简化了数据库操作，降低了数据库相关的耦合度。 4. **CXF**：CXF 是一个开源的服务框架，它支持SOAP、RESTful等多种Web服务标准。使用CXF，开发者可以轻松地...
springMVC + quartz实现定时器（任务调度器）
weixin_33881140的博客
10-20 212
首先我们要知道任务调度器（定时器）有几种，这边我会写三种 第一种是基于JDK的本身的一个定时器（优点：简单，缺点：满足不了复杂的需求） package com.timer1; import java.util.Date; import java.util.TimerTask; /** * jdk自带的定时器 不需要引入任何的jar * @author Admi...
SpringMVC 集成 Quartz 框架 完成动态定时任务
m0_51985332的博客
06-30 1766
Quartz 框架 完成动态定时任务
SpringMVC整合Quartz实现定时任务和Spring自带Task定时任务
蓝天之枫
01-07 436
在Java中我们常用Timer和TimerTask实现定时功能，而在JavaEE项目中可以使用spring整合Quartz定时器、Spring的Task任务。相比于Spring自带的任务，Quartz非常的强大，能够实现所有想要的定时任务，包括Tomcat服务器开始启动，定时定点定周，集群定时任务等等的任务，有关Quartz的介绍和时间配置网上有很多的资料，就不在累赘，下面主要介绍SpringMV...
spring mvc集成Quartz框架配置多定时任务
一个抽风的女Ren的博客
11-30 912
一、增加所依赖的JAR包     1、增加Spring的Maven依赖 &lt;!--Quartz的Maven依赖 --&gt; &lt;dependency&gt; &lt;groupId&gt;org.quartz-scheduler&lt;/groupId&gt; &lt;artifactId&gt;quartz&lt;/artifactId&gt; &lt;vers...
Quartz集成springMVC 的方案二（持久化任务、集群和分布式）
Ryan Z 的技术日志
10-29 903
Quartz是一个开放源码项目，专注于任务调度器，提供了极为广泛的特性如持久化任务，集群和分布式任务等。 Quartz核心是调度器，还采用多线程管理。   1.持久化任务：当应用程序停止运行时，所有调度信息不被丢失，当你重新启动时，调度信息还存在，这就是持久化任务。   2.集群和分布式处理：当在集群环境下，当有配置Quartz的多个客户端时（节点），采用Quartz的集群
springmvc整合Quartz
Brave_heart4pzj的博客
05-08 253
https://www.cnblogs.com/wlsblog/p/8042692.html 比较好 https://blog.csdn.net/weixin_41672897/article/details/81431745 https://www.cnblogs.com/liaojie970/p/5913638.html
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值