Spring boot集成Quartz与RabbitMQ

最新推荐文章于 2026-04-24 09:21:52 发布
原创 最新推荐文章于 2026-04-24 09:21:52 发布 · 1.9k 阅读 · 7 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
该博客介绍了一个Spring Boot项目，演示了如何集成Quartz和RabbitMQ。通过Quartz定时向RabbitMQ发送消息，客户端接收并处理消息。项目中使用Spring Boot JPA和Hibernate处理数据层，Quartz配置为集群模式，确保高可用。同时，讨论了在不同服务器上运行Quartz集群时可能遇到的时间同步问题。

完成一个本地demo的小项目。
在Spring boot中集成Quartz与RabbitMQ，完成通过Quartz定时向RabbitMQ发送消息，并且在客户端监听RabbitMQ队列的消息并进行处理。同时针对Quartz使用了集群特性。

数据层采用Spring boot jpa，用Hibernate简易处理了下CRUD。

环境准备

  • 数据库中建立业务存储表
    t_account 账户表
    t_order 订单表
    t_order_process_detail 订单处理详情表
DROP TABLE IF EXISTS t_order;
DROP TABLE IF EXISTS t_order_process_detail;
DROP TABLE IF EXISTS t_account;

CREATE TABLE t_order(
    id int(20) NOT NULL AUTO_INCREMENT,
    account_id int(20),
    order_process_detail_id int(20),
    order_no varchar(40) NOT NULL,
    order_price decimal(10,2),
    pay_status varchar(20),
    process_status varchar(20),
    primary KEY (id)
)ENGINE=InnoDB;

CREATE TABLE t_order_process_detail(
    id int(20) NOT NULL AUTO_INCREMENT,
    detail varchar(500),
    primary KEY (id)
)ENGINE=InnoDB;

CREATE TABLE t_account(
    id int(20) NOT NULL AUTO_INCREMENT,
    name varchar(200),
    balance decimal(10,2),
    primary KEY (id)
)ENGINE=InnoDB;

  • 需要在本地，或者虚拟机中安装RabbitMQ服务器（安装过程略）

  • 为了实现Quartz的集群配置，需要在数据库中添加Quartz的存储表。建表语句可以在Quartz的jar包的docs文件下找到适合所使用数据库的sql文件。这里使用的MySQL的innodb建表语句。

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;

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))
ENGINE=InnoDB;

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))
ENGINE=InnoDB;

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))
ENGINE=InnoDB;

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(120) 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))
ENGINE=InnoDB;

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))
ENGINE=InnoDB;

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),
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

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))
ENGINE=InnoDB;

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

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))
ENGINE=InnoDB;

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))
ENGINE=InnoDB;

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

CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);

CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);

CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);

commit;

项目配置

  • maven .pom文件
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>ecloud.demo</groupId>
    <artifactId>rabbitquartz</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>rabbitquartz</name>
    <url>http://maven.apache.org</url>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.1.RELEASE</version>
        <relativePath />
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.13</version>
        </dependency>

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

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

    </dependencies>
</project>
  • Spring boot的application.yml配置
server:
  port: 80

spring:
  application:
    name: rabbitquartz
  datasource:
    name: druid
    url: jdbc:mysql://localhost:3306/quartz
    username: admin
    password: admin
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 'x' FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20
    filters: stat,wall,log4j
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
  rabbitmq:
    host: 192.168.200.214
    port: 5672
    username: root
    password: root
    virtual-host: /
    publisher-confirms: true
    listener:
      prefetch: 1
  jpa:
    database: MYSQL
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL5Dialect
  • Quartz的配置
    quartz.properties
#============================================================================
# Configure JobStore
# Using Spring datasource in SchedulerConfig.java
# Spring uses LocalDataSourceJobStore extension of JobStoreCMT
#============================================================================
org.quartz.jobStore.useProperties=false
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.isClustered = true
org.quartz.jobStore.clusterCheckinInterval = 5000
org.quartz.jobStore.misfireThreshold = 60000
org.quartz.jobStore.txIsolationLevelReadCommitted = true
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate

#============================================================================
# Configure Main Scheduler Properties
# Needed to manage cluster instances
#============================================================================
org.quartz.scheduler.instanceName = ClusterQuartz
org.quartz.scheduler.instanceId= AUTO
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false

#============================================================================
# Configure ThreadPool
# Can also be configured in spring configuration
#============================================================================
#org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
#org.quartz.threadPool.threadCount = 5
#org.quartz.threadPool.threadPriority = 5
#org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

QuartzConfig.java

package ecloud.demo.rabbitquartz.config;

import java.io.IOException;
import java.util.Properties;
import java.util.concurrent.Executor;

