可手动控制定时任务

最新推荐文章于 2024-04-17 16:08:31 发布
最新推荐文章于 2024-04-17 16:08:31 发布
阅读量1.8k 收藏 3
点赞数
分类专栏： 定时任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java821643/article/details/105652362
版权

需求介绍

增加对数据的订单监控,达到数据配置的要求时候发送短信

模型设计

create table MKT_WARING
(
  mkt_waring_id       NUMBER(16),  --主键
  waring_sql          VARCHAR2(3000),  --sql
  waring_sql_param    VARCHAR2(500), --sql参数
  waring_cron         VARCHAR2(200), --cron表达式
  waring_status       VARCHAR2(50),  --状态
  waring_sms_tempalte VARCHAR2(100), --短信模板
  waring_sms_context  VARCHAR2(3000), --短信内容
  waring_phone        VARCHAR2(50),--电话号码
  waring_remark       VARCHAR2(200),--备注
  waring_type         VARCHAR2(10),--类型
  waring_expression   VARCHAR2(3000) --表达式(正则最好)
)

代码部分

package com.sitech.waring.config;

import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import com.sitech.crmtpd.market.domain.comp.WaringConfigEntity;
import com.sitech.waring.scheduled.BaseJob;
import com.sitech.waring.scheduled.OrderOverStock;
import com.sitech.waring.scheduled.OrderSuccessRateLow;
import com.sitech.waring.scheduled.OrderTimeoutWaring;
import lombok.extern.slf4j.Slf4j;
import netscape.javascript.JSObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;

/**
 * @oauth: qiangSW
 * @date: 2020/3/24 15:07
 * @description: com.sitech.waring.config
 * @doc:
 */
@Configuration
@Slf4j
public class WaringProjeactInit {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private OrderOverStock orderOverStock;
    @Autowired
    private OrderSuccessRateLow orderSuccessRateLow;
    @Autowired
    private OrderTimeoutWaring orderTimeoutWaring;


    public static List<WaringConfigEntity> waringConfigEntities = Lists.newArrayList();

    @Bean
    public List<WaringConfigEntity> initWaringConfig() {
        String sql = "select mkt_waring_id,waring_sql,waring_sql_param,waring_cron,waring_status,waring_sms_tempalte," +
                "waring_sms_context,waring_phone,waring_expression from mkt_waring where waring_status = '0' and waring_type = '0'";
        List<WaringConfigEntity> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(WaringConfigEntity.class));
        waringConfigEntities.addAll(query);
        log.info("加载预警配置信息{}", JSONObject.toJSONString(query));
        return query;
    }
     

    //项目初始化job
    @Bean
    public void addJobInfo() {
        BaseJob.jobMap.put(orderOverStock.WARING_ID, orderOverStock);
        BaseJob.jobMap.put(orderSuccessRateLow.WARING_ID, orderSuccessRateLow);
        BaseJob.jobMap.put(orderTimeoutWaring.WARING_ID, orderTimeoutWaring);
    }
}

package com.sitech.waring.scheduled;

import com.google.common.collect.Maps;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Map;

/**
 * @oauth: qiangSW
 * @date: 2020/4/5 9:57
 * @description: com.sitech.waring.scheduled
 * @doc:
 */

public interface BaseJob {

    public Map<Long, Runnable> jobMap = Maps.newHashMap();


    public void addJob();
}

package com.sitech.waring.scheduled;


import com.sitech.waring.Service.SendSmsService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;

import org.springframework.stereotype.Component;



/**
 * @oauth: qiangSW
 * @date: 2020/3/25 11:04
 * @description: com.sitech.waring.scheduled
 * @doc: 工单积压预警
 */
@Component
@Slf4j
public class OrderOverStock implements Runnable {

    public static final Long WARING_ID = 2l;

    @Autowired
    private SendSmsService sendSmsService;


    @Override
    public void run() {
        /*发送短信*/
        sendSmsService.smsContextMap(WARING_ID);
    }



}

package com.sitech.waring.scheduled;

import com.google.common.collect.Lists;
import com.sitech.crmtpd.market.domain.comp.WaringConfigEntity;
import com.sitech.waring.Service.SendSmsService;
import com.sitech.waring.config.WaringProjeactInit;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.PostConstruct;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @oauth: qiangSW
 * @date: 2020/3/25 11:05
 * @description: com.sitech.waring.scheduled
 * @doc: 转化率低于1%
 */
