获取项目启动时的参数

package net.fan.init;

import lombok.extern.slf4j.Slf4j;
import net.fan.common.FileUtil;
import net.fan.common.SpringUtils;
import net.fan.domain.TimeModel;
import net.fan.domain.WeatherType;
import net.fan.service.base.BaseHandleService;
import net.fan.service.ncep.NcepServiceImpl;
import net.fan.service.rain.RainServiceImpl;
import net.fan.service.sand.SandServiceImpl;
import net.fan.service.strongconvection.StrongConvServiceImpl;
import net.fan.service.temperature.TemperatureServiceImpl;
import net.fan.service.wind.WindServiceImpl;
import org.apache.commons.cli.*;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * 命令行参数解析
 */
@Slf4j
@Component
public class StartupRunner implements CommandLineRunner {
    //保存所有算法的集合
    private List<String> typesList;
    //micaps3输出路径
    private String rootpath;
    //可选参数
    private TimeModel timeModel;
    //ini文件路径
    private String iniFile;
    //实例类型
    private String type;

    public StartupRunner() {
        this.timeModel = TimeModel.builder().build();
    }

    /**
     * @param args
     * @throws Exception
     */
    @Override
    public void run(String... args) throws Exception {
        CommandLineParser parser = new PosixParser();
        Options options = new Options();

        // 使用 $ java -jar App.jar -h
        options.addOption("h", "help", false, "参数信息");
        // ini文件路径,必传
        options.addOption("file", "", true, "ini配置文件路径");
        // 实例类型,必传
        options.addOption("type", "", true, "实例类型,格式:wind/rain/temp");
        // 时间段,沙尘查询,可选
        options.addOption("anytime", "", true, "时间段,格式以逗号隔开:YYYYMMDDHH,YYYYMMDDHH");

        CommandLine commandLine = parser.parse(options, args);

        HelpFormatter hf = new HelpFormatter();

        // 打印使用帮助
        if (commandLine.hasOption("h")) {
            hf.printHelp("cma", options, true);
        }

        //必传参数判断
        vitifyRequiredParams(commandLine);
        if (StringUtils.isAnyBlank(iniFile, type)) {
            return;
        }

        // 解析ini文件
        processIni();
        if (CollectionUtils.isEmpty(typesList)) {
            return;
        }

        //可选参数判断
        vitifyOptionalParams(commandLine);

        // 识别实例类型,执行算法
        processArithmetic(type);

        //执行完成退出
        System.exit(0);
    }

    /**
     * 必选参数判断
     *
     * @param commandLine
     */
    private void vitifyRequiredParams(CommandLine commandLine) {
        //必传参数判断
        if (!commandLine.hasOption("file") || !commandLine.hasOption("type")) {
            return;
        }
        //必传参数值判断
        this.iniFile = commandLine.getOptionValue("file");
        this.type = commandLine.getOptionValue("type");
    }

    /**
     * 可选参数判断
     *
     * @param commandLine
     */
    private void vitifyOptionalParams(CommandLine commandLine) {
        //可选参数判断
        if (commandLine.hasOption("anytime")) {
            String anytime = commandLine.getOptionValue("anytime");
            if (StringUtils.isNotBlank(anytime)) {
                this.timeModel.setAnyTime(anytime);
            }
        }
        if (commandLine.hasOption("dateTime")) {
            String dateTime = commandLine.getOptionValue("dateTime");
            if (StringUtils.isNotBlank(dateTime)) {
                this.timeModel.setDateTime(dateTime);
            }
        }
    }

    /**
     * 解析ini文件并保存处理文件里的数据
     */
    private void processIni() {
        // 解析ini文件
        Map<String, String> map = FileUtil.readIniFile(iniFile);
        if (CollectionUtils.isEmpty(map)) {
            return;
        }
        //micaps3输出路径
        this.rootpath = map.get("rootpath");
        //对应算法
        String types = map.get("types");
        // ini文件参数判断
        if (StringUtils.isAnyBlank(rootpath, types)) {
            return;
        }
        String[] typesArr = types.split(",");
        this.typesList = Arrays.asList(typesArr);
    }


    /**
     * 算法处理
     *
     * @param clazz
     * @param <T>
     */
    private <T extends BaseHandleService> void processHandle(Class<T> clazz) {
        T instance = SpringUtils.getBean(clazz);
        if (Objects.isNull(instance)) {
            return;
        }

        if(!CollectionUtils.isEmpty(typesList)){
            typesList.stream().forEach(t->{
                try {
                    WeatherType weatherType = WeatherType.builder().type(t).rootpath(rootpath).timeModel(timeModel).build();
                    instance.handle(weatherType);
                    log.info("执行算法 {} 完成。", t);
                } catch (Exception e) {
                    log.error("{} 对应的算法错误，错误信息：{}。", t, e.getMessage());
                }
            });
        }
    }

    /**
     * 执行算法
     *
     * @param type
     */
    private void processArithmetic(String type) {
        if (StringUtils.isBlank(type)) {
            return;
        }
        switch (type) {
            case "wind":
                processHandle(WindServiceImpl.class);
                break;
            case "rain":
                processHandle(RainServiceImpl.class);
                break;
            case "temperature":
                processHandle(TemperatureServiceImpl.class);
                break;
            case "necp":
                processHandle(NcepServiceImpl.class);
                break;
            case "sand":
                processHandle(SandServiceImpl.class);
                break;
            case "strongconv":
                processHandle(StrongConvServiceImpl.class);
                break;
            default:
                break;
        }
    }
}