[Java] Spring Boot支持Crontab任务改造的方法

package com.github.zhgxun.learn.common.task;
 
import com.github.zhgxun.learn.common.task.annotation.scheduletask;
import lombok.extern.slf4j.slf4j;
import org.springframework.boot.springapplication;
import org.springframework.context.applicationcontext;
import org.springframework.context.applicationlistener;
import org.springframework.context.event.contextrefreshedevent;
 
import java.lang.reflect.invocationtargetexception;
import java.lang.reflect.method;
import java.util.list;
import java.util.stream.collectors;
import java.util.stream.stream;
 
/**
 * 不自动加入容器, 用于区分是否属于任务启动, 否则放入容器中, spring 无法选择性执行
 * 需要根据特殊参数在启动时注入
 * 该监听器本身不能访问容器变量, 如果需要访问, 需要从上下文中获取对象实例后方可继续访问实例信息
 * 如果其它类中启动了多线程, 是无法接管异常抛出的, 需要子线程中正确处理退出操作
 * 该监听器最好不用直接做线程操作, 子类的实现不干预
 */
@slf4j
public class taskapplicationlistener implements applicationlistener<contextrefreshedevent> {
  /**
   * 任务启动监听类标识, 启动时注入
   * 即是 java -dspring.task.class=com.github.zhgxun.learn.task.testtask -jar learn.jar
   */
  private static final string spring_task_class = "spring.task.class";
 
  /**
   * 支持该注解的方法个数, 目前仅一个
   * 可以理解为控制台一次执行一个类, 依赖的任务应该通过其它方式控制依赖
   */
  private static final int support_method_count = 1;
 
  /**
   * 保存当前容器运行上下文
   */
  private applicationcontext context;
 
  /**
   * 监听容器刷新事件
   *
   * @param event 容器刷新事件
   */
  @override
  @suppresswarnings("unchecked")
  public void onapplicationevent(contextrefreshedevent event) {
  context = event.getapplicationcontext();
  // 不存在时可能为正常的容器启动运行, 无需关心
  string taskclass = system.getproperty(spring_task_class);
  log.info("scheduletask spring task class: {}", taskclass);
  if (taskclass != null) {
    try {
    // 获取类字节码文件
    class clazz = findclass(taskclass);
 
    // 尝试从内容上下文中获取已加载的目标类对象实例, 这个类实例是已经加载到容器内的对象实例, 即可以获取类的信息
    object object = context.getbean(clazz);
 
    method method = findmethod(object);
 
    log.info("start to run task class: {}, method: {}", taskclass, method.getname());
    invoke(method, object);
    } catch (classnotfoundexception | illegalaccessexception | invocationtargetexception e) {
    e.printstacktrace();
    } finally {
    // 需要确保容器正常出发停止事件, 否则容器会僵尸卡死
    shutdown();
    }
  }
  }
 
  /**
   * 根据class路径名称查找类文件
   *
   * @param clazz 类名称
   * @return 类对象
   * @throws classnotfoundexception classnotfoundexception
   */
  private class findclass(string clazz) throws classnotfoundexception {
  return class.forname(clazz);
  }
 
  /**
   * 获取目标对象中符合条件的方法
   *
   * @param object 目标对象实例
   * @return 符合条件的方法
   */
  private method findmethod(object object) {
  method[] methods = object.getclass().getdeclaredmethods();
  list<method> schedules = stream.of(methods)
    .filter(method -> method.isannotationpresent(scheduletask.class))
    .collect(collectors.tolist());
  if (schedules.size() != support_method_count) {
    throw new illegalstateexception("only one method should be annotated with @scheduletask, but found "
      + schedules.size());
  }
  return schedules.get(0);
  }
 
  /**
   * 执行目标对象方法
   *
   * @param method 目标方法
   * @param object 目标对象实例
   * @throws illegalaccessexception  illegalaccessexception
   * @throws invocationtargetexception invocationtargetexception
   */
  private void invoke(method method, object object) throws illegalaccessexception, invocationtargetexception {
  method.invoke(object);
  }
 
  /**
   * 执行完毕退出运行容器, 并将返回值交给执行环节, 比如控制台等
   */
  private void shutdown() {
  log.info("shutdown ...");
  system.exit(springapplication.exit(context));
  }
}

package com.github.zhgxun.learn.common.task.annotation;
 
import java.lang.annotation.documented;
import java.lang.annotation.elementtype;
import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;
 
@retention(retentionpolicy.runtime)
@target(elementtype.method)
@documented
public @interface scheduletask {
}

package com.github.zhgxun.learn.task;
 
import com.github.zhgxun.learn.common.task.annotation.scheduletask;
import com.github.zhgxun.learn.service.first.launchinfoservice;
import lombok.extern.slf4j.slf4j;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.service;
 
import java.util.concurrent.timeunit;
 
@service
@slf4j
public class testtask {
 
  @autowired
  private launchinfoservice launchinfoservice;
 
  @scheduletask
  public void test() {
  log.info("start task ...");
  log.info("launchinfolist: {}", launchinfoservice.findall());
 
  log.info("模拟启动线程操作");
  for (int i = 0; i < 5; i++) {
    new mytask(i).start();
  }
 
  try {
    timeunit.seconds.sleep(3);
  } catch (interruptedexception e) {
    e.printstacktrace();
  }
  }
}
 
class mytask extends thread {
  private int i;
  private int j;
  private string s;
 
  public mytask(int i) {
  this.i = i;
  }
 
  @override
  public void run() {
  super.run();
  system.out.println("第 " + i + " 个线程启动..." + thread.currentthread().getname());
  if (i == 2) {
    throw new runtimeexception("模拟运行时异常");
  }
  if (i == 3) {
    // 除数不为0
    int a = i / j;
  }
  // 未对字符串对象赋值, 获取长度报空指针错误
  if (i == 4) {
    system.out.println(s.length());
  }
  }
}

package com.github.zhgxun.learn;
 
import com.github.zhgxun.learn.common.task.taskapplicationlistener;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.boot.builder.springapplicationbuilder;
 
@springbootapplication
public class learnapplication {
 
  public static void main(string[] args) {
  springapplicationbuilder builder = new springapplicationbuilder(learnapplication.class);
  // 根据启动注入参数判断是否为任务动作即可, 否则不干预启动
  if (system.getproperty("spring.task.class") != null) {
    builder.listeners(new taskapplicationlistener()).run(args);
  } else {
    builder.run(args);
  }
  }
}

java -dspring.task.class=com.github.zhgxun.learn.task.testtask -jar target/learn.jar