14.SpringShell源码分析-ApplicationRunner

SpringShell应用启动时, 会默认向IOC容器中注入两个ApplicationRunner: ScriptShellApplicationRunner 和 InteractiveShellApplicationRunner, 其中ScriptShellApplicationRunner 的优先级要高于InteractiveShellApplicationRunner.

1. ApplicationRunner 定义

1.1 InteractiveShellApplicationRunner

InteractiveShellApplicationRunner 指定顺序为0

@Order(InteractiveShellApplicationRunner.PRECEDENCE)
public class InteractiveShellApplicationRunner implements ApplicationRunner {
    // ...
}

1.2 ScriptShellApplicationRunner

定义时, 指定顺序为InteractiveShellApplicationRunner 的顺序-100, 也就是优先级大于InteractiveShellApplicationRunner, 通过这种方式限制优先注册ScriptShellApplicationRunner.

@Order(InteractiveShellApplicationRunner.PRECEDENCE - 100) // Runs before InteractiveShellApplicationRunner
public class ScriptShellApplicationRunner implements ApplicationRunner {
    // ...
}

1.3 配置类JLineShellAutoConfiguration

配置类JLineShellAutoConfiguration中注入 interactiveApplicationRunner 和 scriptApplicationRunner 组件, 有条件注入, 默认为true.

@Configuration
public class JLineShellAutoConfiguration {
	@Bean
	@ConditionalOnProperty(prefix = SPRING_SHELL_INTERACTIVE, value = InteractiveShellApplicationRunner.ENABLED, havingValue = "true", matchIfMissing = true)
	public ApplicationRunner interactiveApplicationRunner(Parser parser, Environment environment) {
		return new InteractiveShellApplicationRunner(lineReader(), promptProvider, parser, shell, environment);
	}

	@Bean
	@ConditionalOnProperty(prefix = SPRING_SHELL_SCRIPT, value = ScriptShellApplicationRunner.ENABLED, havingValue = "true", matchIfMissing = true)
	public ApplicationRunner scriptApplicationRunner(Parser parser, ConfigurableEnvironment environment) {
		return new ScriptShellApplicationRunner(parser, shell, environment);
	}
}

2. 源码分析

本文只设计ApplicationRunner的运行流程, 不涉及bean 初始化等其它流程.

1. 启动容器, 遍历执行自定义ApplicationRunner

• SpringShell 应用通过 SpringApplication.run(SpringShellApplication.class, args)启动项目, 会调用org.springframework.boot.SpringApplication#run(java.lang.String…) 方法
• org.springframework.boot.SpringApplication#run(java.lang.String…) 会对容器进行初始化, 创建bean 等操作, 然后会调用所有自定义的ApplicationRunner 的run方法

// 源码: org.springframework.boot.SpringApplication#callRunners
 private void callRunners(ApplicationContext context, ApplicationArguments args) {
    // 获取容器中定义的所有ApplicationRunner
    List<Object> runners = new ArrayList();
    runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
    runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
    AnnotationAwareOrderComparator.sort(runners);
    Iterator var4 = (new LinkedHashSet(runners)).iterator();

    // 遍历所有ApplicationRunner, 执行其run方法.
    while(var4.hasNext()) {
        Object runner = var4.next();
        if (runner instanceof ApplicationRunner) {
            // callRunner()方法里就是执行runner.run(args) 方法
            this.callRunner((ApplicationRunner)runner, args);
        }

        if (runner instanceof CommandLineRunner) {
            this.callRunner((CommandLineRunner)runner, args);
        }
    }
}

2. 优先执行ScriptShellApplicationRunner.run(args)方法

