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

package com.github.zhgxun.learn测试数据mon.task;

import com.github.zhgxun.learn测试数据mon.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测试数据mon.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测试数据mon.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测试数据mon.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