import javax.sql.DataSource;

import org.quartz.Scheduler;
import org.quartz.spi.JobFactory;
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.concurrent.ThreadPoolTaskExecutor;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import ecloud.demo.rabbitquartz.infra.quartz.AutowiringJobFactory;
import ecloud.demo.rabbitquartz.infra.quartz.QuartzJob;

@Configuration
public class QuartzConfig {

    // TODO 多台服务器的时间同步问题

    @Autowired
    private DataSource dataSource;

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();

        factory.setSchedulerName("Cluster_Scheduler");
        factory.setDataSource(dataSource);
        factory.setApplicationContextSchedulerContextKey("applicationContext");
        factory.setTaskExecutor(schedulerThreadPool());
        factory.setTriggers(quartzTrigger().getObject());
        factory.setQuartzProperties(quartzProperties());
        factory.setJobFactory(autowiringJobFactory());
        factory.setOverwriteExistingJobs(true);
        factory.setStartupDelay(15);
        return factory;
    }

    @Bean
    public JobFactory autowiringJobFactory() {
        return new AutowiringJobFactory();
    }

    @Bean
    public Scheduler scheduler() throws Exception {
        Scheduler scheduler = schedulerFactoryBean().getScheduler();
        scheduler.start();
        return scheduler;
    }

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));

        // 在quartz.properties中的属性被读取并注入后再初始化对象
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    @Bean
    public JobDetailFactoryBean quartzJob() {
        JobDetailFactoryBean jobDetailFactoryBean = new JobDetailFactoryBean();

        jobDetailFactoryBean.setJobClass(QuartzJob.class);
        jobDetailFactoryBean.setDurability(true);
        jobDetailFactoryBean.setGroup("order");
        jobDetailFactoryBean.setName("order_job");
        jobDetailFactoryBean.setRequestsRecovery(true);

        return jobDetailFactoryBean;
    }

    @Bean
    public CronTriggerFactoryBean quartzTrigger() {
        CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();

        cronTriggerFactoryBean.setJobDetail(quartzJob().getObject());
        cronTriggerFactoryBean.setCronExpression("0/15 * * * * ?");

        return cronTriggerFactoryBean;
    }

    @Bean
    public Executor schedulerThreadPool() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

        executor.setCorePoolSize(15);
        executor.setMaxPoolSize(25);
        executor.setQueueCapacity(100);

        return executor;
    }
}

Quartz的两个相关类
AutowiringJobFactory.java
这个类是用来为QuartzJob中的属性进行Spring IoC注入

package ecloud.demo.rabbitquartz.infra.quartz;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;

public class AutowiringJobFactory extends AdaptableJobFactory {

    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object jobInstance = super.createJobInstance(bundle);
        // IoC injection
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

QuartzJob类

package ecloud.demo.rabbitquartz.infra.quartz;

import java.util.List;

import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.PersistJobDataAfterExecution;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;

import ecloud.demo.rabbitquartz.business.entity.Order;
import ecloud.demo.rabbitquartz.business.service.RabbitQuartzService;
import ecloud.demo.rabbitquartz.infra.rabbitmq.RabbitSender;

@Component
@PersistJobDataAfterExecution
// 禁止任务并发执行
@DisallowConcurrentExecution
public class QuartzJob extends QuartzJobBean {

    private final Logger logger = LoggerFactory.getLogger(QuartzJob.class);

    @Autowired
    private RabbitQuartzService rabbitQuartzService;

    @Autowired
    private RabbitSender rabbitSender;

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {

        List<Order> orderList = rabbitQuartzService.getAllOrdersToBeProcessed();

        if (orderList.size() > 0) {
            rabbitSender.send(orderList.get(0).getId());
        }

        logger.info("End quartz job \n");
    }

}
  • RabbitMQ的配置
    RabbitMQ的一部分配置包含在Spring boot的application.yml文件中

RabbitConfig.java

package ecloud.demo.rabbitquartz.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import ecloud.demo.rabbitquartz.business.service.RabbitQuartzService;

/*
 * Spring Boot中消息接受处理完后，若无异常，则由Spring Boot发送消息接受确认。
 * spring.rabbitmq.listener.prefetch控制QoS。
 */
@Configuration
@EnableRabbit
public class RabbitConfig {

    private final Logger logger = LoggerFactory.getLogger(RabbitConfig.class);

    public static final String ORDER_ROUTING_KEY = "order_key";

    public static final String ORDER_QUEUE = "order_queue";

    public static final String ORDER_EXCHANGE = "order_exchange";

    @Bean
    Queue orderQueue() {
        return new Queue(ORDER_QUEUE);
    }

    @Bean
    DirectExchange orderExchange() {
        return new DirectExchange(ORDER_EXCHANGE);
    }

