文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

SpringBoot+Quartz+数据库存储的完美集合

2024-04-02 19:55

关注

官网：http://www.quartz-scheduler.org/

我们所需数据库

pom依赖

   <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
            <!--解决mybatis-generator-maven-plugin运行时没有将XxxMapper.xml文件放入target文件夹的问题-->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**
@Component
@Slf4j
public class MyJobFactory extends AdaptableJobFactory {
    //这个对象Spring会帮我们自动注入进来
    @Autowired
    private AutowireCapableBeanFactory autowireCapableBeanFactory;
    //重写创建Job任务的实例方法
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object jobInstance = super.createJobInstance(bundle);
        //通过以下方式，解决Job任务无法使用Spring中的Bean问题
        autowireCapableBeanFactory.autowireBean(jobInstance);
        return super.createJobInstance(bundle);
    }
}

DruidConnectionProvider

package com.wsy.quartz02.utils;
import com.alibaba.druid.pool.DruidDataSource;
import org.quartz.SchedulerException;
import org.quartz.utils.ConnectionProvider;
import java.sql.Connection;
import java.sql.SQLException;



public class DruidConnectionProvider implements ConnectionProvider {
    
    //JDBC驱动
    public String driver;
    //JDBC连接串
    public String URL;
    //数据库用户名
    public String user;
    //数据库用户密码
    public String password;
    //数据库最大连接数
    public int maxConnection;
    //数据库SQL查询每次连接返回执行到连接池，以确保它仍然是有效的。
    public String validationQuery;
    private boolean validateOnCheckout;
    private int idleConnectionValidationSeconds;
    public String maxCachedStatementsPerConnection;
    private String discardIdleConnectionsSeconds;
    public static final int DEFAULT_DB_MAX_CONNECTIONS = 10;
    public static final int DEFAULT_DB_MAX_CACHED_STATEMENTS_PER_CONNECTION = 120;
    //Druid连接池
    private DruidDataSource datasource;
    
    public Connection getConnection() throws SQLException {
        return datasource.getConnection();
    }
    public void shutdown() throws SQLException {
        datasource.close();
    }
    public void initialize() throws SQLException{
        if (this.URL == null) {
            throw new SQLException("DBPool could not be created: DB URL cannot be null");
        }
        if (this.driver == null) {
            throw new SQLException("DBPool driver could not be created: DB driver class name cannot be null!");
        }
        if (this.maxConnection < 0) {
            throw new SQLException("DBPool maxConnectins could not be created: Max connections must be greater than zero!");
        }
        datasource = new DruidDataSource();
        try{
            datasource.setDriverClassName(this.driver);
        } catch (Exception e) {
            try {
                throw new SchedulerException("Problem setting driver class name on datasource: " + e.getMessage(), e);
            } catch (SchedulerException e1) {
            }
        }
        datasource.setUrl(this.URL);
        datasource.setUsername(this.user);
        datasource.setPassword(this.password);
        datasource.setMaxActive(this.maxConnection);
        datasource.setMinIdle(1);
        datasource.setMaxWait(0);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(this.DEFAULT_DB_MAX_CACHED_STATEMENTS_PER_CONNECTION);
        if (this.validationQuery != null) {
            datasource.setValidationQuery(this.validationQuery);
            if(!this.validateOnCheckout)
                datasource.setTestOnReturn(true);
            else
                datasource.setTestOnBorrow(true);
            datasource.setValidationQueryTimeout(this.idleConnectionValidationSeconds);
        }
    }
    
    public String getDriver() {
        return driver;
    }
    public void setDriver(String driver) {
        this.driver = driver;
    }
    public String getURL() {
        return URL;
    }
    public void setURL(String URL) {
        this.URL = URL;
    }
    public String getUser() {
        return user;
    }
    public void setUser(String user) {
        this.user = user;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public int getMaxConnection() {
        return maxConnection;
    }
    public void setMaxConnection(int maxConnection) {
        this.maxConnection = maxConnection;
    }
    public String getValidationQuery() {
        return validationQuery;
    }
    public void setValidationQuery(String validationQuery) {
        this.validationQuery = validationQuery;
    }
    public boolean isValidateOnCheckout() {
        return validateOnCheckout;
    }
    public void setValidateOnCheckout(boolean validateOnCheckout) {
        this.validateOnCheckout = validateOnCheckout;
    }
    public int getIdleConnectionValidationSeconds() {
        return idleConnectionValidationSeconds;
    }
    public void setIdleConnectionValidationSeconds(int idleConnectionValidationSeconds) {
        this.idleConnectionValidationSeconds = idleConnectionValidationSeconds;
    }
    public DruidDataSource getDatasource() {
        return datasource;
    }
    public void setDatasource(DruidDataSource datasource) {
        this.datasource = datasource;
    }
}

application.yml

server:
  servlet:
    context-path: /
  port: 80
spring:
  datasource:
    #1.JDBC
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mysql?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123
    druid:
      #2.连接池配置
      #初始化连接池的连接数量 大小，最小，最大
      initial-size: 5
      min-idle: 5
      max-active: 20
      #配置获取连接等待超时的时间
      max-wait: 60000
      #配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      time-between-eviction-runs-millis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      min-evictable-idle-time-millis: 30000
      validation-query: SELECT 1 FROM DUAL
      test-while-idle: true
      test-on-borrow: true
      test-on-return: false
      # 是否缓存preparedStatement，也就是PSCache  官方建议MySQL下建议关闭   个人建议如果想用SQL防火墙 建议打开
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      filter:
        stat:
          merge-sql: true
          slow-sql-millis: 5000
      #3.基础监控配置
      web-stat-filter:
        enabled: true
        url-pattern: 
    List<ScheduleTrigger> queryScheduleTriggerLst();
}

