import io.bootique.log.BootLogger; //导入依赖的package包/类
public CommandOutcome run(Consumer<BQRuntime> beforeShutdownCallback, String... args) {

        BootLogger logger = createBootLogger();
        Bootique bootique = Bootique.app(args).bootLogger(logger);
        configure(bootique);

        BQRuntime runtime = bootique.createRuntime();
        try {
            return runtime.getInstance(Runner.class).run();
        } catch (Exception e) {
            logger.stderr("Error", e);
            return CommandOutcome.failed(1, getStderr());
        } finally {

            try {
                beforeShutdownCallback.accept(runtime);
            }
            finally {
                runtime.shutdown();
            }
        }
    }
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Singleton
@Provides
Server createServer(ServerFactory factory,
                    Set<Servlet> servlets,
                    Set<MappedServlet> mappedServlets,
                    Set<Filter> filters,
                    Set<MappedFilter> mappedFilters,
                    Set<EventListener> listeners,
                    Set<MappedListener> mappedListeners,
                    BootLogger bootLogger,
                    ShutdownManager shutdownManager) {

    Server server = factory.createServer(
            allServlets(servlets, mappedServlets),
            allFilters(filters, mappedFilters),
            allListeners(listeners, mappedListeners));

    shutdownManager.addShutdownHook(() -> {
        bootLogger.trace(() -> "stopping Jetty...");
        server.stop();
    });

    return server;
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
private Thread createJVMShutdownHook() {

        // resolve all services needed for shutdown eagerly and outside shutdown thread to ensure that shutdown hook
        // will not fail due to misconfiguration, etc.

        ShutdownManager shutdownManager = this.shutdownManager;
        BootLogger logger = this.bootLogger;

        return new Thread("bootique-shutdown") {

            @Override
            public void run() {
                shutdown(shutdownManager, logger);
            }
        };
    }
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
/**
 * Registers a JVM shutdown hook that is delegated to {@link ShutdownManager}.
 *
 * @see Bootique#exec()
 * @since 0.11
 * @deprecated since 0.23 unused as {@link Bootique} class handles JVM-level shutdown events. BQRuntime should not
 * get involved in that.
 */
@Deprecated
public void addJVMShutdownHook() {

    // resolve all Injector services needed for shutdown eagerly and outside
    // shutdown thread to ensure that shutdown hook will not fail due to
    // misconfiguration, etc.

    ShutdownManager shutdownManager = injector.getInstance(ShutdownManager.class);
    BootLogger logger = getBootLogger();

    Runtime.getRuntime().addShutdownHook(new Thread("bootique-shutdown") {

        @Override
        public void run() {
            shutdown(shutdownManager, logger);
        }
    });
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Override
public void configure(Binder binder) {

    BQCoreModule.extend(binder)
            .initAllExtensions()
            .addOption(createConfigOption())
            .addCommand(HelpConfigCommand.class);

    // bind instances
    binder.bind(BootLogger.class).toInstance(Objects.requireNonNull(bootLogger));
    binder.bind(ShutdownManager.class).toInstance(Objects.requireNonNull(shutdownManager));
    binder.bind(String[].class).annotatedWith(Args.class).toInstance(Objects.requireNonNull(args));

    // deprecated, kept for those users who may have injected this in their own code
    binder.bind(Duration.class).annotatedWith(ShutdownTimeout.class)
            .toInstance(Objects.requireNonNull(Duration.ofMillis(10000L)));

    // too much code to create config factory.. extracting it in a provider
    // class...
    binder.bind(ConfigurationFactory.class).toProvider(JsonNodeConfigurationFactoryProvider.class).in(Singleton.class);
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Provides
@Singleton
ExecutionPlanBuilder provideExecutionPlanBuilder(
        Provider<CliFactory> cliFactoryProvider,
        Provider<CommandManager> commandManagerProvider,
        Set<CommandRefDecorated> commandDecorators,
        BootLogger logger,
        ShutdownManager shutdownManager) {

    Provider<ExecutorService> executorProvider = () -> {
        ExecutorService service = Executors.newCachedThreadPool(new CommandDispatchThreadFactory());
        shutdownManager.addShutdownHook(() -> service.shutdownNow());
        return service;
    };

    Map<Class<? extends Command>, CommandDecorator> merged = ExecutionPlanBuilder.mergeDecorators(commandDecorators);
    return new ExecutionPlanBuilder(cliFactoryProvider, commandManagerProvider, executorProvider, merged, logger);
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Provides
@Singleton
Environment provideEnvironment(
        @EnvironmentProperties Map<String, String> diProperties,
        @EnvironmentVariables Map<String, String> diVars,
        Set<DeclaredVariable> declaredVariables,
        BootLogger logger) {

    DefaultEnvironment.Builder environment = DefaultEnvironment.builder(logger);

    if (Boolean.valueOf(diProperties.get(EXCLUDE_SYSTEM_PROPERTIES))) {
        environment.excludeSystemProperties();
    }
    if (Boolean.valueOf(diProperties.containsKey(EXCLUDE_SYSTEM_VARIABLES))) {
        environment.excludeSystemVariables();
    }

    return environment.diProperties(diProperties)
            .diVariables(diVars)
            .declaredVariables(declaredVariables)
            .build();
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
public MultiCommand(
        Command mainCommand,
        CommandDecorator extraCommands,
        Provider<CliFactory> cliFactoryProvider,
        Provider<CommandManager> commandManagerProvider,
        Provider<ExecutorService> executorProvider,
        BootLogger logger) {

    super(mainCommand.getMetadata());

    this.logger = logger;
    this.mainCommand = mainCommand;
    this.cliFactoryProvider = cliFactoryProvider;
    this.commandManagerProvider = commandManagerProvider;
    this.executorProvider = executorProvider;
    this.extraCommands = extraCommands;
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Inject
public JsonNodeConfigurationFactoryProvider(
        ConfigurationSource configurationSource,
        Environment environment,
        JacksonService jacksonService,
        BootLogger bootLogger,
        Set<OptionMetadata> optionMetadata,
        Set<OptionRefWithConfig> optionDecorators,
        Cli cli) {

    this.configurationSource = configurationSource;
    this.environment = environment;
    this.jacksonService = jacksonService;
    this.bootLogger = bootLogger;
    this.optionMetadata = optionMetadata;
    this.optionDecorators = optionDecorators;
    this.cli = cli;
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Singleton
@Provides
public DataSourceFactory createDataSource(
        ConfigurationFactory configFactory,
        BootLogger bootLogger,
        ShutdownManager shutdownManager,
        Set<DataSourceListener> listeners,
        Injector injector) {

    Map<String, ManagedDataSourceFactory> configs = configFactory
            .config(new TypeRef<Map<String, ManagedDataSourceFactory>>() {
            }, configPrefix);

    LazyDataSourceFactory factory = new LazyDataSourceFactoryFactory(configs).create(injector, listeners);
    shutdownManager.addShutdownHook(() -> {
        bootLogger.trace(() -> "shutting down LazyDataSourceFactory...");
        factory.shutdown();
    });

    return factory;
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Provides
@Singleton
public UndertowServer createServer(Builder builder,
                                   BootLogger bootLogger,
                                   ShutdownManager shutdownManager) {
    UndertowServer server = new UndertowServer(builder);
    shutdownManager.addShutdownHook(() -> {
        bootLogger.trace(() -> "stopping Undertow...");
        server.stop();
    });

    return server;
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Inject
public ListCommand(Provider<JobRegistry> jobRegistryProvider, BootLogger bootLogger) {
	super(createMetadata());

	this.jobRegistryProvider = jobRegistryProvider;
	this.bootLogger = bootLogger;
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
public HelpConfigCommand(BootLogger bootLogger, Provider<ConfigHelpGenerator> helpGeneratorProvider) {
    super(CommandMetadata
            .builder(HelpConfigCommand.class)
            .description("Prints information about application modules and their configuration options.")
            .shortName('H'));

    this.bootLogger = bootLogger;
    this.helpGeneratorProvider = helpGeneratorProvider;
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
/**
 * Executes Bootique runtime shutdown, allowing all interested DI services to perform cleanup.
 *
 * @since 0.12
 */
public void shutdown() {
    ShutdownManager shutdownManager = injector.getInstance(ShutdownManager.class);
    BootLogger logger = getBootLogger();

    shutdown(shutdownManager, logger);
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Provides
@Singleton
ConfigurationSource provideConfigurationSource(Cli cli, @DIConfigs Set<String> diConfigs, BootLogger bootLogger) {
    return CliConfigurationSource
            .builder(bootLogger)
            .diConfigs(diConfigs)
            .cliConfigs(cli)
            .build();
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Provides
@Singleton
Terminal provideTerminal(BootLogger bootLogger) {

    // very simple OS test...
    boolean isUnix = "/".equals(System.getProperty("file.separator"));
    return isUnix ? new SttyTerminal(bootLogger) : new FixedWidthTerminal(TTY_DEFAULT_COLUMNS);
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Provides
@Singleton
CommandManager createManager(Set<Command> moduleCommands,
                             @ExtraCommands Set<Command> extraCommands,
                             HelpCommand helpCommand,
                             Injector injector,
                             BootLogger bootLogger) {

    return new CommandManagerWithOverridesBuilder(moduleCommands, bootLogger)
            .defaultCommand(defaultCommand(injector))
            .helpCommand(helpCommand)
            .hideBaseCommands(noModuleCommands)
            .overrideWith(extraCommands)
            .build();
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
public ExecutionPlanBuilder(
        Provider<CliFactory> cliFactoryProvider,
        Provider<CommandManager> commandManagerProvider,
        Provider<ExecutorService> executorProvider,
        Map<Class<? extends Command>, CommandDecorator> decorators,
        BootLogger logger) {

    this.logger = logger;
    this.decorators = decorators;
    this.cliFactoryProvider = cliFactoryProvider;
    this.commandManagerProvider = commandManagerProvider;
    this.executorProvider = executorProvider;
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Test
public void testDeclaredVar_InHelp() {

    ByteArrayOutputStream out = new ByteArrayOutputStream();
    ByteArrayOutputStream err = new ByteArrayOutputStream();
    BootLogger logger = new DefaultBootLogger(false, new PrintStream(out), new PrintStream(err));

    BQModuleProvider configurableProvider = new BQModuleProvider() {
        @Override
        public Module module() {
            return b -> {
            };
        }

        @Override
        public Map<String, Type> configs() {
            return Collections.singletonMap("x", Bean5.class);
        }
    };

    BQRuntime runtime = testFactory.app()
            .module(configurableProvider)
            .declareVar("x.m", "X_VALID_VAR")
            .declareVar("x.y.prop", "X_INVALID_VAR")
            .bootLogger(logger)
            .createRuntime();

    Cli cli = runtime.getInstance(Cli.class);
    runtime.getInstance(HelpCommand.class).run(cli);

    String help = new String(out.toByteArray());
    assertTrue("No ENVIRONMENT section:\n" + help, help.contains("ENVIRONMENT"));
    assertTrue(help.contains("X_VALID_VAR"));
    assertFalse(help.contains("X_INVALID_VAR"));
}
 

import io.bootique.log.BootLogger; //导入依赖的package包/类
@Test
@Ignore
public void testDeclaredVar_InHelpWithMap() {

    ByteArrayOutputStream out = new ByteArrayOutputStream();
    ByteArrayOutputStream err = new ByteArrayOutputStream();
    BootLogger logger = new DefaultBootLogger(false, new PrintStream(out), new PrintStream(err));

    BQModuleProvider configurableProvider = new BQModuleProvider() {
        @Override
        public Module module() {
            return b -> {
            };
        }

        @Override
        public Map<String, Type> configs() {
            return Collections.singletonMap("x", Bean4.class);
        }
    };

    BQRuntime runtime = testFactory.app()
            .module(configurableProvider)
            .declareVar("x.m.prop", "X_VALID_VAR")
            .declareVar("x.m.prop.x", "X_INVALID_VAR")
            .bootLogger(logger)
            .createRuntime();

    Cli cli = runtime.getInstance(Cli.class);
    runtime.getInstance(HelpCommand.class).run(cli);

    String help = new String(out.toByteArray());
    assertTrue("No ENVIRONMENT section:\n" + help, help.contains("ENVIRONMENT"));
    assertTrue(help.contains("X_VALID_VAR"));
    assertFalse(help.contains("X_INVALID_VAR"));
}