spring boot elastic job 整合-定时任务

最新推荐文章于 2024-10-24 17:22:55 发布
最新推荐文章于 2024-10-24 17:22:55 发布
阅读量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
关注
专栏目录
spring boot + job（定时器）
xiao4_muxin的博客
03-01 3069
一：创建springboot项目的时候自动加载job所需的类 二：创建job类 package com.demo.job; import java.util.Date; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation...
Spring Boot 整合定时任务，可以动态编辑的定时任务
江南一点雨的专栏
03-09 4584
定时任务，松哥之前写过多篇文章和大家介绍，上次还自己 DIY 了一个可以动态编辑的定时任务，还录了一个配套视频： 相关的资料链接戳这里： Spring 定时任务玩出花！ 手把手教你定制可编辑的定时任务！ 开发可配置的定时任务～第二弹 Vue非典型用法，一个简单的管理页面 不过我们当时自己写的这个不支持分布式环境，想要支持倒也不是啥难事，弄一个 zookeeper 或者 redis 作为公共的信息中心，里边记录了定时任务的各种运行情况，有了这个就能支持分布式环境了。 今天咱们不自己写了，我们来看一个现成
SpringBoot教程（二十二） | SpringBoot实现分布式定时任务之elastic-job
qq_20236937的博客
08-15 1575
SpringBoot实现分布式定时任务之elastic-job
SpringBoot几种定时任务的实现方式
weixin_34192732的博客
10-30 535
定时任务实现的几种方式： Timer：这是java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。ScheduledExecutorService：也jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任...
springboot整合 xxl-job
此人很懒
07-25 2463
如果启动失败，检查配置文件的值是否一致，如accessToken的值。
springboot整合xxl-job
学海无涯,我用JAVA
06-13 7688
单机模式中的定时任务很简单,一般使用@EnableScheduling 就可以了,但是在集群中,这个简单的定时任务就不行了,会有问题;例如我要在半夜12点执行一个任务,发送一条短信给一个用户,但是当为集群的时候,这种简单的任务,在多个节点上,都会执行,那么就会造成任务的重复执行,每个用户都接受到了多条相同的短信,这种错误还好,但是当涉及到计算等问题的时候,这种错误就是致命的,而且当没有集群经验的时候,这种问题在单机情况下还是正常,集群就会出现大问题!!!
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-...
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-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的控制台版本，支持在...
分布式调度任务架构elastic job的spring-boot-starter自动装载模块
06-06
所以博主自己开发了一个elastic job 的spring boot starter自动装载模块；目前 该starter已经在公司多个项目生产环境运行。研发只需关注实现job和在application.yml增 加相应配置即可。 模块运行环境： 1.JDK...
Spring-boot整合elastic-job分布式调度解决方案，Java全栈知识体系
2401_83620690的博客
03-28 863
学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。下方即为我手绘的MyBtis知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的MyBtis知识脑图原件（包括上方的面试解析xmind文档）
SpringBoot集成系列--xxlJob
程序员Forlan的博客
12-07 4701
本文提供了搭建调度中心xxl-job-admin的步骤，包括下载项目、调整项目参数、执行初始化数据库SQL、启动项目和访问。同时，还介绍了在Spring Boot中集成xxl-job的步骤，包括添加依赖、配置执行器、创建执行器和开发任务。最后，介绍了两种任务开发方式，BEAN模式和GLUE模式，并进行了测试。
SpringBoot篇（任务）
最新发布
wlcass zhengge blog
10-24 737
springboot整合第三方技术第二部分我们来说说任务系统，其实这里说的任务系统指的是定时任务。定时任务是企业级开发中必不可少的组成部分，诸如长周期业务数据的计算，例如年度报表，诸如系统脏数据的处理，再比如系统性能监控报告，还有抢购类活动的商品上架，这些都离不开定时任务。本节将介绍两种不同的定时任务技术。Quartz技术是一个比较成熟的定时任务框架，怎么说呢？有点繁琐，用过的都知道，配置略微复杂。
Springboot——集成Elastic Job实现任务调度
tang_seven的博客
05-08 2367
Sprngboot集成elatic job，进行分布式任务调度（分布式架构下的定时任务）
SpringBoot整合DataX数据同步（自动生成job文件）
陌殇殇的博客
07-03 1748
Springboot整合datax配置生成json文件进行数据同步,mysql和elasticsearch数据同步
SpringBoot 集成 xxl-job 实现定时任务管理
weixin_45626288的博客
07-05 3665
XXL-Job是一个功能强大的分布式任务调度框架，集成了Spring Boot后能够发挥更大的优势。它提供了分布式任务调度、任务执行报告、任务调度中心、良好的扩展性、分布式集群部署、监控与报警等多种优势。此外，XXL-Job是开源免费的，可以在GitHub上获取源代码和详细文档。详细的文档和使用指南可以在XXL-Job的官方文档中找到。
Springboot与ElasticJob
渔阳的博客
07-29 440
zookeeper注册中心 这段配置代码固定不变，直接使用即可。Elastic-Job任务类。elastic-job配置类。
springboot项目中引入Xxl-Job并部署和使用
m0_69594200的博客
05-08 1663
xxl-job是分布式任务调度平台，部署为独立的调度服务平台。
SpringBoot项目中实现job定时任务—极简版
热门推荐
code_monkey的博客
01-21 19万+
人工智能，零基础入门！http://www.captainbed.net/inner 现在的web项目中很多场景下都有要执行定时任务的需求，比如说每隔5秒将redis中的统计当天注册用户数持久化到数据库。现在项目中实现这一功能，一般用quartz这一工具框架，但是这个对于一个新手来说比较麻烦，各种查资料配置之类的。后面我接触到一种比较方便快速实现job任务的方法，总结下来： 一、项目文件结...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值