java定时任务schedule quartz xxl-job 小记_java xxl-job使用

1.Timer类

        java中存在Timer类可以实现简单的定时任务调度

import java.util.Timer;
import java.util.TimerTask;
public class TimerExample {
    public static void main(String[] args) {
        Timer timer = new Timer();
        
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                // 定时任务的具体逻辑
                System.out.println("定时任务执行啦！");
            }
        };
 
        // 延迟1秒后执行任务，之后每隔5秒重复执行
        timer.schedule(task, 1000L, 5000L);
    }
}

        通过timer.schedule(task, delay, period)的方法将任务task安排在延迟delay毫秒后开始，每间隔period毫秒重复执行。

        Timer的缺点在于其是单线程，所有任务都在一个线程中串行执行，如果一个任务的执行时间超过了预期，会对后续任务的执行时间产生影响。也就是说，当一个任务抛出异常，其他任务也会终止运行。因此Timer类只适合于简单的定时任务，不涉及复杂的任务调度需求或分布式环境。

Spring框架还提供了一种通过添加@Schedule注解的方式来实现定时任务：

import org.springframework.scheduling.annotation.Scheduled;
 
@Component //添加component注解交给spring容器
public class timeTest{
 
    @Scheduled(cron = "0/15 * * * * ?")//用cron表达式来实现定时
    public void test(){
        System.out.println("定时");
    }
}

同时需要再启动类上添加@EnableScheduling来开启定时任务

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
 
@SpringBootApplication
@EnableScheduling
public class TimerApp {
    public static void main(String[] args) {
        SpringApplication.run(TimerApp.class);
    }
}

        通过spring task实现定时任务可见能更快速实现，但不支持动态调整，修改任务参数就需要重启项目。

2.Quartz

        Quartz实现定时任务调度 在Maven中引入依赖

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>{quartz.version}</version>
</dependency>

添加配置文件

@Configuration
public class JobConfig {
    @Bean //定义作业的具体实现方法和触发器的关联关系
    public JobDetail jobDetail(){
        return JobBuilder.newJob(MyJob.class) 
                .storeDurably(true)
                .build();
    }
 
    @Bean //将作业和触发器关联到调度器中
    public Trigger trigger(){
       return  TriggerBuilder.newTrigger()
                .forJob(jobDetail())
                .withSchedule(CronScheduleBuilder.cronSchedule("0 36 22 * * ?"))
                .build();//用cron来进行定时任务
    }
}

/**
*定时器业务代码
*/
public class MyJob extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext context) 
    throws JobExecutionException{
        System.out.println("我是定时器quartz,准备运行..");//实现定时器功能
    }
}

3.xxl-job

        XXL-JOB是一个分布式任务调度平台

docker安装：

配置docker-compose.yml文件

version: '2'
#自定义的docker网络
networks:
  wn_docker_net:
    external: true
services:
  xxl-job-compose:
    #读取Dockerfile
    #build: 
    #  context: .
    #  dockerfile: Dockerfile文件名
    #镜像名称
    image: xuxueli/xxl-job-admin:2.3.1
    #容器名称
    container_name: xxl-job
    ports:
      - "9898:8080"
    environment:
      PARAMS: '--spring.datasource.url=jdbc:mysql://192.168.240.129:3306/xxl_job?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
               --spring.datasource.username=root
               --spring.datasource.password=123'
    volumes:
      - /usr/local/software/xxl-job/logs:/data/applogs
    networks:
      wn_docker_net:
        ipv4_address: 172.18.12.100

用docker-compose命令安装xxl-job

通过该网址即可访问xxl-job平台

spring：

  中央仓库地址

<!-- https://mvnrepository.com/artifact/com.xuxueli/xxl-job-core -->
        <dependency>
            <groupId>com.xuxueli</groupId>
            <artifactId>xxl-job-core</artifactId>
            <version>2.3.1</version>
        </dependency>

 yml文件配置

#xxljob配置
xxl:
  job:
    admin:
      addresses: http://192.168.240.129:9898/xxl-job-admin
    executor:
      appname: xxl-job-executor-sample
      port: 9777
    accessToken: default_token

配置类

import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Slf4j
@Configuration
public class XxlJobConfig {
    @Value("${xxl.job.admin.addresses}")
    private String address;
    @Value("${xxl.job.executor.appname}")
    private String appName;
    @Value("${xxl.job.executor.port}")
    private int port;
    @Value("${xxl.job.accessToken}")
    private String accessToken;
    @Bean
    public XxlJobSpringExecutor xxlJobSpringExecutor(){
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setAdminAddresses(address);
        xxlJobSpringExecutor.setAppname(appName);
        xxlJobSpringExecutor.setPort(port);
        log.debug("xxl-job初始化成功:{}",xxlJobSpringExecutor);
        return xxlJobSpringExecutor;
    }
}

引入依赖后即可使用

使用注解即可实现定时任务

import com.xxl.job.core.handler.annotation.XxlJob;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
 
@Component
@Slf4j
public class MyJobs {
    @XxlJob("helloXxl")
    public void helloXxlJob(){
        log.debug("hello,xxl-job");
    }
}

通过注解和平台设置实现定时功能