spring如何调度

Spring调度是基于Spring框架提供的调度器实现的，可以通过配置和编程两种方式来完成调度任务。

配置方式：

1. 在Spring的配置文件中，添加<task:annotation-driven />来启用注解驱动的调度任务。
2. 使用@Scheduled注解标记需要调度的方法，可以设置固定的时间间隔或者Cron表达式。
3. 在需要进行调度的类中，添加@Component或者其他相关注解，使Spring能够扫描到该类。

编程方式：

1. 创建一个实现了Runnable接口或者继承了TimerTask类的任务类，实现具体的任务逻辑。
2. 在需要进行调度的类中，创建一个ScheduledExecutorService对象。
3. 使用ScheduledExecutorService的scheduleAtFixedRate或者scheduleWithFixedDelay方法来定时执行任务。

通过以上配置和编程方式，可以实现Spring的调度功能。调度器可以实现定时调度或者延迟调度，可以非常方便地集成到Spring的应用程序中。

Spring框架提供了各种调度机制来实现任务的定时执行、异步执行和周期性执行。下面是五种常用的Spring调度方式：

1. 基于注解的调度：Spring提供了@Scheduled注解，可以将一个方法标记为定时任务。比如

@Scheduled(fixedDelay = 5000)
public void scheduleTask() {
    // 执行定时任务的逻辑代码
}

上述代码表示每隔5秒执行一次scheduleTask()方法。除了fixedDelay，还有其他属性可以设置，如fixedRate、cron等。

2. 基于XML配置的调度：通过在Spring的配置文件中使用Task命名空间来配置定时任务。示例如下：

<task:scheduled-tasks>
    <task:scheduled ref="task" method="run" fixed-delay="5000"/>
</task:scheduled-tasks>

上述配置表示每隔5秒执行一个名为"task"的bean的"run"方法。

3. 使用ThreadPoolTaskScheduler：Spring提供了ThreadPoolTaskScheduler来实现多线程调度。该调度器可以配置线程池大小、并发线程数、队列等特性，适用于要求高并发的场景。

4. 使用Cron表达式调度：Spring支持使用Cron表达式来配置复杂的任务调度。Cron表达式可以精确到秒，可以设置周期性调度、定点调度等。示例如下：

@Scheduled(cron = "0 0 9 * * ?") // 每天上午9点执行
public void scheduleTask() {
    // 执行定时任务的逻辑代码
}

5. 异步调度：使用@Async注解可以将方法标记为异步执行。被@Async注解修饰的方法会在调用时立即返回，而实际执行会在另一个线程中进行。示例如下：

@Async
public void asyncTask() {
    // 异步执行的逻辑代码
}

上述代码表示asyncTask()方法会异步执行。

总结来说，Spring框架提供了多种调度方式，可以根据需要选择最适合的方式来实现任务的定时执行、异步执行和周期性执行。

Spring框架中提供了多种调度方式，包括基于注解的调度，基于XML配置的调度以及基于任务调度器的调度。下面将从这三个方面分别讲解Spring框架的调度功能。

一、基于注解的调度

1. 引入相关依赖

首先，在项目的pom.xml文件中引入spring-context和spring-context-support依赖，例如：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

2. 创建定时任务类

在Spring框架中，使用@Scheduled注解声明定时任务。首先，创建一个定时任务类，例如：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class MyScheduler {

    @Scheduled(cron = "0/5 * * * * ?") // 每隔5秒执行一次
    public void task() {
        // 定时任务具体逻辑
        System.out.println("执行定时任务");
    }
}

在上述代码中，使用@Scheduled注解来标记需要执行的定时任务，通过cron表达式指定任务执行的时间规则。

3. 开启定时任务

为了使Spring框架能够扫描到定时任务类并进行调度，需要在配置类上添加@EnableScheduling注解，例如：

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;

@Configuration
@EnableScheduling
public class AppConfig {
    
    // 配置其他Bean
    
}

在上述代码中，使用@Configuration注解标记配置类，并使用@EnableScheduling注解开启定时任务功能。

二、基于XML配置的调度

1. 引入相关依赖

首先，在项目的pom.xml文件中引入spring-context和spring-context-support依赖，与上述相同。

2. 创建定时任务类

创建一个定时任务类，例如：

public class MyScheduler {

    public void task() {
        // 定时任务具体逻辑
        System.out.println("执行定时任务");
    }
}

3. 配置定时任务

在Spring配置文件中，通过配置task命名空间和task:scheduler元素来配置定时任务。例如，创建一个名为app-context.xml的Spring配置文件，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/task
                        http://www.springframework.org/schema/task/spring-task.xsd">
    
    <!-- 配置定时任务 -->
    <task:scheduler id="taskScheduler" pool-size="10" />
    
    <task:scheduled-tasks scheduler="taskScheduler">
        <task:scheduled ref="myScheduler" method="task" cron="0/5 * * * * ?" />
    </task:scheduled-tasks>

    <bean id="myScheduler" class="com.example.MyScheduler" />

</beans>

在上述配置文件中，使用task:scheduler元素配置任务调度器，task:scheduled-tasks元素用于配置定时任务，并通过task:scheduled元素指定定时任务的调用方法和时间表达式。

4. 启动Spring容器

在Main方法中启动Spring容器，例如：

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        new ClassPathXmlApplicationContext("app-context.xml");
    }
}

三、基于任务调度器的调度

Spring框架提供了多种任务调度器，如ThreadPoolTaskScheduler、ThreadPoolTaskExecutor、ConcurrentTaskScheduler等。下面以ThreadPoolTaskScheduler为例进行讲解。

1. 引入相关依赖

首先，在项目的pom.xml文件中引入spring-context和spring-context-support依赖，与上述相同。

2. 创建定时任务类

创建一个定时任务类，与前述相同。

3. 配置任务调度器和定时任务

在配置类中，创建一个ThreadPoolTaskScheduler对象，用于执行定时任务。同时，通过调用ThreadPoolTaskScheduler的schedule方法来配置定时任务。例如：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

@Configuration
public class AppConfig {
    
    @Bean
    public ThreadPoolTaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        taskScheduler.setPoolSize(10); // 线程池大小
        taskScheduler.initialize(); // 初始化
        return taskScheduler;
    }
    
    @Bean
    public MyScheduler myScheduler() {
        return new MyScheduler();
    }
    
    // 配置定时任务
    @Bean
    public ScheduledFuture<?> scheduleJob(ThreadPoolTaskScheduler taskScheduler) {
        return taskScheduler.schedule(myScheduler()::task, new CronTrigger("0/5 * * * * ?"));
    }
}

在上述代码中，首先创建一个ThreadPoolTaskScheduler对象，并配置线程池大小，然后调用initialize方法进行初始化。接着，创建MyScheduler对象和定时任务调度方法的配置，并通过taskScheduler的schedule方法指定定时任务执行的方法和时间表达式。

4. 启动Spring容器

与基于XML配置的调度相同，需要在Main方法中启动Spring容器。