14.SpringShell源码分析-ApplicationRunner

Bertha 。 2022-03-22 14:09 271阅读 0赞

> 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);
    		}
    	}
    }