1. 首先对所有启动参数做一遍过滤, 获取所有的脚本参数, 并创建文件列表. 也就是说, 只要启动参数包含脚本参数, 则忽略所有其它参数.
2. 如果启动参数中,包含脚本参数:
   1. 关闭交互式方式, 在执行InteractiveShellApplicationRunner.run 方法时, 会先判断是否
   2. 遍历脚本列表, 为每个脚本文件创建一个InputProvider, 每个脚本都作为一个独立的输入源, 执行sell.run()方法
   3. 每个脚本读到最后都返回null, shell.run()读到null时, 结束shell.run()中的循环.
3. 如果启动参数, 不包含脚本参数, 则此ApplicationRunner运行结束, 接下来运行下一个ApplicationRunner, 即InteractiveShellApplicationRunner

//  org.springframework.shell.jline.ScriptShellApplicationRunner#run**
@Override
public void run(ApplicationArguments args) throws Exception {
    # 1.获取启动参数中所有以@开头的参数, 为每个脚本参数创建一个File对象, 组成File列表
	List<File> scriptsToRun = args.getNonOptionArgs().stream()
			.filter(s -> s.startsWith("@"))
			.map(s -> new File(s.substring(1)))
			.collect(Collectors.toList());

	boolean batchEnabled = environment.getProperty(SPRING_SHELL_SCRIPT_ENABLED, boolean.class, true);

    # 2.如果脚本参数不为空
	if (!scriptsToRun.isEmpty() && batchEnabled) {
	    // 3.设置关闭交互式方式, 保证运行为脚本的所有命令之后, 直接关闭程序
		InteractiveShellApplicationRunner.disable(environment);
		// 4.遍历每个脚本, 为每个脚本创建一个命令提供源, 依次执行shell的run方法.
		for (File file : scriptsToRun) {
			try (Reader reader = new FileReader(file);
					FileInputProvider inputProvider = new FileInputProvider(reader, parser)) {
				shell.run(inputProvider);
			}
		}
	}
}

3. 其次执行 InteractiveShellApplicationRunner.run(args)方法

1. 首先判断, 交互方式是否打开. 即在ScriptShellApplicationRunner.run中有没有关闭交互时方式
2. 如果交互方式打开, 则创建控制台命令输入源, 执行shell的run方法. shell 的run 会进入无限循环, 当用户输入为null 时, 则终止循环, 退出程序

// 源码: org.springframework.shell.jline.InteractiveShellApplicationRunner#run
@Override
public void run(ApplicationArguments args) throws Exception {
    // 获取交互方式是否打开, 如果ScriptShellApplicationRunner 中执行了第三步, 此处获取即为false.
	boolean interactive = isEnabled();

	// 如果交互方式打开(为true), 则创建控制台输入源, 执行shell 的run方法
	if (interactive) {
		InputProvider inputProvider = new JLineInputProvider(lineReader, promptProvider);
		shell.run(inputProvider);
	}
}

4. 核心方法Shell.run(InputProvider)

• Shell的run方法是一个无限循环, 会循环地从传入的InputProvider中获取命令, 如果获取为空, 则跳出循环, 结束run方法; 否则解析命令, 执行命令,并将返回值输出.
• run方法从InputProvider 中是一条命令一条命令读取的, 且只有当返回值为null时, 才会跳出run方法, 结束方法运行. 这一点在自定义Runner时需要注意.

// 源码: org.springframework.shell.Shell#run
public void run(InputProvider inputProvider) throws IOException {
    // 自定义循环退出码
	Object result = null;

	// 无限循环, 知道result为退出嘛
	while (!(result instanceof ExitRequest)) {
		Input input;

		// 从输入源中读取一条输入
		try {
			input = inputProvider.readInput();
		}
		catch (Exception e) {
			resultHandler.handleResult(e);
			continue;
		}

		// 当读取的输入为null时, 跳出循环, 结束此shell的运行
		if (input == null) {
			break;
		}

		// 执行命令, 相应结果
		result = evaluate(input);

		// 处理结果, 回显终端
		if (result != NO_INPUT && !(result instanceof ExitRequest)) {
			resultHandler.handleResult(result);
		}
	}
}