不用spring怎么定时任务

如果不使用Spring框架，你可以使用Java自带的定时任务调度器来实现定时任务。

在Java中，可以使用java.util.Timer类来创建定时任务。下面给出一个简单的例子来说明如何使用Timer来实现定时任务：

import java.util.Timer;
import java.util.TimerTask;

public class MyTask extends TimerTask {
    public void run() {
        // 在这里编写需要定时执行的任务逻辑
        System.out.println("定时任务执行了！");
    }

    public static void main(String[] args) {
        Timer timer = new Timer();
        long delay = 0; // 延迟时间，单位为毫秒
        long period = 1000; // 任务执行间隔，单位为毫秒

        // 创建定时任务，并设置任务的延迟时间和执行间隔
        timer.schedule(new MyTask(), delay, period);
    }
}

上述代码中，我们定义了一个继承自TimerTask的自定义任务类MyTask。在MyTask中，我们重写了run方法，这个方法中编写了需要定时执行的任务逻辑。

在main方法中，我们创建了一个Timer对象，并使用schedule方法来安排定时任务的执行。需要传入一个TimerTask对象，以及延迟时间和执行间隔。

这样就可以实现一个简单的定时任务了。你可以根据自己的需求定制定时任务的执行逻辑。

需要注意的是，Timer类是单线程的，如果在任务执行期间出现异常，可能会导致整个定时任务停止运行。如果需要更加健壮的定时任务框架，建议使用Spring框架提供的定时任务功能。

不使用Spring框架的情况下，也可以实现定时任务。下面是五种常见的方式：

1. 使用Java内置的定时任务工具类：Java中已经提供了一些用于处理任务调度的类和接口，比如Timer和TimerTask。可以创建一个继承自TimerTask的类，在其中实现要执行的任务逻辑，并使用Timer来启动定时任务。

示例代码：

import java.util.Timer;
import java.util.TimerTask;

public class MyTask extends TimerTask {
    @Override
    public void run() {
        // 执行定时任务逻辑
        System.out.println("定时任务执行");
    }

    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new MyTask(), 0, 1000);  // 每秒执行一次
    }
}

2. 使用Java线程池：可以通过创建线程池来实现定时任务。可以使用Java的ScheduledExecutorService接口来创建线程池，并使用schedule方法来调度定时任务。

示例代码：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class MyTask implements Runnable {
    @Override
    public void run() {
        // 执行定时任务逻辑
        System.out.println("定时任务执行");
    }

    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        executor.scheduleAtFixedRate(new MyTask(), 0, 1, TimeUnit.SECONDS);  // 每秒执行一次
    }
}

3. 使用Quartz框架：Quartz是一个功能强大且灵活的开源调度框架，可以用于定时调度任务。可以通过配置Quartz的触发器来指定任务的执行时间。

示例代码：

import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class MyTask implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 执行定时任务逻辑
        System.out.println("定时任务执行");
    }

    public static void main(String[] args) throws SchedulerException {
        JobDetail job = JobBuilder.newJob(MyTask.class)
                .withIdentity("myJob", "group1")
                .build();

        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever())
                .build();

        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        scheduler.start();
        scheduler.scheduleJob(job, trigger);
    }
}

4. 使用TimerTask+Thread：可以创建一个继承自TimerTask的类，在其中实现要执行的任务逻辑，并在一个新线程中启动Timer来调度定时任务。

示例代码：

import java.util.Timer;
import java.util.TimerTask;

public class MyTask extends TimerTask {
    @Override
    public void run() {
        // 执行定时任务逻辑
        System.out.println("定时任务执行");
    }

    public static void main(String[] args) {
        new Thread(() -> {
            Timer timer = new Timer();
            timer.schedule(new MyTask(), 0, 1000);  // 每秒执行一次
        }).start();
    }
}

5. 使用Java的ScheduledThreadPoolExecutor：Java提供了ThreadPoolExecutor的子类ScheduledThreadPoolExecutor，可以用于定时调度任务。

示例代码：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class MyTask implements Runnable {
    @Override
    public void run() {
        // 执行定时任务逻辑
        System.out.println("定时任务执行");
    }

    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        executor.scheduleAtFixedRate(new MyTask(), 0, 1, TimeUnit.SECONDS);  // 每秒执行一次
    }
}

以上是五种不使用Spring框架实现定时任务的方法，选择适合自己项目需求的方式来实现定时任务即可。

如果不使用Spring框架，你可以使用Java原生的定时任务API来实现定时任务。

下面是一种实现定时任务的方法：

1. 创建一个类，用来实现定时任务的逻辑。例如，创建一个名为Task的类，它会在每隔一定时间输出一条信息到控制台上。

public class Task {
    public void run() {
        System.out.println("定时任务执行");
    }
}

2. 在主类中，创建一个定时任务调度器，并且配置定时任务的执行计划。

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Main {
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                Task myTask = new Task();
                myTask.run();
            }
        };
        Date startTime = new Date(); // 设置任务的起始时间
        int intervalTime = 5000; // 设置任务的执行间隔时间为5秒
        timer.scheduleAtFixedRate(task, startTime, intervalTime);
    }
}

在上述代码中，我们使用了Java提供的Timer类来创建定时任务调度器，TimerTask类用来定义定时任务的执行逻辑。scheduleAtFixedRate()方法用来配置定时任务的执行计划，其中第一个参数为要执行的任务，第二个参数为任务的起始时间，第三个参数为任务的执行间隔时间。

3. 运行程序，可以看到定时任务开始按照设定的计划执行。

定时任务执行
定时任务执行
定时任务执行
...

通过以上步骤，你就可以在不使用Spring的情况下实现定时任务的功能了。当然，Java还提供了其他的定时任务的实现方式，如使用ScheduledExecutorService，你可以根据自己的实际需求选择合适的方式来实现定时任务。