spring boot elastic job 整合-定时任务

最新推荐文章于 2024-07-25 15:53:40 发布
最新推荐文章于 2024-07-25 15:53:40 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： 定时任务执行 文章标签： 定时 elastic-job
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/styhm/article/details/81034729
版权

一、采用当当网elastic job，实现spingboot启动注入定时任务，任务配置在数据库，可以动态加载任务配置。

上干货

引入jar

    <properties>
        <elastic-job.version>2.1.5</elastic-job.version>
    </properties>

        <!-- 引入elastic-job-lite核心模块 -->
        <dependency>
            <artifactId>elastic-job-common-core</artifactId>
            <groupId>com.dangdang</groupId>
            <version>${elastic-job.version}</version>
        </dependency>
        <dependency>
            <artifactId>elastic-job-lite-core</artifactId>
            <groupId>com.dangdang</groupId>
            <version>${elastic-job.version}</version>
        </dependency>
        <dependency>
            <artifactId>elastic-job-lite-spring</artifactId>
            <groupId>com.dangdang</groupId>
            <version>${elastic-job.version}</version>
        </dependency>

定义任务载体

package cn.quantgroup.cashloanflow.config.jobevent.job;

import cn.quantgroup.cashloanflow.service.job.ITimeJobService;
import cn.quantgroup.cashloanflow.util.DateUtil;
import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;
/**
 * 每一小时扫描CallbackFailRecord表
 */
@Slf4j
@Component
public class CallbackFailSimpleJob implements SimpleJob {

    @Autowired
    private ITimeJobService timeJobService;


    @Override
    public void execute(ShardingContext shardingContext) {
        log.info("[CallbackFailRecord回调失败监控][JobName:{}] [ShardingItem:{}] [ShardingTotalCount:{}] [TaskId:{}] [JobParameter:{}] [Time:{}] start",
                shardingContext.getJobName(), shardingContext.getShardingItem(), shardingContext.getShardingTotalCount(), shardingContext.getTaskId(), shardingContext.getJobParameter(), DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
         timeJobService.callbackFailSendMsg();
    }
}

注册加载定时任务

package cn.quantgroup.cashloanflow.config.jobevent;

import cn.quantgroup.cashloanflow.entity.cashloanflow.ElasticJobConfig;
import cn.quantgroup.cashloanflow.repository.cashloanflow.IElasticJobConfigRepository;
import cn.quantgroup.cashloanflow.util.ApplicationContextHolder;
import com.dangdang.ddframe.job.api.ElasticJob;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.dangdang.ddframe.job.config.JobCoreConfiguration;
import com.dangdang.ddframe.job.config.JobTypeConfiguration;
import com.dangdang.ddframe.job.config.simple.SimpleJobConfiguration;
import com.dangdang.ddframe.job.event.JobEventConfiguration;
import com.dangdang.ddframe.job.lite.config.LiteJobConfiguration;
import com.dangdang.ddframe.job.lite.spring.api.SpringJobScheduler;
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperRegistryCenter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.List;

/**
 * 可以动态改变任务，（JobConfigUpdateController 提供接口）
 * Created with suntao on 2019/3/19
 */
@Slf4j
@Component
public class ElasticJobLoader2 implements CommandLineRunner {

    @Autowired
    private IElasticJobConfigRepository elasticJobConfigRepository;

    @Resource
    private ZookeeperRegistryCenter zookeeperRegistryCenter;

    @Resource
    private JobEventConfiguration jobEventConfiguration;



    @Override
    public void run(String... args) {

        List<ElasticJobConfig> elasticJobConfigList = elasticJobConfigRepository.findAllActive();
        if (elasticJobConfigList == null || elasticJobConfigList.size() == 0) {
            return;
        }
        elasticJobConfigList.forEach(elasticJobConfig -> registryJob(elasticJobConfig));
        log.info("所有定时任务加载完成");
    }


    /**
     * 重新加载任务
     * @param ids
     */
    public void reloadJobByIds(List<Long> ids) {
        List<ElasticJobConfig> elasticJobConfigList = elasticJobConfigRepository.findAll(ids);
        elasticJobConfigList.forEach(elasticJobConfig -> registryJob(elasticJobConfig));
    }