ScheduleTriggerParamMapper

package com.wsy.quartz02.mapper;
import com.wsy.quartz02.model.ScheduleTriggerParam;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface ScheduleTriggerParamMapper {
    int deleteByPrimaryKey(Integer param_id);
    int insert(ScheduleTriggerParam record);
    int insertSelective(ScheduleTriggerParam record);
    ScheduleTriggerParam selectByPrimaryKey(Integer param_id);
    int updateByPrimaryKeySelective(ScheduleTriggerParam record);
    int updateByPrimaryKey(ScheduleTriggerParam record);
    
    List<ScheduleTriggerParam> queryScheduleParamLst(Integer triggerId);
}

ScheduleTriggerParam

<select id="queryScheduleParamLst" resultType="com.wsy.quartz02.model.ScheduleTriggerParam">
    select <include refid="Base_Column_List"/>
    from t_schedule_trigger_param where schedule_trigger_id=#{triggerId}
  </select>

ScheduleTrigger

<select id="queryScheduleTriggerLst" resultType="com.wsy.quartz02.model.ScheduleTrigger">
    select <include refid="Base_Column_List"/>
    from t_schedule_trigger
  </select>

QuartzConfiguration

package com.wsy.config;
import com.wsy.quartz02.utils.MyJobFactory;
import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import java.io.IOException;
import java.util.Properties;
@Configuration
public class QuartzConfiguration {
    @Autowired
    private MyJobFactory myJobFactory;
    //创建调度器工厂
    @Bean
        public SchedulerFactoryBean schedulerFactoryBean(){
            //1.创建SchedulerFactoryBean
            //2.加载自定义的quartz.properties配置文件
            //3.设置MyJobFactory
            SchedulerFactoryBean factoryBean=new SchedulerFactoryBean();
            try {
                factoryBean.setQuartzProperties(quartzProperties());
                factoryBean.setJobFactory(myJobFactory);
                return factoryBean;
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
    }
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean=new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    @Bean(name="scheduler")
    public Scheduler scheduler(){
        return schedulerFactoryBean().getScheduler();
}

MyJob

package com.wsy.quartz02.job;
import lombok.extern.slf4j.Slf4j;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.stereotype.Component;
import java.util.Date;
@Component
@Slf4j
public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.err.println("MyJob是一个空的任务计划,时间："+new Date().toLocaleString());
    }
}

MyJob1

package com.wsy.quartz02.job;
import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.springframework.stereotype.Component;
import java.util.Date;
@Component
@Slf4j
public class MyJob1 implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobDetail jobDetail =
                jobExecutionContext.getJobDetail();
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        System.out.println(new Date().toLocaleString()+"-->携带参数个数:"+jobDataMap.size());
    }
}

MyJob2

package com.wsy.quartz02.job;
import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.springframework.stereotype.Component;
import java.util.Date;
@Component
@Slf4j
public class MyJob2 implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobDetail jobDetail =
                jobExecutionContext.getJobDetail();
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        System.out.println(new Date().toLocaleString()+"-->MyJob2参数传递name="+jobDataMap.get("name")+",score="+
                jobDataMap.get("score"));
    }
}

Quartz02Controller

package com.wsy.quartz02.controler;
import com.wsy.quartz02.model.ScheduleTrigger;
import com.wsy.quartz02.service.ScheduleTriggerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import java.util.List;

@Controller
@RequestMapping("/quartz")
public class Quartz02Controller {
    @Autowired
    private ScheduleTriggerService scheduleTriggerService;
    @RequestMapping("/list")
    public ModelAndView getAll(){
        ModelAndView mv = new ModelAndView();
        List<ScheduleTrigger> list = scheduleTriggerService.queryScheduleTriggerLst();
        mv.addObject("quartzList",list);
        mv.setViewName("index");
        return mv;
    }
    @RequestMapping("/edit")
    public String editStatus(ScheduleTrigger scheduleTrigger){
        int n = scheduleTriggerService.updateByPrimaryKeySelective(scheduleTrigger);
        return "redirect:/quartz/list";
    }
    @RequestMapping("/proSave/{id}")
    public ModelAndView proSave(@PathVariable(value = "id") Integer id){
        ModelAndView mv=new ModelAndView();
        ScheduleTrigger scheduleTrigger = scheduleTriggerService.selectByPrimaryKey(id);
        mv.addObject("schedule",scheduleTrigger);
        mv.setViewName("edit");
        return mv;
    }
}

