关于java:创建定时任务的-5-种方式还有谁不会

4次阅读

共计 7581 个字符，预计需要花费 19 分钟才能阅读完成。

Quartz 表达式生成地址：http://cron.qqe2.com

反对生成定时工作表达式和反解析，应用 Quartz 表达式的定时工作如下：

  • xxl-job
  • springboot 的 @Scheduled
  • Quartz 框架

一、定时工作的五种创立形式

1、应用线程创立 job 定时工作 

/**
  * TODO 应用线程创立 job 定时工作
  * @author 王松
  */
public class JobThread {

    public static class Demo01 {
        static long count = 0;

        public static void main(String[] args) {Runnable runnable = new Runnable() {
                @Override
                public void run() {while (true) {
                        try {Thread.sleep(1000);
                            count++;
                            System.out.println(count);
                        } catch (Exception e) {// TODO: handle exception}
                    }
                }
            };
            Thread thread = new Thread(runnable);
            thread.start();}
    }
}

2、应用 TimerTask 创立 job 定时工作 

/**
 * TODO 应用 TimerTask 创立 job 定时工作
 * @author 王松
 */
public class JobTimerTask {

    static long count = 0;
    public static void main(String[] args) {TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                count++;
                System.out.println(count);
            }
        };
        // 创立 timer 对象设置间隔时间
        Timer timer = new Timer();
        // 距离天数
        long delay = 0;
        // 距离毫秒数
        long period = 1000;
        timer.scheduleAtFixedRate(timerTask, delay, period);
    }
}

3、应用线程池创立 job 定时工作 

/**
  * TODO 应用线程池创立 job 定时工作
  * @author 王松
  */
public class JobScheduledExecutorService {public static void main(String[] args) {Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    // task to run goes here
                    System.out.println("Hello !!");
                }
            };
            ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
            // 第二个参数为首次执行的延时工夫，第三个参数为定时执行的间隔时间
            service.scheduleAtFixedRate(runnable, 1, 1, TimeUnit.SECONDS);
        }
}

4、Quartz 框架

1、引入 maven 依赖 

<dependencies>
     <!-- quartz -->
     <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>

2、任务调度类 

public class MyJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {System.out.println("quartz MyJob date:" + System.currentTimeMillis());
    }
}

3、启动类 

public class JobQuartz {public static void main(String[] args) throws SchedulerException {
        //1. 创立 Scheduler 的工厂
        SchedulerFactory sf = new StdSchedulerFactory();
        //2. 从工厂中获取调度器实例
        Scheduler scheduler = sf.getScheduler();
        //3. 创立 JobDetail，JobDetail jb = JobBuilder.newJob(MyJob.class)
                //job 的形容
                .withDescription("this is a ram job")
                //job 的 name 和 group
                .withIdentity("ramJob", "ramGroup")
                .build();
        // 工作运行的工夫，SimpleSchedle 类型触发器无效，3 秒后启动工作
        long time= System.currentTimeMillis() + 3*1000L;
        Date statTime = new Date(time);
        //4. 创立 Trigger
        // 应用 SimpleScheduleBuilder 或者 CronScheduleBuilder
        Trigger t = TriggerBuilder.newTrigger()
                .withDescription("")
                .withIdentity("ramTrigger", "ramTriggerGroup")
                //.withSchedule(SimpleScheduleBuilder.simpleSchedule())
                // 默认以后工夫启动
                .startAt(statTime)
                // 两秒执行一次，Quartz 表达式，反对各种牛逼表达式
                .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?"))
                .build();
        //5. 注册工作和定时器
        scheduler.scheduleJob(jb, t);
        //6. 启动 调度器
        scheduler.start();}

5、springboot 的 @Scheduled 注解 

@Component
@Configuration      //1. 次要用于标记配置类，兼备 Component 的成果。@EnableScheduling   // 2. 开启定时工作
public class SaticScheduleTask {@Scheduled(cron = "0/5 * * * * ?") //3. 增加定时工作
    //@Scheduled(fixedRate=5000) // 或间接指定工夫距离，例如：5 秒
    private void configureTasks() {System.err.println("执行动态定时工作工夫:" + LocalDateTime.now());
    }
}

二、xxl-job 任务调度后盾 Admin

xxl-job 有什么用？

  • 分布式集群的状况下，保障定时工作不被反复执行。
  • 执行原理同 Nginx 类型，所有定时工作通过任务调度平台散发，也可配置负载平衡等等
  • 首先让咱们可能应用起来，搭建一个本人的工作

Spring Boot 基础教程就不介绍了，举荐看这里：https://github.com/javastacks…

第一步: github 下载源码导入

下载地址：https://github.com/xuxueli/xx…

以后版本目录构造 2.1.1

第二步: 执行 sql

文件地址：xxl-job/doc/db/tables_xxl_job.sql

以后 2.1.1 版本 sql

第三步: 批改 xxl-job-admin 我的项目配置

配置文件：application.properties

批改数据库连贯

第四步: 启动 admin 我的项目

springboot 形式启动我的项目

拜访 http://localhost:8080/xxl-job-admin/

账号密码：admin / 123456

任务调度核心就搭建好了

接下来须要创立一个服务器连贯任务调度核心

三、自创立 boot 我的项目的工作 xxl-job

创立一个 boot 我的项目

我的目录构造

pom.xml

web 外围及 xxl-job-core

<!-- spring-boot-starter-web (spring-webmvc + tomcat) -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

<!-- xxl-job-core 版本号依据本人下载的版本批改 -->
<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>2.1.1-SNAPSHOT</version>
</dependency>

logback.xml

日志配置间接拷贝 

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false" scan="true" scanPeriod="1 seconds">

