如何获取当前执行的Trigger

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class TriggerNameExample {

    public static void main(String[] args) throws SchedulerException {
        // 创建调度器
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // 定义 JobDetail
        JobDetail job = JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob", "group1")
                .build();

        // 定义触发器
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .withSchedule(CronScheduleBuilder.cronSchedule("0 0 7 * * ? *"))
                .build();

        // 将 JobDetail 和 Trigger 注册到调度器中
        scheduler.scheduleJob(job, trigger);

        // 启动调度器
        scheduler.start();
    }

    public static class MyJob implements Job {
        @Override
        public void execute(JobExecutionContext context) throws JobExecutionException {
            // 获取当前执行的 Trigger
            Trigger currentTrigger = context.getTrigger();

            // 获取当前执行的 Trigger 的名称
            String triggerName = currentTrigger.getKey().getName();

            // 输出当前执行的 Trigger 的名称
            System.out.println("当前执行的 Trigger 名称: " + triggerName);
        }
    }
}

在示例中，我们在 MyJob 的 execute() 方法中添加了代码来获取当前执行的 Trigger。首先使用 context.getTrigger() 方法获取当前执行的 Trigger 对象，然后使用 getKey().getName() 方法获取 Trigger 的名称。
这样，你就可以在 execute() 方法中获取当前执行的 Trigger 的名称，并根据需要进行处理。

如何注册多个rigger 到同一个 Job 上

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class MultipleTriggersExample {

    public static void main(String[] args) throws SchedulerException {
        // 创建调度器
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // 定义 JobDetail
        JobDetail job = JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob", "group1")
                .build();

        // 定义触发器1
        Trigger trigger1 = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")
                .withSchedule(CronScheduleBuilder.cronSchedule("0 0 7 * * ? *"))
                .build();

        // 定义触发器2
        Trigger trigger2 = TriggerBuilder.newTrigger()
                .withIdentity("trigger2", "group1")
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(10))
                .startAt(DateBuilder.futureDate(10, DateBuilder.IntervalUnit.SECOND))
                .build();

        // 将 JobDetail 和 Trigger1 注册到调度器中
        scheduler.scheduleJob(job, trigger1);

        // 将 JobDetail 和 Trigger2 注册到调度器中
        scheduler.scheduleJob(job, trigger2);

        // 启动调度器
        scheduler.start();
    }

    public static class MyJob implements Job {
        @Override
        public void execute(JobExecutionContext context) throws JobExecutionException {
            // 在这里定义具体的任务逻辑
            System.out.println("Job 执行时间: " + context.getFireTime());
        }
    }
}

在上述示例中，我们创建了两个触发器 trigger1 和 trigger2，分别使用了不同的调度策略。trigger1 使用了 Cron 表达式 “0 0 7 * * ? *”，表示每天早上 7 点触发。trigger2 使用了简单的重复调度策略，每隔 10 秒触发一次，从当前时间开始延迟 10 秒。
然后，我们将同一个 Job MyJob 和不同的触发器注册到调度器中，通过调用 scheduler.scheduleJob(job, trigger) 方法来完成注册。
当调度器启动后，MyJob 的 execute() 方法会根据各个触发器的调度策略进行执行。
请注意，这只是一个示例，你可以根据需要注册多个触发器，并根据不同的调度策略来定制你的任务执行逻辑。

在 Quartz 中，Trigger 类是一个抽象类，不支持直接继承。如果你想创建自定义的 Trigger 类，需要实现 Trigger 接口。

以下是一个示例代码，演示如何创建自定义的 Trigger 类：

import org.quartz.*;

import java.util.Date;

public class MyTrigger implements Trigger {

    @Override
    public Date getNextFireTime() {
        // 在这里实现获取下一次触发时间的逻辑
        return null;
    }

    @Override
    public Date getPreviousFireTime() {
        // 在这里实现获取上一次触发时间的逻辑
        return null;
    }

    @Override
    public void setNextFireTime(Date date) {
        // 在这里实现设置下一次触发时间的逻辑
    }

    @Override
    public void setPreviousFireTime(Date date) {
        // 在这里实现设置上一次触发时间的逻辑
    }

    // 其他 Trigger 接口的方法，根据需要进行实现

    @Override
    public void triggered(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        // 在这里实现触发时的逻辑
    }

    @Override
    public void updateAfterMisfire(org.quartz.Calendar calendar) {
        // 在这里实现错过触发后的处理逻辑
    }

    @Override
    public void updateWithNewCalendar(org.quartz.Calendar calendar, long l) {
        // 在这里实现更新 Trigger 的日历和时间偏移量的逻辑
    }

    @Override
    public int executionComplete(JobExecutionContext jobExecutionContext, JobExecutionException e) {
        // 在这里实现任务执行完成后的处理逻辑
        return 0;
    }

    // 其他 Trigger 接口的方法，根据需要进行实现
}

在上述示例中，我们创建了一个名为 MyTrigger 的类，实现了 Quartz 的 Trigger 接口。
你可以根据需要在 MyTrigger 类中实现 Trigger 接口的方法，以满足你的定制需求。例如，你可以在 getNextFireTime() 方法中实现获取下一次触发时间的逻辑，或者在 triggered() 方法中实现触发时的逻辑。
请注意，在实现自定义 Trigger 时，你需要考虑触发时间的计算、任务触发逻辑的实现以及错过触发的处理等方面的功能。