@Component
@Slf4j
public class OrderSuccessRateLow implements Runnable {

    public static final Long WARING_ID = 1l;

    @Autowired
    private SendSmsService sendSmsService;

    @PostConstruct
    @Override
    public void run() {
        sendSmsService.smsContextIntger(WARING_ID);
    }
}

package com.sitech.waring.Service;

import com.sitech.crmtpd.mapper.IntfPush0MsgMktMapper;
import com.sitech.crmtpd.market.domain.IntfPush0MsgMkt;
import com.sitech.crmtpd.market.domain.comp.WaringConfigEntity;
import com.sitech.jframe.jdbc.sequence.SeqService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import com.sitech.waring.config.WaringProjeactInit;
import org.springframework.util.StringUtils;

import java.text.MessageFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @oauth: qiangSW
 * @date: 2020/3/24 15:24
 * @description: com.sitech.waring.Service
 * @doc: 发送短信
 */
@Service
@Slf4j
public class SendSmsService {

    @Autowired
    private IntfPush0MsgMktMapper intfPush0MsgMktMapper;
    @Autowired
    private SeqService seqService;
    @Autowired
    private JdbcTemplate jdbcTemplate;


    /**
     * 返回 map
     *
     * @param configId
     */
    public void smsContextMap(Long configId) {
        WaringConfigEntity waringConfigEntity = filterWaringConfigEntity(configId);
        if (null == waringConfigEntity) {
            return;
        }

        String sql = waringConfigEntity.getWaringSql();
        String sqlParam = waringConfigEntity.getWaringSqlParam();
        String[] sqlParamArry = sqlParam.split(",");
        Map<String, Object> map = jdbcTemplate.queryForMap(sql, sqlParamArry);
        String waringContext = waringConfigEntity.getWaringSmsContext();
        String smsContext = MessageFormat.format(waringContext, map.get("summary15day"), map.get("summary"));
        String[] phones = waringConfigEntity.getWaringPhone().split(",");
        for (int i = 0; i < phones.length; i++) {
            StringBuffer buffer = new StringBuffer("{\"content\":\"").append(smsContext).append("\"}");
            sendSms(phones[i], buffer.toString(), waringConfigEntity.getWaringSmsTempalte());
        }
    }

    /**
     * 返回Intger
     *
     * @param configId
     */
    public void smsContextIntger(Long configId) {

        WaringConfigEntity waringConfigEntity = filterWaringConfigEntity(configId);
        if (null == waringConfigEntity) {
            return;
        }
        String sql = waringConfigEntity.getWaringSql();
        String sqlParam = waringConfigEntity.getWaringSqlParam();
        Object result = 0;
        if (!StringUtils.isEmpty(sqlParam)) {
            String[] sqlParamArry = sqlParam.split(",");
            result = jdbcTemplate.queryForObject(sql, sqlParamArry, Object.class);
        } else {
            result = jdbcTemplate.queryForObject(sql, Object.class);
        }
        String waringContext = waringConfigEntity.getWaringSmsContext();
        String smsContext = MessageFormat.format(waringContext, result);
        String[] phones = waringConfigEntity.getWaringPhone().split(",");
        for (int i = 0; i < phones.length; i++) {
            StringBuffer buffer = new StringBuffer("{\"content\":\"").append(smsContext).append("\"}");
            sendSms(phones[i], buffer.toString(), waringConfigEntity.getWaringSmsTempalte());
        }

    }

    /**
     * 过滤
     *
     * @param configId
     * @return
     */
    public WaringConfigEntity filterWaringConfigEntity(Long configId) {
        List<WaringConfigEntity> waringConfigEntities = WaringProjeactInit.waringConfigEntities;
        if (CollectionUtils.isEmpty(waringConfigEntities)) {
            return null;
        }
        /*根据主键过滤,过滤后只有一条数据*/
        List<WaringConfigEntity> collect = waringConfigEntities.stream()
                .filter(filter -> filter.getMktWaringId().longValue() == configId.longValue())
                .collect(Collectors.toList());

        return Optional.ofNullable(collect).map(a -> {
            return a.get(0);
        }).orElse(null);
    }