    <contextName>logback</contextName>
    <property name="log.path" value="/data/applogs/xxl-job/xxl-job-executor-sample-springboot.log"/>

    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} %contextName [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.path}</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}.%d{yyyy-MM-dd}.zip</fileNamePattern>
        </rollingPolicy>
        <encoder>
            <pattern>%date %level [%thread] %logger{36} [%file : %line] %msg%n
            </pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="console"/>
        <appender-ref ref="file"/>
    </root>

</configuration>

application.properties 退出配置

需批改或自定义

  • xxl-job admin 地址
  • xxl.job.executor.appname 自定义名称，后盾配置必须对应
  • xxl.job.executor.ip 以后电脑 Ip，或部署我的项目的电脑 Ip
  • xxl.job.executor.port 端口 
# 端口号
server.port=8081
# 日志
logging.config=classpath:logback.xml

## xxl-job admin 地址，多个逗号分隔 "
xxl.job.admin.addresses=http://127.0.0.1:8080/xxl-job-admin

## xxl-job 名称 || socket ip 以后我的项目部署的 ip 地址 / 本机 ip || socket 端口号
xxl.job.executor.appname=xxl-job-executor-sample
xxl.job.executor.ip=192.168.43.153
xxl.job.executor.port=9999

## xxl-job, access token
xxl.job.accessToken=
## xxl-job log path
xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler
## xxl-job log retention days
xxl.job.executor.logretentiondays=-1

增加 boot 配置类 XxlJobConfig

/**
 * xxl-job xxljob.config
 */
@SuppressWarnings("ALL")
@Configuration
public class XxlJobConfig {private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

    @Value("${xxl.job.executor.appname}")
    private String appName;

    @Value("${xxl.job.executor.ip}")
    private String ip;

    @Value("${xxl.job.executor.port}")
    private int port;

    @Value("${xxl.job.accessToken}")
    private String accessToken;

    @Value("${xxl.job.executor.logpath}")
    private String logPath;

    @Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;


    @Bean(initMethod = "start", destroyMethod = "destroy")
    public XxlJobSpringExecutor xxlJobExecutor() {logger.info(">>>>>>>>>>> xxl-job xxljob.config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppName(appName);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);
        System.err.println(ip+":"+port);
        return xxlJobSpringExecutor;
    }

    /**
     * 针对多网卡、容器内部署等状况，可借助 "spring-cloud-commons" 提供的 "InetUtils" 组件灵便定制注册 IP；*
     * 1、引入依赖：* <dependency>
     * <groupId>org.springframework.cloud</groupId>
     * <artifactId>spring-cloud-commons</artifactId>
     * <version>${version}</version>
     * </dependency>
     *
     * 2、配置文件，或者容器启动变量
     * spring.cloud.inetutils.preferred-networks: 'xxx.xxx.xxx.'
     *
     * 3、获取 IP
     * String ip_ = inetUtils.findFirstNonLoopbackHostInfo().getIpAddress();
     */
}

工作 job

@JobHandler(value="demoJobHandler")
@Component
public class DemoJobHandler extends IJobHandler {

     static int count;
    @Override
    public ReturnT<String> execute(String param) throws Exception {System.out.println("执行 job 工作"+count++);
        return SUCCESS;
    }
}

admin 后盾配置

执行管理器下

工作治理下编辑工作

定时规定生成：http://cron.qqe2.com/

job 工作名：@JobHandler 注解值 >> 如:@JobHandler(value=“demoJobHandler”)

启动

这样就配置实现了

原文链接：https://blog.csdn.net/qq_4146…

版权申明：本文为 CSDN 博主「兮家小二」的原创文章，遵循 CC 4.0 BY-SA 版权协定，转载请附上原文出处链接及本申明。

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿 (2021 最新版)

2. 终于靠开源我的项目弄到 IntelliJ IDEA 激活码了，真香！

3. 阿里 Mock 工具正式开源，干掉市面上所有 Mock 工具！

4.Spring Cloud 2020.0.0 正式公布，全新颠覆性版本！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！

正文完
java
发表至： java
2021-06-21
 0
力扣(LeetCode)863
关于java:SpringBoot定时任务-Spring自带的定时任务是如何实现的有何注意点
关于java:异常SLF4JLoggerContext-cannot-be-cast-to-log4jcoreLoggerContext
用Helm部署Kubernetes应用支持多环境部署与版本回滚

站内搜索

-「」