    @Bean
    Binding bindingExangeQueue() {
        return BindingBuilder.bind(orderQueue()).to(orderExchange()).with(ORDER_ROUTING_KEY);
    }

    @Bean
    RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory, RabbitQuartzService rabbitQuartzService) {
        final RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);

        // 发送确认的回调方法，配合rabbitmq.publisher-confirms=true
        rabbitTemplate.setConfirmCallback((correlationData, b, s) -> {
            if (b) {
                logger.info("Sending OK");
            } else {
                logger.error("Sending failed, cause: " + s);
            }
        });

        rabbitTemplate.setMessageConverter(messageConverter());

        return rabbitTemplate;
    }

    @Bean
    Jackson2JsonMessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }
}
  • Hibernate配置
    HibernateConfig.java
package ecloud.demo.rabbitquartz.config;

import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@Configuration
@EntityScan(basePackages = "ecloud.demo.rabbitquartz.business")
@EnableJpaRepositories(basePackages = "ecloud.demo.rabbitquartz.business")
public class HibernateConfig {

}

剩余的部分就是传统的Spring项目，业务层，dao层等等。
项目结构：
这里写图片描述

项目运行

复制项目后，只需要修改application.yml中的server port，就可以模拟同时启动多个服务器实例。
丰富Controller层的接口以后，可以通过postman等工具来完成订单创建等。

我们也可以观察到多个服务器同时运行模拟了一个Quartz集群，只在一个服务器中有QuartzJob的执行，并且一旦该服务器被关闭，QuartzJob可以在剩余可用的服务器中被执行。

同时观察RabbitMQ服务器，可以发现在配置的队列中（这里是order_queue），有消息的进入以及被消费。

待解决问题

在当前项目中，Quartz的集群是在同一个主机上运行的。如果服务器的示例是在不同的服务器中需要考虑服务器的时间同步。关于这一点，我还没想好。

代码下载

全部代码下载链接：
https://github.com/wanghaoalain/rabbitquartz.git

