定时器任务处理(xxlJob,定时器,延迟任务等)

最新推荐文章于 2024-04-06 01:07:23 发布
最新推荐文章于 2024-04-06 01:07:23 发布
阅读量476 收藏 1
点赞数 1
分类专栏： java 工作实现 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59850019/article/details/131128673
版权

定时器任务处理(xxlJob,定时器,延迟任务等)

对于生活中会存在一些任务,当时不做处理,我们可以通过定时任务的方式去处理一些任务,此文就是一个操作记录的流程记录,可以做到一下几点;

1.处理时间的设定

2.处理次数的设定

3.处理结果的记录

相对而言项目中非常使用.

做一个记录使用;

1.example

表结构
在这里插入图片描述

CREATE TABLE `tasks` (
  `id` int(11) NOT NULL COMMENT '主键 id',
  `business_id` varchar(30) NOT NULL COMMENT '业务关联键',
  `business_type` int(11) DEFAULT NULL COMMENT '业务类型',
  `create_user` varchar(255) DEFAULT NULL COMMENT '创建人',
  `create_time` timestamp NULL DEFAULT NULL COMMENT '创建时间',
  `update_user` varchar(255) DEFAULT NULL COMMENT '更新人',
  `update_time` timestamp NULL DEFAULT NULL COMMENT '更新时间',
  `deal_time` timestamp NULL DEFAULT NULL COMMENT '处理时间',
  `next_deal_time` timestamp NULL DEFAULT NULL COMMENT '下次处理时间',
  `deal_count` int(255) DEFAULT NULL COMMENT '处理次数\r\n',
  `status` int(11) DEFAULT NULL COMMENT '状态(0.待处理  1.处理中  2.处理失败 3 处理完成)',
  `remark` varchar(255) DEFAULT NULL COMMENT '备注信息',
  `active` int(1) DEFAULT NULL COMMENT '是否有效(0.逻辑删除  1 存在)',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2.TasksTest-测试(可以直接使用job,或者定时器等调用)-

package com.controller;

import com.service.job.BusinessJobService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @author syh
 * @date 2023/6/9 11:03
 * @details 类描述
 */
@SpringBootTest
public class TasksTest {


    @Autowired
   private BusinessJobService businessJobService;

    @Test
    public void process(){
        businessJobService.dealTaskByType("1");
    }

}

3.BusinessJobService-任务实现

package com.service.job;

/**
 * @author syh
 * @date 2023/6/8 10:05
 * @details 类描述
 */
public interface BusinessJobService {

    /**
     * 获取对应类型的实现
     *
     * @param type
     */
    void dealTaskByType(String type);
}



package com.service.job.impl;

import com.pojo.Tasks;
import com.service.job.BusinessJobService;
import com.service.dealer.Dealer;
import com.service.job.TasksTypeEnum;
import com.service.student.StudentService;
import com.service.task.TasksService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import javax.annotation.PostConstruct;
import javax.naming.Context;
import java.util.*;

/**
 * @author syh
 * @date 2023/6/8 10:11
 * @details 类描述
 */
@Service
@Slf4j
public class BusinessJobServiceImpl implements BusinessJobService {


    @Autowired
    private TasksService tasksService;

    private Map<TasksTypeEnum, Dealer> dealerMap=new HashMap<>();

    @Autowired
    private List<Dealer> dealerList;  //获取所有的实现类


    @PostConstruct
    public void init() {
        //这种方式自动维护,当然也可以使用map每次都添加也是可以的
        for (Dealer dealer : dealerList) {
            //map定义枚举,维护枚举更好的定义规则,也可以用数字或者字符代替
            dealerMap.put(dealer.getTasksTypeEnum(), dealer);
        }
    }


    /**
     * 获取对应类型的实现
     *
     * @param type
     */
    @Override
    public void dealTaskByType(String type) {
        //获取对应任务(也可以不指定type做通用,通过对nextDealTime的设定实现想要的结果,这样就可以一对多,也可以定义多个type)
        List<Tasks> tasksList = tasksService.getTasksByType(type);
        if (!CollectionUtils.isEmpty(tasksList)) {
            for (Tasks tasks : tasksList) {
                //设置任务状态,避免安全问题
                boolean flag = tasksService.processTasks(tasks);
                if (flag) {
                    //执行待执行的任务  实现对应的实现
                    boolean result = doDeal(tasks);
                    //处理执行完的任务
                    tasksService.endTasks(result, tasks);
                }
            }
        }

    }



    /**
     * 获取业务同时执行
     *
     * @param tasks
     * @return
     */
    private boolean doDeal(Tasks tasks) {
        // 获取对应的实现类
        Dealer dealer = dealerMap.get(TasksTypeEnum.getTasksTypeEnum(tasks.getBusinessType()));
        boolean result = false;
        try {
            if (!ObjectUtils.isEmpty(dealer)) {
                result = dealer.doDeal(tasks);
            }
        } catch (Exception e) {
            log.info("业务处理异常");
            return false;
        }
        return result;
    }

    private Dealer getDealer(Integer businessType) {
        Dealer dealer = dealerMap.get(businessType);
        return dealer;
    }


}

4.TasksService-task任务记录

package com.service.task;


import com.baomidou.mybatisplus.extension.service.IService;
import com.pojo.Tasks;

import java.util.List;

/**
 * <p>
 * 服务类
 * </p>
 *
 * @author itcast
 * @since 2023-06-08
 */
public interface TasksService extends IService<Tasks> {


    /**
     * 创建任务
     *
     * @param tasks
     */
    public void createTasks(Tasks tasks);

    /**
     * 根据类型获取tasks
     *
     * @param type
     * @return
     */
    List<Tasks> getTasksByType(String type);


    /**
     * 修改待处理的任务状态
     * 设置状态  -->处理中    -->更新数据库信息   -->防止重复操作
     *
     * @param tasks
     * @return
     */
    Boolean processTasks(Tasks tasks);

    /**
     * 处理执行完的任务
     *
     * @param result
     * @param tasks
     */
    void endTasks(boolean result, Tasks tasks);
}


package com.service.task.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import com.mapper.TasksMapper;
import com.pojo.Tasks;
import com.service.job.TasksTypeEnum;
import com.service.task.TasksService;
import com.service.task.TasksStatusEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.Date;
import java.util.List;

import static java.time.LocalTime.now;

/**
 * @author syh
 * @date 2023/6/8 14:16
 * @details 详情
 */
@Slf4j
@Service
public class TasksServiceImpl extends ServiceImpl<TasksMapper, Tasks> implements TasksService {


    /**
     * 创建任务
     *
     * @param tasks
     */
    public void createTasks(Tasks tasks) {


    }

    /**
     * 根据类型获取tasks
     *
     * @param type
     * @return
     */
    @Override
    public List<Tasks> getTasksByType(String type) {
        //获取对应类型的任务
        LambdaQueryWrapper<Tasks> queryWrapper = new LambdaQueryWrapper<>();
        // 业务类型
        queryWrapper.eq(Tasks::getBusinessType, Integer.valueOf(type));
        queryWrapper.eq(Tasks::getActive, 1);
        //获取  0 未处理的   3 处理失败  的任务
        queryWrapper.in(Tasks::getStatus, Arrays.asList(0, 3));
        //下次处理的时间   <<可控>>
        queryWrapper.le(Tasks::getNextDealTime, new Date());
        List<Tasks> list = this.list(queryWrapper);
        return list;
    }


    /**
     * 修改待处理的任务状态
     * 设置状态  -->处理中    -->更新数据库信息   -->防止重复操作
     *
     * @param tasks
     * @return
     */
    public Boolean processTasks(Tasks tasks) {
        LambdaUpdateWrapper<Tasks> updateWrapper = getUpdateTasksBySystem(tasks);
        //此处避免多线程多任务安全问题
        updateWrapper.eq(Tasks::getStatus, tasks.getStatus());
        // 设置任务为进行中
        updateWrapper.set(Tasks::getStatus, TasksStatusEnum.DOING.getCode());
        //更新指定的字段
        boolean updateBoolean = update(updateWrapper);
        return updateBoolean;
    }


    /**
     * 处理执行完的任务
     *
     * @param result
     * @param tasks
     */
    public void endTasks(boolean result, Tasks tasks) {
        LambdaUpdateWrapper<Tasks> updateWrapper = getUpdateTasksBySystem(tasks);
        updateWrapper.eq(Tasks::getStatus, TasksStatusEnum.DOING.getCode());
        // 设置任务成功
        updateWrapper.set(Tasks::getStatus, TasksStatusEnum.SUCCESS.getCode());
        //次数加1
        updateWrapper.set(Tasks::getDealCount, tasks.getDealCount() + 1);
        //更新指定的字段
        boolean updateBoolean = update(updateWrapper);
    }

    private LambdaUpdateWrapper<Tasks> getUpdateTasksBySystem(Tasks tasks) {
        LambdaUpdateWrapper<Tasks> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(Tasks::getUpdateUser, "系统");
        updateWrapper.set(Tasks::getUpdateTime, new Date());
        //处理时间
        updateWrapper.set(Tasks::getDealTime, new Date());
        updateWrapper.eq(Tasks::getId, tasks.getId());
        return updateWrapper;
    }
}

5.枚举任务类(TasksTypeEnum,TasksStatusEnum)

package com.service.task;

/**
 * @author syh
 * @date 2023/6/8 16:14
 * @details 类描述
 */
public enum TasksTypeEnum {

    /**
     *
     */
    ONE(1, "StudentService");


    private Integer code;

    private String desc;

    public Integer getCode() {
        return code;
    }

    public String getDesc() {
        return desc;
    }

    TasksTypeEnum(Integer code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public static TasksTypeEnum getTasksTypeEnum(Integer code) {

        for (TasksTypeEnum typeEnum : TasksTypeEnum.values()) {
            if (code.equals(typeEnum.getCode())) {
                return typeEnum;
            }
        }
        return null;
    }
}


package com.service.task;

import com.pojo.Tasks;

/**
 * @author syh
 * @date 2023/6/8 15:10
 * @details 类描述
 */
public enum TasksStatusEnum {

    UNDO(0, "未处理"),
    DOING(1, "处理中"),
    SUCCESS(2, "成功"),
    FAIL(3, "失败");


    private Integer code;
    private String desc;


    TasksStatusEnum(Integer code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public Integer getCode() {
        return code;
    }

    public String getDesc() {
        return desc;
    }
}

6.实现dealer接口实现类

package com.service.dealer;

import com.pojo.Tasks;
import com.service.task.TasksTypeEnum;

/**
 * @author syh
 * @date 2023/6/8 16:07
 * @details 处理业务接口
 */
public interface Dealer {

    /**
     * 具体逻辑实现
     * @param tasks
     * @return
     */
    boolean doDeal(Tasks tasks);

    /**
     * 接口枚举对应类
     * @return
     */
    TasksTypeEnum getTasksTypeEnum();
}


package com.service.student;


import com.baomidou.mybatisplus.extension.service.IService;
import com.pojo.Student;
import com.service.dealer.Dealer;

/**
 * @author syh
 * @date 2023/5/614:14
 * @details 详情
 */
public interface StudentService extends IService<Student> , Dealer {

  
}


package com.service.student.impl;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mapper.StudentMapper;
import com.pojo.Student;
import com.pojo.Tasks;
import com.service.task.TasksTypeEnum;
import com.service.student.StudentService;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.io.File;
import java.io.FileOutputStream;
import java.util.List;
import java.util.UUID;

/**
 * @author syh
 * @date 2023/5/614:16
 * @details 详情
 */
@Service
public class StudentServiceImpl extends ServiceImpl<StudentMapper, Student> implements StudentService {

    /**
     * job 定时任务实现
     * @param tasks
     * @return
     */
    @Override
    public boolean doDeal(Tasks tasks) {
        try {
            //todo 业务逻辑
            System.out.println("双色球,2块钱百万杠杆");
        } catch (Exception e) {
            return false;
        }
        return true;

    }

    /**
     * 用于tasksJob
     *
     * @return
     */
    @Override
    public TasksTypeEnum getTasksTypeEnum() {
        //指定map对应的枚举
        return TasksTypeEnum.ONE;
    }
}
沈么鬼？
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
定时器 也叫任务调度器 Spring的定时任务 xxl-job分布式任务调度
飘然生的博客
06-18 3870
一。概述 Cron表达式是一个字符串，字符串以5或6个空格隔开,中间均由空格隔开，分为6或7个域，每一个域代表一个含义，Cron有如下两种语法格式： 1.Seconds Minutes Hours DayofMonth Month DayofWeek Year 秒 分 小时 几号 几月 周几 年 2.Seconds Minutes Hours DayofMonth Month DayofWeek 秒 分 小时 几号 几月 周几 二。符号详细说明 * 表示匹配该域的任意值，假如在Minu
使用XXL-JOB完成需求：添加数据库一条记录的同时指定时间延时删除
学习开发
10-10 534
XXL-JOB工具的使用
【物联网】解密STM32定时器外设：从入门到实战，轻松应对定时任务_tim_dier_uie
最新发布
2401_83817916的博客
04-06 368
设置预分频器（PSC）和自动重载寄存器（ARR）：根据所需的计时周期和计数频率，设置预分频器和自动重载寄存器的值。然后，配置定时器的时钟源和时钟分频器，选择适当的时钟频率。输出比较：定时器的比较功能可以与外部输入进行比较，当计数器的值与比较器的值相等时，可以触发相应的事件。根据实际需求配置计数模式。计数器和自动重装载寄存器：计数器用于计数时间，当计数器的值达到自动重装载寄存器中的值时，会触发相应的事件。比较器设置：比较器用于设置触发事件的条件，当计数器的值与比较器寄存器中的值相等时，会触发相应的事件。
java 异步线程任务执行监控与处理
weixin_42968598的博客
09-24 1145
import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Ti...
XXL-JOB任务有效期支持实现方案
lonelymanontheway的博客
11-21 2053
XXL-JOB任务有效期支持的一种实现方案。
xxl-job执行出现异常
蓝斌星的博客
07-15 2924
xxl-job执行的时候报这个错误是因为方法所在的类没有注解@Component。
详解Python3定时器任务代码
09-18
主要介绍了Python3定时器任务代码，本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
TIMER_轮询_裸机定时器任务调度_
09-29
裸机多任务轮询定时器，用于简单任务的轮询
用golang实现一个定时器任务队列实例
09-20
golang中提供了2种定时器timer和ticker，分别是一次性定时器和重复任务定时器。这篇文章主要介绍了用golang实现一个定时器任务队列实例，非常具有实用价值，需要的朋友可以参考下
PHP 多任务秒级定时器的实现方法
12-18
描述 最近在公司部署crontab的时候，突发奇想是否...主要就是让PHP可以同时开启很多子进程，并行的去处理一些任务。 Spl – SplMinHeap – 小顶堆 一个小顶堆数据结构，在实现定时器的时候，采用这种结构效率还是不错的
Java中Spring使用Quartz任务调度定时器
08-31
本篇文章主要介绍了Java中Spring使用Quartz任务调度定时器，具有一定的参考价值，有兴趣的可以了解一下。
XXL-JOB的阻塞处理策略-单机串行机制
qq_44754301的博客
01-05 6026
默认的单机串行策略,是指的是在xxl-job调度时串行,还是指具体的执行器串行?
XXL-JOB一般错误解决方式
热门推荐
weixin_39433171的博客
07-26 5万+
关于XXL-JOB的配置可以看我的另一篇博客： XXL-JOB整合本地实际项目(spring)案例 ： https://blog.csdn.net/weixin_39433171/article/details/80929270 在实际项目中，会遇到一些问题，如下： 一、执行任务以后，后台查看任务已完成，但是，页面无法显示 执行结果为成功，一直处于 执行中状态，必须手动停止，且执行结...
一文带你使用xxl-job定时任务
小鲍侃java
10-24 2万+
​ 1.设计思想 将调度行为抽象形成“调度中心”公共平台，而平台自身并不承担业务逻辑，“调度中心”负责发起调度请求。 将任务抽象成分散的JobHandler，交由“执行器”统一管理，“执行器”负责接收调度请求并执行对应的JobHandler中业务逻辑。 因此，“调度”和“任务”两部分可以相互解耦，提高系统整体稳定性和扩展性； 2.系统组成 调度模块（调度中心）： 负责管理调度信息，按照调度配置发出调度请求，自身不承担业务代码。调度系统与任务解耦，提高了系统可用性和稳定性，同时调度系统性能不再受限于任务模块
系统定时任务及延迟任务的设定
weixin_51129538的博客
11-01 340
系统延时任务及定时任务 1.系统延时任务 [root@localhost ~]# at 23:37 ##设定任务执行时间 at> rm -fr /mnt/* ##任务动作 at> << CTRL +D ##用ctrl+D发起任务 [root@localhost ~]# at now+1min ##延时1分钟 at> rm -fr /mnt/* at> at -l ##查看任务列表 at -c 任务号 ##查看任务内容 at -r 任务
使用XXL-JOB时，如何避免多台服务器重复调度任务？｜工作踩坑系列
程序员小彭的博客
07-29 1万+
1.XXL-JOB介绍 XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。支持通过Web页面对任务进行CRUD操作，操作简单，一分钟上手；支持动态修改任务状态、启动/停止任务，以及终止运行中任务，即时生效。 　　官方地址中文版：https://www.xuxueli.com/xxl-job 　　Gitee地址：https://gitee.com/xuxueli0323/xxl-job 2.应用场景介绍 我们将XXL-JOB调度系统部署在两台服务器实例上。使用XXL-
分布式定时任务的动态添加、延迟任务选型分析
qq_34468174的博客
12-23 1546
这里写自定义目录标题本文只做分析不做实现elastic-jobxxl-job动态添加任务、延迟任务的不支持说明elastic-jobxxl-job延迟队列结论 写的比较好的博客：https://www.cnblogs.com/throwable/p/11955154.html 本文只做分析不做实现 项目上很多时候会使用定时任务，对应有很多分布式定时框架，比较优秀的例如elastic-job、xxl-job，两者都能实现分布式任务调度；但两者有差异性；而项目上有动态添加定时任务、延迟定时任务的需求，这两款框架
XxlJobConfig分布式定时器任务管理XxlJob配置类，替代
道阻且长,行则将至 行而不辍,未来可期
08-08 742
废弃原来的quartz定时器的任务管理，总体来说，本地服务应该使用quartz定时任务还是不错的选择，可是多个应用服务的话，也就是分部署应用部署，还是建议使用XXjob吧，这个前台页面可以自定义开发，所以使用体验较好，多应用系统使用上来说还是不错的！...
XXL-JOB原理
Alice_whj的博客
03-18 1万+
XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。在众多XXL-Job平台的特征中，有如下几条需要关注的： 1、使用简单：支持通过Web页面对任务配置，降低操作任务的难度； 2、动态：支持动态修改任务状态、启动/停止任务，以及终止运行中任务，即时生效； 3、调度中心HA（中心式）：调度采用中心式设计，“调度中心”自研调度组件并支持集群部署，可保证调度中心HA； 4、执行器HA（分布式）：任务分布式执行，任务”执行器”
FREERTOS定时器任务
05-27
3. 定时器任务回调函数：定时器任务回调函数会在定时器任务到期时执行，可以在回调函数中实现所需的任务处理。 ``` void vTimerCallback(TimerHandle_t xTimer) { // 定时器任务到期时执行的任务处理 } ``` 在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值