    private void registryJob(ElasticJobConfig elasticJobConfigBean) {
        try {
            Class<? extends ElasticJob> jobClass = (Class<? extends ElasticJob>) Class
                    .forName(elasticJobConfigBean.getJobClass());
            ElasticJob elasticJob = getInstance(jobClass);
            SpringJobScheduler jobScheduler = jobScheduler(elasticJob, elasticJobConfigBean);
            jobScheduler.init();
            log.info("初始化定时任务 {} ", elasticJobConfigBean.toString());
        } catch (Exception e) {
            log.error("注册Job出错：{} ", elasticJobConfigBean.toString(), e);
        }

    }


    /**
     * @param jobClass
     * @return
     */
    private ElasticJob getInstance(Class<? extends ElasticJob> jobClass) {
        ElasticJob bean = ApplicationContextHolder.getBean(jobClass);
        return bean;
    }

    /**
     * 注册SpringJobScheduler
     *
     * @param elasticJob
     * @param elasticJobConfigBean
     * @return
     */
    private SpringJobScheduler jobScheduler(ElasticJob elasticJob, ElasticJobConfig elasticJobConfigBean) {
        LiteJobConfiguration build = LiteJobConfiguration.newBuilder(jobConfiguration(elasticJob, elasticJobConfigBean))
                .overwrite(true).build();
        SpringJobScheduler springJobScheduler = new SpringJobScheduler(elasticJob, zookeeperRegistryCenter, build,
                jobEventConfiguration);
        return springJobScheduler;
    }

    /**
     * job配置
     *
     * @param elasticJob
     * @param elasticJobConfigBean
     * @return
     */
    private JobTypeConfiguration jobConfiguration(final ElasticJob elasticJob,
                                                  ElasticJobConfig elasticJobConfigBean) {
        JobCoreConfiguration jobCoreConfiguration = JobCoreConfiguration
                .newBuilder(elasticJobConfigBean.getJobName(), elasticJobConfigBean.getCron(),
                        elasticJobConfigBean.getShardingTotalCount())
                .shardingItemParameters(elasticJobConfigBean.getShardingItemParameters())
                //.misfire(Boolean.valueOf(elasticJobConfigBean.getMisfire()))
                .description(elasticJobConfigBean.getDescription())
                //.failover(Boolean.valueOf(elasticJobConfigBean.getFailover()))
                .jobParameter(elasticJobConfigBean.getJobParameter())
                .build();
        if (elasticJob instanceof SimpleJob) {
            return new SimpleJobConfiguration(jobCoreConfiguration, elasticJob.getClass().getCanonicalName());
        }
//        if (elasticJob instanceof DataflowJob) {
//            return new DataflowJobConfiguration(jobCoreConfiguration, elasticJob.getClass().getCanonicalName(),
//                    Boolean.valueOf(elasticJobConfigBean.getStreamingProcess()));
//        }
        throw new RuntimeException("未知类型定时任务：" + elasticJob.getClass().getName());
    }


}

任务配置config，引入DateSource，在加载时，读取数据库任务配置表

package cn.quantgroup.cashloanflow.config.jobevent;

import com.dangdang.ddframe.job.event.JobEventConfiguration;
import com.dangdang.ddframe.job.event.rdb.JobEventRdbConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;
import javax.sql.DataSource;

/**
 * 为job配置数据源
 * Created with suntao on 2019/3/19
 */
@Configuration
public class JobEventConfig {

    @Resource
    private DataSource dataSource;