activeMQ 与 quartz 事例
03-19
NULL 博文链接：https://ycljf86.iteye.com/blog/700926
大数据互联网架构阶段 QuartZ定时任务+RabbitMQ消息队列
热门推荐
chou_out_man的博客
02-02 1万+
QuartZ定时任务+RabbitMQ消息队列 一 、QuartZ定时任务解决订单系统遗留问题 情景分析: 在电商项目中 ， 订单生成后 ， 数据库商品数量-1 ， 但是用户迟迟不进行支付操作 ， 这样不仅导致没有生成效益， 而且导致后来的用户无法购买的问题 。 这种情况的订单成为恶意订单 解决方案： 早期： 虚拟商品数量 ， 数量减到0时 ，仍然可以减。 但是这种办法显然没有根本的...
超详细的RabbitMQ笔记
m0_64416017的博客
10-28 264
详细介绍RabbitMQ，从概念到安装到玩转，细节满满，带你轻松上手MQ
Darwin Gödel Machine：构建能自我进化的AI编程智能体
最新发布
weixin_33709590的博客
04-24 438
在人工智能与软件工程交叉领域，智能体（Agent）技术正成为自动化编程和代码生成的核心范式。其原理在于通过大语言模型（LLM）赋予系统理解任务、规划步骤和执行代码的能力，从而模拟人类程序员的思维过程。这项技术的核心价值在于能够显著提升开发效率，自动化处理重复性编码任务，并在复杂问题求解中提供辅助。典型的应用场景包括自动代码补全、Bug修复、单元测试生成以及系统架构优化等。本文聚焦的Darwin Gödel Machine项目，正是这一技术前沿的深度实践。它创新性地将“达尔文式进化”的实证验证思想与“哥德尔机
[中间件] RabbitMQ 的 Exchange 和 Queue 绑定：实现高效消息传递的关键步骤
2301_79528833的博客
09-18 2766
Exchange 和 Queue 绑定是 RabbitMQ 中实现消息路由的关键步骤。通过为 Exchange 和 Queue 建立绑定关系，我们可以确保消息能够被准确路由到对应的消费者，从而实现精确的消息传递。在 Spring Boot 中，我们可以通过配置文件或配置类的方式来进行 Exchange 和 Queue 的绑定，从而实现消息的传递。
RabbitMQ + Quartz +Swagger 使用记录
weixin_33755847的博客
06-11 555
1、RabbitMQ概述 1、官方解释 RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而群集和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。 Erlang是一种通用的面向并发的编程语言，它由瑞典电信设备制造商爱立信所辖的CS-Lab开发，目的是创造一种可以应对...
RabbitMQ
m0_72710328的博客
01-19 183
我们为什么需要rabbitmq
基于Spring Boot的医疗设备维护平台
2301_79727522的博客
02-10 683
Java领域优质创作者🏆、专注于Java技术领域和学生毕业项目实战,高校老师/讲师/同行交流合作。
Spring 5.2.8测试依赖汇总
m0_37607945的博客
04-21 494
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0
Spring Boot 企业级开发
weixin_67145605的博客
09-13 1362
《Spring Boot企业级开发教程（第2版）》 黑马程序员 著
SpringBoot所有的Starter以及常用依赖
A_java_c的博客
08-10 2034
官网 官网 列表 spring-boot-starter Core starter, including auto-configuration support, logging and YAML spring-boot-starter-activemq Starter for JMS messaging using Apache ActiveMQ spring-boot-starter-amqp Starter for using Spring AMQP and Rabbit MQ
springboot信用卡管理系统设计开发实现
2501_93250029的博客
01-27 262
Spring Boot信用卡管理系统通过技术标准化、业务模块化、数据资产化，解决了传统管理的痛点，同时为金融创新（如虚拟信用卡、区块链征信）预留扩展空间，具有显著的商业价值和社会效益。
springboot继承组件_GitHub - superleeyom/spring-boot-learning: Spring Boot 学习笔记，Spring Boot 与各种其他技术或者组件的集...
weixin_42600407的博客
02-22 572
目录Spring Boot 集成测试和部署运维测试用的类，需要在类的头部添加 @RunWith(SpringRunner.class) 和 @SpringBootTest 注解。@RunWith(SpringRunner.class)@SpringBootTestpublic class TestUserService {}测试常用的注解和类：@Test：Junit 常用注解...
Spring Boot 实现延时任务的 4 种方式：Redis、RabbitMQ、Quartz、时间轮对比
nihao2q的博客
08-28 1241
七、总结与实践建议简单场景（如订单取消）：推荐 Redis ZSet，实现快，依赖轻高并发场景（消息延迟）：推荐 RabbitMQ/Kafka 延时队列复杂调度任务（多任务依赖、分布式调度）：选择 Quartz + DB高性能定时器（游戏、缓存刷新）：可用 时间轮在实际开发中，可以根据 任务可靠性、并发量、可维护性 来选择合适的方案。四、基于 Quartz 的延时任务1. 思路Quartz 是专业的任务调度框架，支持 CRON 表达式、持久化、分布式，适合复杂的调度任务。// 消费任务（定时扫描）
使用Spring Boot集成中间件：基础篇
m0_68856746的博客
01-10 2553
Spring Boot是一个非常流行的Java开发框架，它提供了许多常用的中间件和技术栈集成。下面是一些常用的中间件和技术栈，可以与Spring Boot一起使用：
Spring Boot整合Quartz教程
gitblog_00301的博客
08-30 519
Spring Boot整合Quartz教程 项目介绍 Spring Boot整合Quartz项目是一个基于Spring Boot框架的任务调度系统，利用Quartz开源任务调度库实现定时任务的管理和执行。Quartz是一个功能强大的开源任务调度框架，广泛应用于需要定时执行任务的系统中。 项目快速启动 环境准备 JDK 1.8或更高版本 Maven 3.x IntelliJ IDEA或Eclips...
开源项目推荐：Spring Boot 结合 Quartz 与 RabbitMQ 的任务调度管理
gitblog_00395的博客
01-14 349
开源项目推荐：Spring Boot 结合 Quartz 与 RabbitMQ 的任务调度管理 1. 项目基础介绍 本项目是基于Spring Boot框架的开源项目，主要使用Java语言进行开发。项目整合了Quartz任务调度框架、RabbitMQ消息队列以及H2内存数据库，提供了一个动态任务管理的Web控制台。通过该项目，开发者可以轻松实现定时任务的管理和调度，同时利用RabbitMQ进行任务执...
Spring Boot 整合 Quartz 教程
gitblog_00273的博客
08-30 406
Spring Boot 整合 Quartz 教程 1. 项目的目录结构及介绍 springboot-quartz/ ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ └── com/ │ │ │ └── example/ │ │ │ ├── config/ │ │ │ ...
Spring Boot Demo 项目教程
gitblog_00491的博客
04-06 694
Spring Boot Demo 项目教程 1. 项目介绍 Spring Boot Demo 是一个基于 Spring Boot 的开源项目，它包含了多种组件的集成示例，如 Redis、Solr、RocketMQ 等。该项目旨在帮助开发者快速理解和掌握 Spring Boot 的使用，以及如何在项目中集成各种常用的技术栈。 2. 项目快速启动 要快速启动 Spring Boot Demo，请按照以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值