    public void smsContext(List<Long> configIds) {
        List<WaringConfigEntity> waringConfigEntities = WaringProjeactInit.waringConfigEntities;
        if (CollectionUtils.isEmpty(waringConfigEntities)) {
            return;
        }
        /*根据主键过滤,过滤后只有一条数据*/
        List<WaringConfigEntity> collect = waringConfigEntities.stream()
                .filter(filter -> {
                    return configIds.contains(filter);
                })
                .collect(Collectors.toList());
        if (CollectionUtils.isEmpty(collect)) {
            return;
        }
        collect.stream().forEach(each -> {
            String sql = each.getWaringSql();
            String sqlParam = each.getWaringSqlParam();
            String[] sqlParamArry = sqlParam.split(",");
            String result = jdbcTemplate.queryForObject(sql, sqlParamArry, String.class);
            String waringExpression = each.getWaringExpression();
            Pattern compile = Pattern.compile(waringExpression);
            Matcher matcher = compile.matcher(result);
            if (!matcher.matches()) {
                return;
            }
            String waringContext = each.getWaringSmsContext();
            String smsContext = String.format(waringContext, result);
            String[] phones = each.getWaringPhone().split(",");
            for (int i = 0; i < phones.length; i++) {
                sendSms(phones[i], smsContext, each.getWaringSmsTempalte());
            }
        });
    }

    /**
     * 发送短信
     *
     * @param phone
     * @param smsContext
     * @param msgTemplateId
     */
    public void sendSms(String phone, String smsContext, String msgTemplateId) {
        Date curDate = new Date();
        IntfPush0MsgMkt intfPush0MsgMkt = new IntfPush0MsgMkt();
        String seq = "100" + DateTimeFormatter.ofPattern("yyyyMMdd").format(LocalDate.now())
                + seqService.getNextval("SEQ_SMS_SEND_ID");
        String sendFlag = "0";
        String sendMsg = "";
        String dealFlag = "00";
        String dealMsg = "未调用统一推送平台接口";
        intfPush0MsgMkt.setSeq(seq);
        intfPush0MsgMkt.setMktCampaignId(0l);
        intfPush0MsgMkt.setContactOrderId(0l);
        intfPush0MsgMkt.setTemplateid(msgTemplateId);
        intfPush0MsgMkt.setParameter(smsContext);
        intfPush0MsgMkt.setPhoneNo(phone);
        intfPush0MsgMkt.setInsertTime(curDate);
        intfPush0MsgMkt.setSendFlag(sendFlag);
        intfPush0MsgMkt.setSendMsg(sendMsg);
        intfPush0MsgMkt.setOpCode("yingfu");
        intfPush0MsgMkt.setLoginNo("admin");
        intfPush0MsgMkt.setSendTime(curDate);
        intfPush0MsgMkt.setHold1("0");
        intfPush0MsgMkt.setHold3(Objects.toString(0));
        intfPush0MsgMkt.setServNo("0");
        intfPush0MsgMkt.setServiceNo("0");
        intfPush0MsgMkt.setDealFlag(dealFlag);
        intfPush0MsgMkt.setDealMsg(dealMsg);
        intfPush0MsgMkt.setDealDate(curDate);
        intfPush0MsgMktMapper.insertSelective(intfPush0MsgMkt);
        log.info("{}发生告警短信",seq);
    }


   /* public Date getCron(TriggerContext triggerContext, Long configId, String scheduledName) {
        List<WaringConfigEntity> waringConfigEntities = WaringProjeactInit.waringConfigEntities;
        if (CollectionUtils.isEmpty(waringConfigEntities)) {
            return null;
        }
        *//*根据主键过滤,过滤后只有一条数据*//*
        List<WaringConfigEntity> collect = waringConfigEntities.stream()
                .filter(filter -> filter.getMktWaringId().longValue() == configId.longValue())
                .collect(Collectors.toList());
        if (CollectionUtils.isEmpty(collect)) {
            return null;
        }
        WaringConfigEntity waringConfigEntity = collect.get(0);
        log.info("{},cron表达式{}", scheduledName, waringConfigEntity.getWaringCron());
        CronTrigger cronTrigger = new CronTrigger(waringConfigEntity.getWaringCron());
        return cronTrigger.nextExecutionTime(triggerContext);
    }*/
}

package com.sitech.waring.Service;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.sitech.crmtpd.market.domain.comp.WaringConfigEntity;
import com.sitech.waring.config.WaringProjeactInit;
import com.sitech.waring.scheduled.BaseJob;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ScheduledFuture;

