quartz的工具类

Quartz是一个开源的任务调度框架，它允许你在Java应用中安排和执行定期或一次性任务。Quartz的核心组件包括：

1. **Scheduler**：这是主要的工作引擎，负责管理任务的调度和执行。

2. **Job**：是需要执行的基本单位，通常是一个实现了`org.quartz.Job接口`的类，或者继承自`org.quartz.JobImpl`的类。

3. **JobDetail**：代表一个具体的任务，包含有关任务的信息，如Job名称、组名、触发器等。

4. **Trigger**：触发器定义了何时执行Job，它可以是定时的（如每天的特定时间）或事件驱动的。

5. **Calendar**：用于指定某些特定日期或时间段内，触发器应该被激活。

Quartz提供了一些工具类来方便地配置和管理任务，例如：

- `org.quartz.SchedulerBuilder`：用于构建`Scheduler`实例。
- `org.quartz.TriggerBuilder`：用于构建`Trigger`实例。
- `org.quartz.CronScheduleBuilder`：用于创建cron表达式的触发器。
- `org.quartz.SimpleScheduleBuilder`：用于创建简单时间间隔的触发器。

使用这些工具类，你可以通过XML配置文件或者程序代码动态地设置任务。Quartz还提供了API来进行调度的启动、停止、暂停和恢复操作。

相关问题

若依（Springboot+Vue）框架下 写一个静态工具类，判断被调用方法的调用方式是普通方式还是定时任务的方式（注意：框架定时任务为Quartz实现的）（不要使用AOP）

在Springboot+Vue框架下，可以通过以下方式编写一个静态工具类来判断被调用方法的调用方式是普通方式还是定时任务的方式，而不使用AOP：

1. 首先，引入Quartz的依赖，确保框架已经集成了Quartz。

2. 在工具类中，编写一个方法来判断调用方式：

import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SchedulerTaskExecutor;
import org.springframework.scheduling.support.CronTrigger;

import java.lang.reflect.Method;

public class InvokeTypeUtil {

    public static boolean isScheduledTask() {
        StackTraceElement[] elements = Thread.currentThread().getStackTrace();
        if (elements != null && elements.length >= 4) {
            String className = elements[3].getClassName();
            String methodName = elements[3].getMethodName();

            try {
                Class<?> cls = Class.forName(className);
                Method[] methods = cls.getMethods();
                for (Method method : methods) {
                    if (method.getName().equals(methodName)) {
                        if (isQuartzJob(method)) {
                            return true;
                        }
                    }
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

    private static boolean isQuartzJob(Method method) {
        Class<?> cls = method.getDeclaringClass();
        SchedulerFactoryBean schedulerFactoryBean = (SchedulerFactoryBean) SpringContextUtil.getBean(SchedulerFactoryBean.class);
        SchedulerTaskExecutor taskExecutor = schedulerFactoryBean.getTaskExecutor();
        Method invocableMethod = taskExecutor.getClass().getDeclaredMethod("getCurrentlyInvokedMethod");
        invocableMethod.setAccessible(true);
        Method currentlyInvokedMethod = (Method) invocableMethod.invoke(taskExecutor);

        if (currentlyInvokedMethod != null) {
            return cls.equals(currentlyInvokedMethod.getDeclaringClass()) && method.getName().equals(currentlyInvokedMethod.getName());
        } else {
            CronTrigger cronTrigger = (CronTrigger) SpringContextUtil.getBean(method.getName() + "Trigger");
            if (cronTrigger != null) {
                return cls.equals(cronTrigger.getJobDetail().getJobClass()) && method.getName().equals(cronTrigger.getJobDetail().getKey().getName());
            }
        }
        return false;
    }
}

3. 在调用方法中，通过调用`InvokeTypeUtil.isScheduledTask()`方法来判断调用方式：

public class MyService {

    public void myMethod() {
        if (InvokeTypeUtil.isScheduledTask()) {
            System.out.println("调用方式：定时任务");
        } else {
            System.out.println("调用方式：普通方式");
        }
    }
}

以上代码会判断当前调用的方法是否由Quartz定时任务触发，如果是则返回true，否则返回false。这样就可以实现判断被调用方法的调用方式是普通方式还是定时任务的方式。