ScheduleTriggerService

package com.wsy.quartz02.service;
import com.wsy.quartz02.model.ScheduleTrigger;
import java.util.List;

 public interface ScheduleTriggerService {
        int deleteByPrimaryKey(Integer id);
        int insert(ScheduleTrigger record);
        int insertSelective(ScheduleTrigger record);
        ScheduleTrigger selectByPrimaryKey(Integer id);
        int updateByPrimaryKeySelective(ScheduleTrigger record);
        int updateByPrimaryKey(ScheduleTrigger record);
        
        List<ScheduleTrigger> queryScheduleTriggerLst();
}

Quartz02Application

package com.wsy.quartz02;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@MapperScan("com.wsy.quartz02.mapper")
@EnableTransactionManagement
@EnableScheduling
@SpringBootApplication
public class Quartz02Application {
    public static void main(String[] args) {
        SpringApplication.run(Quartz02Application.class, args);
    }
}

界面

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>quartz定时任务管理</title>
</head>
<body>
<h1 style="text-align: center">定时任务</h1>
<table style="text-align: center" align="center" border="1px" width="50%">
    <tr>
        <td>id</td>
        <td>表达式</td>
        <td>状态</td>
        <td>工作类</td>
        <td>分组</td>
        <td>操作</td>
    </tr>
    <tr th:each="q : ${quartzList}">
        <td th:text="${q.id}"></td>
        <td th:text="${q.cron}"></td>
        <td th:text="${q.status}"></td>
        <td th:text="${q.job_name}"></td>
        <td th:text="${q.job_group}"></td>
        <td th:switch ="${q.status} == 0">
            <a th:case="true" th:href="@{/quartz/edit(id=${q.id},status=1)}" rel="external nofollow" >启动</a>
            <a th:case="false" th:href="@{/quartz/edit(id=${q.id},status=0)}" rel="external nofollow" >停止</a>
            <a th:href="@{'/quartz/proSave/'+${q.id}}" rel="external nofollow" >编辑</a>
            <a th:href="@{'/add/'}" rel="external nofollow" >增加</a>
        </td>
    </tr>
</table>
</body>
</html>

edit.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>修改定时任务</title>
</head>
<body>
<h1>修改定时任务</h1>
<form th:action="@{/quartz/edit}" method="post">
    <input type="hidden" name="id" th:value="${schedule.id}" />
    表达式： <input width="300px" type="text" name="cron" th:value="${schedule.cron}" /></br>
    工作类： <input width="300px" type="text" name="job_name" th:value="${schedule.job_name}" /></br>
    分组：<input width="300px" type="text" name="job_group" th:value="${schedule.job_group}" /></br>
    <input type="submit" value="提交"/>
</form>
</body>
</html>

到此这篇关于SpringBoot+Quartz+数据库存储的文章就介绍到这了,更多相关SpringBoot+Quartz+数据库存储内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

阅读原文内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

SpringBoot+Quartz+数据库存储的完美集合

后端开发2024-04-02

如何集合SpringBoot+Quartz+数据库存储

后端开发2023-06-29

SpringBoot结合Quartz实现数据库存储

后端开发2024-04-02

存储数据的好帮手：ASP 函数和 Spring 的完美结合。

后端开发2023-10-06

SpringBoot集成内存数据库Derby的实践

后端开发2024-04-02

SpringBoot集成内存数据库H2的实践

后端开发2024-04-02

LabVIEW与阿里云数据库的完美结合

LabVIEW与阿里云数据库的完美结合
后端开发2023-12-27

SpringBoot集成内存数据库hsqldb的实践

后端开发2024-04-02

SpringBoot集成H2内存数据库的方法

后端开发2024-04-02

SpringBoot集成内存数据库Sqlite的实践

后端开发2024-04-02

PHP与数据库存储管理的集成

后端开发2023-05-17

Redis 与 Node.js 的完美邂逅，解锁数据存储新境界

Redis 与 Node.js 的完美邂逅，解锁数据存储新境界
后端开发2024-04-03

从RAG到TAG：探索AI与数据库的完美结合

后端开发TAG模型2024-11-29

如何将ASP索引与numpy存储完美结合，以提高数据处理效率？

后端开发2023-08-20

Java集合框架：洞悉集合容器的奥秘，掌握数据存储的艺术

Java集合框架：洞悉集合容器的奥秘，掌握数据存储的艺术
后端开发2024-02-22

Oracle数据库分区技术：优化大型数据集的存储效率！

后端开发数据库Oracle2024-11-30

数据库与云服务的完美结合：缔造卓越业务

数据库与云服务的完美结合：缔造卓越业务
后端开发2024-04-02

MAGNet怎么与现有的数据库和存储系统集成

MAGNet怎么与现有的数据库和存储系统集成
后端开发2024-05-21

铁威马D8 Hybrid硬盘柜：冷热数据存储的完美解决方案

后端开发铁威马D8Hybr2024-11-29

Scopus 数据采集并转化为 Python 中的 DataFrame 格式，并存储到 MySQL 数据库

后端开发2023-10-10
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