/**
 * @oauth: qiangSW
 * @date: 2020/3/25 8:40
 * @description: com.sitech.waring.Service
 * @doc: 刷新配置
 */
@RestController
public class RefreshService {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;
    @Autowired
    private WaringProjeactInit waringProjeactInit;

    Map<Long, ScheduledFuture<?>> scheduledFutureMap = Maps.newHashMap();

    Map<Long, Runnable> allJob = BaseJob.jobMap;

    @Bean
    public ThreadPoolTaskScheduler trPoolTaskScheduler() {
        return new ThreadPoolTaskScheduler();
    }

    /**
     * 刷新job配置数据
     */
    @GetMapping("/refreshConfigEntity")
    public void refreshConfigEntity() {
        String sql = "select mkt_waring_id,waring_sql,waring_sql_param,waring_cron,waring_status,waring_sms_tempalte," +
                "waring_sms_context,waring_phone,waring_expression from mkt_waring where waring_status = '0'";
        List<WaringConfigEntity> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(WaringConfigEntity.class));
        WaringProjeactInit.waringConfigEntities.clear();
        WaringProjeactInit.waringConfigEntities.addAll(query);

    }

    /**
     * 启动全部job
     */
    @GetMapping("/startAll")
    public void startAll() {
        List<WaringConfigEntity> waringConfigEntities = waringProjeactInit.initWaringConfig();
        Optional.ofNullable(allJob).ifPresent(a -> {
            waringConfigEntities.stream().filter(filter -> {
                return allJob.containsKey(filter.getMktWaringId());
            }).forEach(each -> {
                ScheduledFuture<?> schedule =
                        threadPoolTaskScheduler.schedule(allJob.get(each.getMktWaringId()),
                                new CronTrigger(each.getWaringCron()));

                if (!scheduledFutureMap.containsKey(each.getMktWaringId())) {
                    scheduledFutureMap.put(each.getMktWaringId(), schedule);
                } else {
                    scheduledFutureMap.remove(each.getMktWaringId());
                    scheduledFutureMap.put(each.getMktWaringId(), schedule);
                }
            });
        });
    }

    /**
     * 根据id启动job
     *
     * @param waringId
     */
    @GetMapping("/startJobById")
    public void startJon(@RequestParam("waringId") Long waringId) {
        List<WaringConfigEntity> waringConfigEntities = waringProjeactInit.initWaringConfig();
        waringConfigEntities.stream()
                .filter(filter -> filter.getMktWaringId().longValue() == waringId.longValue())
                .forEach(each -> {
                    ScheduledFuture<?> schedule =
                            threadPoolTaskScheduler.schedule(allJob.get(each.getMktWaringId()),
                                    new CronTrigger(each.getWaringCron()));
                    if (!scheduledFutureMap.containsKey(each.getMktWaringId())) {
                        scheduledFutureMap.put(each.getMktWaringId(), schedule);
                    } else {
                        scheduledFutureMap.remove(each.getMktWaringId());
                        scheduledFutureMap.put(each.getMktWaringId(), schedule);
                    }
                });
    }

    /**
     * 手动触发某个job
     *
     * @param waringId
     */
    @GetMapping("/triggerJob")
    public void triggerJob(@RequestParam("waringId") Long waringId) {

        Optional.ofNullable(allJob).ifPresent(a -> {
            for (Map.Entry<Long, Runnable> map : allJob.entrySet()) {
                if (map.getKey().longValue() == waringId.longValue()) {
                    threadPoolTaskScheduler.execute(map.getValue());
                }
            }
        });
    }

    /**
     * 停止job
     *
     * @param waringId
     */
    @GetMapping("/stop")
    public void stop(@RequestParam("waringId") Long waringId) {
        if (null != waringId) {
            if (scheduledFutureMap.containsKey(waringId)) {
                scheduledFutureMap.get(waringId).cancel(true);
                scheduledFutureMap.remove(waringId);
            }
        } else {
            Optional.ofNullable(scheduledFutureMap).ifPresent(a -> {
                a.forEach((k, v) -> {
                    v.cancel(true);
                });
                a.clear();
            });
        }
        System.out.println("stop job");
    }

    /**
     * 获取所有job
     *
     * @return
     */
    @GetMapping("/getJobName")
    public List<Long> getJobName() {
        List<Long> list = Lists.newArrayList();
        Optional.ofNullable(scheduledFutureMap).ifPresent(a -> {
            a.forEach((k, v) -> {
                list.add(k);
            });
        });
        return list;
    }
}

 