    @Bean
    public JobEventConfiguration jobEventConfiguration() {
        return new JobEventRdbConfiguration(dataSource);
    }
}

sql:

CREATE TABLE `elastic_job_config` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `job_name` varchar(255) NOT NULL COMMENT '作业名称',
  `cron` varchar(50) NOT NULL COMMENT 'cron表达式，用于控制作业触发时间',
  `sharding_total_count` int(3) NOT NULL COMMENT '作业分片总数',
  `sharding_item_parameters` varchar(512) DEFAULT NULL COMMENT '分片序列,列号从0开始,不可大于或等于作业分片总数.如：0=a,1=b,2=c',
  `job_parameter` varchar(512) DEFAULT NULL COMMENT '作业自定义参数',
  `failover` tinyint(4) DEFAULT NULL COMMENT '是否开启任务执行失效转移',
  `misfire` tinyint(4) DEFAULT NULL COMMENT '是否开启错过任务重新执行',
  `description` varchar(512) DEFAULT NULL COMMENT '作业描述信息',
  `job_class` varchar(512) NOT NULL COMMENT '作业实现类',
  `streaming_process` tinyint(4) DEFAULT NULL COMMENT '是否流式处理数据（只有Dataflow类型支持）',
  `job_config` text,
  `is_active` tinyint(4) NOT NULL DEFAULT '1' COMMENT '是否有效，0：否，1：是，default：1',
  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `jobName` (`job_name`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;

INSERT INTO `elastic_job_config` (`job_name`, `cron`, `sharding_total_count`, `sharding_item_parameters`, `job_parameter`, `failover`, `misfire`, `description`, `job_class`, `streaming_process`, `job_config`, `is_active`, `created_at`)
VALUES
	('callbackFailSimpleJob', '0 0 0/1 * * ? ', 1, '', NULL, NULL, NULL, '回调失败监控', 'cn.quantgroup.cashloanflow.config.jobevent.job.CallbackFailSimpleJob', NULL, NULL, 1, '2019-04-02 18:05:08'),
	('orderMappingIncrementJob', '0 */10 8-23 * * ?', 1, '', '{\"monitorDays\":7, \"fluctuate\":{\"low\":0.6, \"up\":2, \"absoluteValue\":10}, \"scanMins\":10, \"channelIdList\":[333,158748,158888,159507,159509,159513,159537,159538,159541,159561,159562,159563,159583,159584,159672,159726]}', NULL, NULL, '进件流量监控任务', 'cn.quantgroup.cashloanflow.config.jobevent.job.OrderMappingIncrementSimpleJob', NULL, NULL, 1, '2019-04-03 14:06:35');

任务额外自定义配置可以加载job_parameter中，通过

String jobParameter = shardingContext.getJobParameter();

获取自定义配置

可以通过加载器动态加载任务，当任务需要更改配置时，服务有不想重新启动，通过自定义接口调用reloadJobByIds方法。

/**
     * 重新加载任务
     * @param ids
     */
    public void reloadJobByIds(List<Long> ids) {
        List<ElasticJobConfig> elasticJobConfigList = elasticJobConfigRepository.findAll(ids);
        elasticJobConfigList.forEach(elasticJobConfig -> registryJob(elasticJobConfig));
    }

二、通过当当elastic job二次开发，再次是应用的开发好的jar，这种方式优点是每个定时任务，通过注解方式配置，方便阅读，缺点是不能动态加载任务配置，当定时任务很多时，不方便管理。

1、引入jar

        <dependency>
            <groupId>com.github.kuhn-he</groupId>
            <artifactId>elastic-job-lite-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>

该jar 是有当当网elastic job封装升级的jar

2、创建job执行类

@Component
@Slf4j
@ElasticSimpleJob(cron="* * * * * ?",jobName="test123",shardingTotalCount=2,jobParameter="测试参数",shardingItemParameters="0=A,1=B")
public class MySimpleJob implements SimpleJob {

    @Override
    public void execute(ShardingContext shardingContext) {
        log.info("itemId={}", shardingContext.getShardingItem());
    }
}ElasticSimpleJob(cron="* * * * * ?",jobName="test123",shardingTotalCount=2,jobParameter="测试参数",shardingItemParameters="0=A,1=B")
public class MySimpleJob implements SimpleJob {

    @Override
    public void execute(ShardingContext shardingContext) {
        log.info("itemId={}", shardingContext.getShardingItem());
    }
}

三、启动spring boot，定时任务即启动

1、shardingTotalCount=2，将定时任务分成两个片区，如果一台server执行，那么两个片区都由该server执行

打印结果：
2018-07-13 17:17:14.204  INFO 88070 --- [g.MySimpleJob-1] c.f.t.e.config.MySimpleJob               : itemId=0
2018-07-13 17:17:14.205  INFO 88070 --- [g.MySimpleJob-2] c.f.t.e.config.MySimpleJob               : itemId=1
2018-07-13 17:17:15.175  INFO 88070 --- [g.MySimpleJob-4] c.f.t.e.config.MySimpleJob               : itemId=0
2018-07-13 17:17:15.175  INFO 88070 --- [g.MySimpleJob-3] c.f.t.e.config.MySimpleJob               : itemId=1
2018-07-13 17:17:16.168  INFO 88070 --- [g.MySimpleJob-6] c.f.t.e.config.MySimpleJob               : itemId=0
2018-07-13 17:17:16.168  INFO 88070 --- [g.MySimpleJob-5] c.f.t.e.config.MySimpleJob               : itemId=1

此时只有一个server节点在zk注册，任务全部由该server执行

如果有多台server接入，如 server1，server2

那么server1得到分片itemId=0，server2分片itemid=1.

如果两台server，分成6片，或者7片

shardingItemParameters="0=A,1=B,2=C,3=D,4=E,5=F"

那么分片情况

server1：0，1，2

server2：3，4，5

或者分成7片：shardingItemParameters="0=A,1=B,2=C,3=D,4=E,5=F,6=G"

 

server1：0，1，2

server2：3，4，5，6

如果当server1或者server2宕机，那么会重新选举，重新负载任务到可用server

默认shardingTotalCount=1，由其中一台主server执行，其他为福server，当主server宕机，副server会顶替。

2、elastic-job定位为分布式定时任务，当任务数量级非常大的时候，可以根据需要加机器，解决定时任务原有串行执行效率问题，在解决中可以根据itemId对数据进行分组，解决重复执行问题。

 

cron：定时执行规则，可以参考：https://www.cnblogs.com/lazyInsects/p/8075487.html

 

 

小涛_foxiaotao
关注
专栏目录
elasticjob-spring-boot-starter:elasticjob-spring-boot-starter
03-29
elasticjob-spring-boot-starter 概述 Elastic-Job-Lite Spring Boot Starter。 快速开始 1.添加elasticjob-spring-boot-starter依赖项 pom.xml： <groupId>org.springframework.boot <artifactId>spring-boot-...
Elastic Job入门示例-实现原理介绍
seanme的专栏
05-11 486
Source : http://elasticjob.io/docs/elastic-job-lite/03-design/lite-design/弹性分布式实现第一台服务器上线触发主服务器选举。主服务器一旦下线，则重新触发选举，选举过程中阻塞，只有主服务器选举完成，才会执行其他任务。某作业服务器上线时会自动将服务器信息注册到注册中心，下线时会自动更新服务器状态。主节点选举，服务器上下线，分片总数...
集成elastic-job分布式调度定时任务
AnNanDu的博客
10-21 2631
定时任务这一组件在工作过程中经常使用到，在单机节点上可以直接选择使用自带的定时任务组件，而这种定时任务一旦确定固化了定时触发策略，也无法动态开启关闭，所以后来有了。是定时任务领域的一个开源项目，由开发，可以通过调度定时任务的启停及策略，还有对事务跟集群的支持等等强大功能。但是而就是当当在Quartz的基础上进行了二次封装，这两个版本除了部署方式不一样在上是一样的，相对于。
springboot整合 xxl-job
最新发布
此人很懒
07-25 1503
如果启动失败，检查配置文件的值是否一致，如accessToken的值。
Elastic-Job分布式任务调度（2）：Elastic-Job快速入门
u013938578的博客
01-03 1162
此任务在每次执行时获取一定数目的文件，进行备份处理，由File实体类的backedUp属性来标识该文件是否已备份。zookeeper要求采用3.4.6及以上版本。Maven要求3.0.4及以上版本。自行查看我的zookeeper专题。JDK要求1.7及以上版本。
分布式定时任务调度实战
长沙老码农
03-10 5855
目录 1、为什么需要定时任务 2、定时任务调度框架 2.1 单机 2.2 分布 3、xxl-job和elastic-job对比 3.1 支持集群部署方式 3.2 多节点部署任务执行方式 3.3 日志可追溯 3.4 监控告警 3.5 弹性扩容缩容 3.6 支持并行调度 3.7 高可用策略 3.8 失败处理策略 3.9 动态分片策略 3.10 总结和结论 4、xxl-job实践 4.1 下载源码 4.2 执行数据库脚本 4.3 配置调度中心文件 4.4 部署调度中心.
当当elasticJob详细版本，抽取出来成为公共部分及使用，内容有点多，需要的老铁耐心查阅。。。。。。。。
黑科技的专栏
01-26 684
抽取部分 <!--定时任务--> <dependency> <groupId>com.dangdang</groupId> <artifactId>elastic-job-lite-core</artifactId> <version>RELEASE</version> </dependency&
关于elasticjob控制台使用
诸般世界
10-30 2923
elasticjob学习了一下，其对于分布式任务及分布式定时任务的整体设计非常不错，尤其对于java伙伴来说便捷性非常高，其对于spring与zookeeper的支持非常高，部署应用相对简单，可以快速入手并应用，总体来说很友好； 关于elastic-job-lite-console控制台的使用，目前的控制台支持任务参数的修改，任务的触发、终止、追踪、详情配置等等，...
分布式调度任务架构elastic job的spring-boot-starter自动装载模块
06-06
所以博主自己开发了一个elastic job 的spring boot starter自动装载模块；目前 该starter已经在公司多个项目生产环境运行。研发只需关注实现job和在application.yml增 加相应配置即可。 模块运行环境： 1.JDK...
elastic-job-lite-console-2.1.5.zip[支持Windows/Os/Linux]
01-15
Elastic-Job是一个分布式任务调度框架，由两个独立的子项目Elastic-Job-Lite和Elastic-Job-Cloud组成。这里的"elastic-job-lite-console-2.1.5.zip"是一个压缩包，其中包含了Elastic-Job-Lite的控制台版本，支持在...
java版ss源码-elastic-job-spring-boot-starter:Elastic-JobSpringBoot自动集成，只需要
06-04
elastic-job-spring-boot-starter介绍 注意点 Spring Boot 1.X版本使用elastic-job-spring-boot-starter 1.0.1版本，配置前缀为elasticJob.xxx.xxx Spring Boot 2.X版本使用elastic-job-spring-boot-starter 1.0.2...
elastic-job-spring-boot:弹性作业springboot启动器，简化springboot集成成本
03-25
Elastic Elastic-Job-Lite为轻量级无中心化解决方案，使用罐基于quartz定时任务框架为基础的，因此已有quartz的大部分功能使用zookeeper做协调，调度中心，更轻量级完成任务的分片支持弹性扩容，可以水平扩展，当...
定时任务编写
li-zhang-yu的博客
12-06 303
定时任务模板类。
elastic-job之Simple类型作业实现
热门推荐
一不小心的程序员
05-17 1万+
1.什么是Simple类型作业？Simple类型作业意为简单实现，未经任何封装的类型。需实现SimpleJob接口。该接口仅提供单一方法用于覆盖，此方法将定时执行。与Quartz原生接口相似，但提供了弹性扩缩容和分片等功能。2. 创建Simple类型项目，通过API启动方式调用2.1 首先我们maven创建一个普通的java项目，然后在pom文件中加入下面这行引入&lt;dependency&gt...
分布式集群架构场景化解决⽅案（四）分布式调度问题
舞鹤白沙编码日志
01-26 242
调度—>定时任务，分布式调度—>在分布式集群环境下定时任务这件事 Elastic-job（当当⽹开源的分布式调度框架） 一. 定时任务的场景 定时任务形式：每隔⼀定时间/特定某⼀时刻执⾏ 例如： 订单审核、出库 订单超时⾃动取消、⽀付退款 礼券同步、⽣成、发放作业 物流信息推送、抓取作业、退换货处理作业 数据积压监控、⽇志监控、服务可⽤性探测作业 定时备份数据 ⾦融系统每天的定时结算 数据归档、清理作业 报表、离线数据分析作业 二. 什么是分
Elastic-Job 作业?任务?分片? do you know?
洪晓鸿
04-08 1145
分片机制是Elastic-Job实现分布式任务调度的关键，它使得Elastic-Job能够在分布式环境中实现作业的并行处理，提高处理速度和可靠性。 分片节点和作业执行器节点都是在Zookeeper注册中心中创建的节点，用于存储作业的分片信息和执行器信息。这些节点在Elastic-Job的分布式任务调度过程中起到协调作业执行器之间的协作作用。
springboot整合elaticjob报错
fdfdfdfvc的博客
08-06 673
springboot整合elaticjob报错 Invocation of init method failed; nested exception is java.lang.NullPointerException application.properties文件配置 elaticjob.zookeeper.server-lists=10.10.80.51:2181 elaticjob.zookeeper.namespace=my-project server.port=8766 spring.appl.
在streaming process中为什么需要类似sql查询语言
iTer的专栏
05-25 1249
从现有的CEP（Complex Event Processing）框架，像强大得Esper，我们学到很多工作完全可以通过写sql来完成的，不需要编写任何的代码。所以对于流处理我认为也需要这样的类似sql查询语言。目前像Storm这样的流处理平台框架强迫使用者去实现像silding window，一些query pattern的操作。我认为并不是每一个案例开发者都喜欢重写这些东西。所以我们需要high
elasticJob实现动态增加定时任务、动态增加定时任务、动态修改定时任务
fajing_feiyue的博客
10-14 3466
一、定时任务很多都是配置在配置文件中，但很多时候我们需要根据业务需要调整动态增删改定时任务，这里写出例子供大家参考。 （1）maven依赖 <dependency> <groupId>com.dangdang</groupId> <artifactId>elastic-job-lite-...
elasticjob springboot-start
07-30
elasticjob-springboot-start是一个用于在Spring Boot应用中集成ElasticJob分布式任务调度框架的开源项目。该项目提供了简单易用的方式，方便开发者在Spring Boot应用中使用ElasticJob来进行任务调度。 ElasticJob...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值