SpringBoot 中 CommandLineRunner的作用示例详解

import org.springframework.boot.commandlinerunner;
import org.springframework.stereotype.component;
@component
public class mystartuprunner implements commandlinerunner {
    @override
    public void run(string... args) throws exception {
        system.out.println("项目已经启动");
    }
}

import lombok.extern.slf4j.slf4j;
import org.springframework.boot.commandlinerunner;
import org.springframework.core.ordered;
import org.springframework.stereotype.component;
/**
 * 优先级最高
 * 该类期望在springboot 启动后第一顺位执行
 * @since 12:57
 **/
@slf4j
@component
public class highordercommandlinerunner implements commandlinerunner, ordered {
    @override
    public void run(string... args) throws exception {
        for (string arg : args) {
            log.info("arg = " + arg);
        }
        log.info("i am highorderrunner");
    }
    @override
    public int getorder() {
        return integer.min_value+1;
    }
}

import lombok.extern.slf4j.slf4j;
import org.springframework.boot.commandlinerunner;
import org.springframework.core.ordered;
import org.springframework.stereotype.component;
/**
 * 优先级低于{@code highordercommandlinerunner}
 * @since 12:59
 **/
@slf4j
@component
public class lowordercommandlinerunner implements commandlinerunner, ordered {
    @override
    public void run(string... args) throws exception {
        log.info("i am loworderrunner");
    }
    @override
    public int getorder() {
        return integer.min_value+1;
    }
}

import org.springframework.boot.commandlinerunner;
import org.springframework.core.annotation.order;
import org.springframework.stereotype.component;
@component
@order(value=2)
public class mystartuprunner1 implements commandlinerunner {
    @override
    public void run(string... args) throws exception {
        system.out.println("执行2");
    }
}

import org.springframework.boot.commandlinerunner;
import org.springframework.core.annotation.order;
import org.springframework.stereotype.component;
@component
@order(value=1)
public class mystartuprunner2 implements commandlinerunner {
    @override
    public void run(string... args) throws exception {
        system.out.println("执行1");
    }
}

import lombok.extern.slf4j.slf4j;
import org.springframework.boot.applicationarguments;
import org.springframework.boot.applicationrunner;
import org.springframework.core.ordered;
import org.springframework.stereotype.component;
import java.util.arrays;
import java.util.list;
import java.util.set;
/**
 * 优先级最低
 **/
@slf4j
@component
public class defaultapplicationrunner implements applicationrunner, ordered {
    @override
    public void run(applicationarguments args) throws exception {
        log.info("i am applicationrunner");
        set<string> optionnames = args.getoptionnames();
        log.info("optionnames = " + optionnames);
        string[] sourceargs = args.getsourceargs();
        log.info("sourceargs = " + arrays.tostring(sourceargs));
        list<string> nonoptionargs = args.getnonoptionargs();
        log.info("nonoptionargs = " + nonoptionargs);
        list<string> optionvalues = args.getoptionvalues("foo");
        log.info("optionvalues = " + optionvalues);
    }
    @override
    public int getorder() {
        return integer.min_value+2;
    }
}

 optionvalues = null

java -jar yourapp.jar --foo=bar --foo=baz --dev.name=fcant java fcantcn

public configurableapplicationcontext run(string... args) {
   stopwatch stopwatch = new stopwatch();
   //设置线程启动计时器
   stopwatch.start();
   configurableapplicationcontext context = null;
   collection<springbootexceptionreporter> exceptionreporters = new arraylist<>();
   //配置系统属性：默认缺失外部显示屏等允许启动
   configureheadlessproperty();
   //获取并启动事件监听器，如果项目中没有其他监听器，则默认只有eventpublishingrunlistener
   springapplicationrunlisteners listeners = getrunlisteners(args);
   //将事件广播给listeners
   listeners.starting();
   try {
       //对于实现applicationrunner接口，用户设置applicationarguments参数进行封装
      applicationarguments applicationarguments = new defaultapplicationarguments(
            args);
      //配置运行环境：例如激活应用***.yml配置文件      
      configurableenvironment environment = prepareenvironment(listeners,
            applicationarguments);
      configureignorebeaninfo(environment);
      //加载配置的banner(gif,txt...)，即控制台图样
      banner printedbanner = printbanner(environment);
      //创建上下文对象，并实例化
      context = createapplicationcontext();
      exceptionreporters = getspringfactoriesinstances(
            springbootexceptionreporter.class,
            new class[] { configurableapplicationcontext.class }, context);
      //配置spring容器      
      preparecontext(context, environment, listeners, applicationarguments,
            printedbanner);
      //刷新spring上下文，创建bean过程中      
      refreshcontext(context);
      //空方法，子类实现
      afterrefresh(context, applicationarguments);
      //停止计时器：计算线程启动共用时间
      stopwatch.stop();
      if (this.logstartupinfo) {
         new startupinfologger(this.mainapplicationclass)
               .logstarted(getapplicationlog(), stopwatch);
      }
      //停止事件监听器
      listeners.started(context);
      //开始加载资源
      callrunners(context, applicationarguments);
   }
   catch (throwable ex) {
      handlerunfailure(context, listeners, exceptionreporters, ex);
      throw new illegalstateexception(ex);
   }
   listeners.running(context);
   return context;
}

private void callrunners(applicationcontext context, applicationarguments args) {
    //将实现applicationrunner和commandlinerunner接口的类，存储到集合中
   list<object> runners = new arraylist<>();
   runners.addall(context.getbeansoftype(applicationrunner.class).values());
   runners.addall(context.getbeansoftype(commandlinerunner.class).values());
   //按照加载先后顺序排序
   annotationawareordercomparator.sort(runners);
   for (object runner : new linkedhashset<>(runners)) {
      if (runner instanceof applicationrunner) {
         callrunner((applicationrunner) runner, args);
      }
      if (runner instanceof commandlinerunner) {
         callrunner((commandlinerunner) runner, args);
      }
   }
}

private void callrunner(commandlinerunner runner, applicationarguments args) {
   try {
       //调用各个实现类中的逻辑实现
      (runner).run(args.getsourceargs());
   }
   catch (exception ex) {
      throw new illegalstateexception("failed to execute commandlinerunner", ex);
   }
}