YangTG5号
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring动态配置计时器触发时间
Hugiee的博客
06-06 1547
Spring中添加计时器的时候根据业务需求可能会需要动态处理触发时间;import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.scheduling.Trigger; import org.springframework.scheduling.TriggerContext; import ...
SpringBoot 定时器/定时任务：在一个指定的周期时间内，执行某一项任务。
热门推荐
menghunzhihun的博客
04-18 2万+
说多都是累，直接上代码：实现方式有三种(可能还有更多的实现，这三种只是楼主目前所知道的)：    1、静态定时器，无法修改周期        @Configuration("myScheduled") @EnableScheduling public class ScheduledDemo{     //每10秒执行一次     @Scheduled(cron="0/10 * * * * ?") ...
Java定时任务
最新发布
孟斌斌的博客
04-17 718
java.util.Timer 类允许您在未来的某个时间执行一个任务，或者在一定的时间间隔执行任务。可以指定定时任务的触发时间、频率等。每天的0点、3点、5点、7点都执行一次：0 0 0, 3,5,7 * *?在12分、13分、14分执行一次：0 12,13,14 * * *?每月1号凌晨1点执行一次：0 0 1 1 *?每隔1分钟执行一次：0 */1 * * *?每隔5秒执行一次：*/5 * * * *?每天22点执行一次：0 0 22 * *?每天凌晨1点执行一次：0 0 1 * *?
SpringBoot定时任务以及Corn表达式详解
上善若泪
08-12 4128
目录 1 Schedule定时任务器 1.1 pom.xml文件 1.2 编写定时任务类 1.3 启动类中开启定时任务的调用 2 Quartz定时任务框架讲解 2.1Quartz的使用思路 2.2Quartz 的基本使用方式 2.2.1 pom.xml文件 2.2.2 创建job类 2.2.3 测试代码 3 SpringBoot整合Quartz定时框架 3.1编写 Quartz 的配置类 3.2编写 Quartz 的启动类 1 Schedule定时任务器 sched...
springboot中动态cron表达式的定时任务
陆玖神通的博客
11-27 5977
最近工作上接到了一个定时相关的需求，通过分析发现，需求比较简单，并不需要任务持久化，也不需要定时任务的复杂操作。 所以对比之下，选用了spring-context模块里包含的scheduling功能。
SpringBoot——Scheduled定时任务
tang_seven的博客
04-06 5192
简单总结springboot定时任务的使用，包括基于@Scheduled注解的静态定时任务，和继承SchedulingConfigurer类的动态定时任务。
SpringBoot设置动态定时任务（任务循环间隔时间可随意修改）
青灬火的博客
05-29 1万+
近两天因为工作需要，之前的项目架构更换，在新的架构上需要实现一个定时循环任务，如项目启动后每隔100秒执行一次，但是该间隔时间在项目运行中是必须可以动态修改的。 在网上搜了很多相关文章来看，几乎全都是运用cron表达式来实现的。但是cron表达式存在一个问题就是，它可以设置60秒以内，或者整分钟（或小时）来作为循环间隔，却无法实现每100秒（也就是大于59秒，但又不是整分钟）循环一次这样的需求。 当然cron表达式是一个很强大的工具，只是针对于该需求来说不是特别合适。cron表达式更适合于设置定时定点的
springboot定时任务的动态开启关闭
03-07
Spring Boot提供了Spring Scheduler抽象来实现这样的需求，使得开发者能够方便地管理和控制定时任务。本篇文章将深入探讨如何在Spring Boot中实现定时任务的动态开启和关闭。 首先，我们需要引入Spring Boot的`...
6.2 创建定时和周期任务
09-27
在"TimingDemo"这个例子中，我们可以推测它可能包含了一个或多个上述的定时任务实现，可能通过创建Handler、TimerTask、AlarmManager的实例或者使用WorkManager来演示如何在Android中创建和管理定时和周期任务。...
IntelliJ IDEA中创建Spring boot项目，定时任务测试
01-16
2. **编写定时任务类**：在Java源码目录下创建一个定时任务类，例如`ScheduledTask.java`，并使用`@Component`注解标记为Spring Bean。然后使用`@Scheduled`注解来定义任务的执行周期，如`cron`表达式控制执行频率。...
thinkPHP3.2.3定时执行任务
05-12
在IT行业中，定时任务是系统自动化的一个重要...通过合理设计和优化，定时任务可以极大地提升业务效率，减少手动操作，是现代Web应用不可或缺的一部分。在实际开发中，应根据项目需求选择最适合的定时任务解决方案。
java 定时任务及jar包
07-20
- 在Spring应用中，我们可以使用`@Scheduled`注解来声明定时任务，这样无需手动管理线程或定时器。 - 配置`TaskScheduler`或者`ScheduledExecutorService`，Spring会自动处理任务调度。 - `@Scheduled(fixedDelay...
生产问题分析之springboot定时任务莫名其妙停止了
weixin_44637227的博客
05-12 5633
生产问题分析之springboot定时任务莫名其妙停止了
Spring Boot 设置动态定时任务，千万别再写死了~
芋艿V
11-04 1928
???? 这是一个或许对你有用的社群???? 一对一交流/面试小册/简历优化/求职解惑，欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料：《项目实战（视频）》：从书中学，往事上“练”《互联网高频面试题》：面朝简历学习，春暖花开《架构 x 系统设计》：摧枯拉朽，掌控面试高频场景题《精进 Java 学习指南》：系统学习，互联网主流技术栈《必读 Java 源码专栏》：知其然，知其所以然????这是一个或许...
SpringBoot JAVA 动态设置定时任务执行时间
鹿林深的博客
09-21 2038
一 .核心代码 @Component @EnableScheduling public class ScheduleService implements SchedulingConfigurer { private String cron = "*/5 * * * * *"; private SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); @Override public.
SpringBoot 设置动态定时任务，千万别再写死了~
09-27 729
点击关注公众号，实用技术文章及时了解之前写过文章记录怎么在SpringBoot项目中简单使用定时任务，不过由于要借助cron表达式且都提前定义好放在配置文件里，不能在项目运行中动态修改任务执行时间，实在不太灵活。经过网上搜索学习后，特此记录如何在SpringBoot项目中实现动态定时任务。因为只是一个demo，所以只引入了需要的依赖：<dependencies> <dep...
java 定时任务重复执行_Springboot定时任务Scheduled重复执行操作
weixin_39613824的博客
02-13 1677
今天用scheduled写定时任务的时候发现定时任务一秒重复执行一次，而我的cron表达式为 * 0/2 * * * * 。在源码调试的过程中，发现是我的定时任务执行过程太短导致的。于是我另外写了个简单的定时任务@Componentpublic class TestJob {@Scheduled(cron = "* 0/2 * * * *")public void test() {System.o...
Springboot设置定时任务，从数据库中获取cron表达式 DEMO
HM_1011000000的博客
08-17 2909
Springboot设置定时任务，自定义 cron表达式 DEMO。
SpringBoot中两种方式实现定时任务，第二种可实现动态管理定时任务，有示例
qq_40277754的博客
04-21 779
SpringBoot中两种方式实现定时任务，第二种可实现动态管理定时任务
springclound怎么手动控制定时任务的启动
06-08
在Spring Cloud中，可以通过在配置文件中设置`spring.cloud.scheduler.enabled`属性来手动控制定时任务的启动。 当该属性设置为`false`时，所有定时任务都会被禁用，不再执行。当该属性设置为`true`时，所有定时任务都会启用，按照配置的时间间隔执行。 例如，可以在`application.properties`中设置： ``` spring.cloud.scheduler.enabled=false ``` 这样就可以禁用所有定时任务了。如果需要启用定时任务，将该属性设置为`true`即可。 除了全局禁用/启用外，还可以在单个定时任务的注解中设置`cron`属性来控制定时任务的启动时间。例如： ``` @Scheduled(cron = "0 0/5 * * * ?") // 每隔5分钟执行一次 public void myTask() { // ... } ``` 这样，即使全局启用了定时任务，该任务也只会按照指定的时间间隔执行，而不是每分钟都执行。 综上所述，Spring Cloud提供了灵活的定时任务管理方式，可以根据实际需求来控制定时任务的启动和停止。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值