public static void start(String[] args, Set<Class> coreBean, Set<Class> apiBean) {
    logger.info("***** STARTING GEMINI POSTRESQL MAIN *****");

    ConfigurableApplicationContext root = getGeminiRootContext(args, coreBean);

    logger.info("STARTING - GEMINI-WEBAPP CONTEXT ");
    SpringApplicationBuilder webAppBuilder = new SpringApplicationBuilder()
            .parent(root).sources(Api.class).sources(GuiAPI.class, AuthModuleAPI.class, AutoConfiguration.class).web(WebApplicationType.SERVLET);
    if (apiBean.size() != 0) {
        webAppBuilder.sources(apiBean.toArray(new Class[0]));
    }
    ConfigurableApplicationContext gui = webAppBuilder.bannerMode(Banner.Mode.OFF)
            .run(args);
    gui.setId("GEMINI-WAPP");
    logger.info("STARTED - GEMINI-WEBAPP CONTEXT");
}
 

@NotNull
private static ConfigurableApplicationContext getGeminiRootContext(String[] args, Set<Class> coreBean) {
    logger.info("STARTING - GEMINI-ROOT CONTEXT ");
    SpringApplicationBuilder appBuilder = new SpringApplicationBuilder()
            .parent(AutoConfiguration.class, Gemini.class, AuthModule.class, GuiModule.class);
    if (coreBean.size() != 0) {
        appBuilder.sources(coreBean.toArray(new Class[0]));
    }
    ConfigurableApplicationContext root = appBuilder
            .web(WebApplicationType.NONE)
            .bannerMode(Banner.Mode.OFF)
            .run(args);
    root.setId("GEMINI-ROOT");
    Gemini gemini = root.getBean(Gemini.class);
    gemini.init();
    logger.info("STARTED - GEMINI-ROOT CONTEXT");
    return root;
}
 

public static void main(String[] args) throws Exception {

        // the code must execute before spring start
        JarFile bootJarFile = BootJarLaucherUtils.getBootJarFile();
        if (bootJarFile != null) {
            BootJarLaucherUtils.unpackBootLibs(bootJarFile);
            log.debug("the temp tac lib folder:{}", BootJarLaucherUtils.getTempUnpackFolder());
        }
        SpringApplication springApplication = new SpringApplication(ContainerApplication.class);

        springApplication.setWebEnvironment(true);
        springApplication.setBannerMode(Banner.Mode.OFF);

        springApplication.addListeners(new ApplicationListener<ApplicationEnvironmentPreparedEvent>() {
            @Override
            public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
                CodeLoadService.changeClassLoader(event.getEnvironment());
            }
        });
        springApplication.run(args);
    }
 

/**
 * Constructor
 *
 * @param shellListenerService shell listener service
 * @param banner               shell banner
 * @param promptProvider       prompt provider
 * @param shell                spring shell
 * @param completerAdapter     completer adapter
 * @param parser               jline parser
 * @param environment          spring environment
 * @param properties           ssh shell properties
 */
public SshShellCommandFactory(SshShellListenerService shellListenerService,
                              @Autowired(required = false) Banner banner,
                              @Lazy PromptProvider promptProvider,
                              Shell shell,
                              JLineShellAutoConfiguration.CompleterAdapter completerAdapter, Parser parser,
                              Environment environment,
                              SshShellProperties properties) {
    this.shellListenerService = shellListenerService;
    this.shellBanner = banner;
    this.promptProvider = promptProvider;
    this.shell = shell;
    this.completerAdapter = completerAdapter;
    this.parser = parser;
    this.environment = environment;
    this.properties = properties;
}
 

public SshShellRunnable(SshShellProperties properties, ChannelSession session,
                        SshShellListenerService shellListenerService, Banner shellBanner,
                        PromptProvider promptProvider, Shell shell,
                        JLineShellAutoConfiguration.CompleterAdapter completerAdapter, Parser parser,
                        Environment environment, org.apache.sshd.server.Environment sshEnv,
                        SshShellCommandFactory sshShellCommandFactory, InputStream is,
                        OutputStream os, ExitCallback ec) {
    this.properties = properties;
    this.session = session;
    this.shellListenerService = shellListenerService;
    this.shellBanner = shellBanner;
    this.promptProvider = promptProvider;
    this.shell = shell;
    this.completerAdapter = completerAdapter;
    this.parser = parser;
    this.environment = environment;
    this.sshEnv = sshEnv;
    this.sshShellCommandFactory = sshShellCommandFactory;
    this.is = is;
    this.os = os;
    this.ec = ec;
}
 

public static void start (final int port, final int managementPort, final boolean withSsl, final String [] args) {
    Map<String, Object> properties = new HashMap<String, Object>();
    properties.put ("server.port", port);
    properties.put ("management.port", managementPort);
    if (withSsl) {
        properties.put ("server.ssl.key-store", "classpath:server/libe/libe.jks");
        properties.put ("server.ssl.key-store-password", "myserverpass");
        properties.put ("server.ssl.trust-store", "classpath:server/libe/libe.jks");
        properties.put ("server.ssl.trust-store-password", "myserverpass");
        properties.put ("server.ssl.client-auth", "need");
        properties.put ("server.ssl.enabled-protocols","SSLv2,SSLv3,TLSv1.0,TLSv1.1,TLSv1.2");
    }
    RequestMonitor.context = new SpringApplicationBuilder ()
            .sources (RequestMonitor.class)
            .bannerMode (Banner.Mode.OFF)
            .addCommandLineProperties (true)
            .properties (properties)
            .run (args);
}
 

public static void main(String[] args) throws Exception {
    try (ConfigurableApplicationContext ctx = new SpringApplicationBuilder(SpringBootstrap.class)
            .bannerMode(Banner.Mode.OFF).web(WebApplicationType.NONE).run(args)) {
        Configuration conf = ctx.getBean(Configuration.class);
        HashMap<String, String> apacheConf = new HashMap<>();
        Accumulo accumuloConf = conf.getAccumulo();
        apacheConf.put("instance.name", accumuloConf.getInstanceName());
        apacheConf.put("instance.zookeeper.host", accumuloConf.getZookeepers());
        ClientConfiguration aconf = ClientConfiguration.fromMap(apacheConf);
        Instance instance = new ZooKeeperInstance(aconf);
        Connector con = instance.getConnector(accumuloConf.getUsername(),
                new PasswordToken(accumuloConf.getPassword()));

        TabletMetadataQuery query = new TabletMetadataQuery(con, conf.getMetricsTable());
        TabletMetadataView view = query.run();

        System.out.println(view.toText(TimeUnit.DAYS));
    }
}
 

public static synchronized void start(String[] args) throws IOException {
  String daqName = getProperty("c2mon.daq.name");
  if (daqName == null) {
    throw new RuntimeException("Please specify the DAQ process name using 'c2mon.daq.name'");
  }

  // The JMS mode (single, double, test) is controlled via Spring profiles
  String mode = getProperty("c2mon.daq.jms.mode");
  if (mode != null) {
    System.setProperty(AbstractEnvironment.ACTIVE_PROFILES_PROPERTY_NAME, mode);
  }

  if (application == null) {
    application = new SpringApplicationBuilder(DaqStartup.class)
            .bannerMode(Banner.Mode.OFF)
            .build();
  }
  context = application.run(args);

  driverKernel = context.getBean(DriverKernel.class);
  driverKernel.init();

  log.info("DAQ core is now initialized");
}
 

@Test
public void defaultLocalPlatform() {
	ApplicationContext context = new SpringApplicationBuilder(TestConfig.class)
			.web(WebApplicationType.NONE)
			.bannerMode(Banner.Mode.OFF)
			.properties(testProperties())
			.run();
	Map<String, TaskPlatform> taskPlatforms = context.getBeansOfType(TaskPlatform.class);
	assertThat(taskPlatforms).hasSize(1);
	TaskPlatform taskPlatform = taskPlatforms.values().iterator().next();
	assertThat(taskPlatform.getName()).isEqualTo("Local");
	assertThat(taskPlatform.getLaunchers()).hasSize(1);
	assertThat(taskPlatform.getLaunchers().get(0).getName()).isEqualTo("default");
	assertThat(taskPlatform.getLaunchers().get(0).getType()).isEqualTo("Local");
	assertThat(taskPlatform.getLaunchers().get(0).getTaskLauncher()).isInstanceOf(LocalTaskLauncher.class);
}
 

@Test
public void multipleLocalPlatformAccounts() {
	ApplicationContext context = new SpringApplicationBuilder(TestConfig.class)
			.web(WebApplicationType.NONE)
			.bannerMode(Banner.Mode.OFF)
			.properties(testProperties(
					"spring.cloud.dataflow.task.platform.local.accounts[big].javaOpts=-Xmx2048m",
					"spring.cloud.dataflow.task.platform.local.accounts[small].javaOpts=-Xmx1024m"))
			.run();
	Map<String, TaskPlatform> taskPlatforms = context.getBeansOfType(TaskPlatform.class);
	assertThat(taskPlatforms).hasSize(1);
	TaskPlatform taskPlatform = taskPlatforms.values().iterator().next();
	assertThat(taskPlatform.getName()).isEqualTo("Local");
	assertThat(taskPlatform.getLaunchers()).hasSize(2);
	assertThat(taskPlatform.getLaunchers()).extracting("type").containsExactly("Local","Local");
	assertThat(taskPlatform.getLaunchers()).extracting("name").containsExactlyInAnyOrder("big", "small");
}
 

@Override
public void execute() throws MojoExecutionException {
    Map<String, Object> defaultProperties = new HashMap<>();
    defaultProperties.put("spring.config.location", "file:./src/main/resources/");

    ConfigurableApplicationContext context = new SpringApplicationBuilder()
            .sources(Application.class)
            .bannerMode(Banner.Mode.OFF)
            .properties(defaultProperties)
            .run();

    this.environment = context.getEnvironment();

    String[] activeProfiles = context.getEnvironment().getActiveProfiles();
    String profiles = activeProfiles.length != 0 ? String.join(",", activeProfiles) : "Default";
    log.info("Active Profiles: {}", profiles);
    StringEncryptor encryptor = context.getBean(StringEncryptor.class);
    run(new EncryptionService(encryptor), context, encryptPrefix, encryptSuffix, decryptPrefix, decryptSuffix);
}
 

private static SpringApplicationBuilder configureApplication(SpringApplicationBuilder builder) {
    ApplicationListener<ApplicationReadyEvent>  readyListener=new ApplicationListener<ApplicationReadyEvent> () {

        @Override
        public void onApplicationEvent(ApplicationReadyEvent event) {
            ConfigurableApplicationContext context = event.getApplicationContext();
            UserMapper userMapper=context.getBean(UserMapper.class);
            userMapper.allUsers();
            
            UserCondition condition = new UserCondition();
            PageRequest page =new PageRequest(1, 10);
            condition.setPageable(page);
            condition.setStatus(1);
            userMapper.listByCondition(condition);
        }
        
    };
    return builder.sources(CacheDemoApplication.class).bannerMode(Banner.Mode.OFF).listeners(readyListener);
}
 

public static void main(String[] args) {
    ProgramCommand programCommand = ProgramCommand.parseArgs(args);
    if (programCommand == ProgramCommand.EMPTY) {
        printHelp();
        return;
    }
    Command command = Command.fromValue(programCommand.getCommand());
    if (command == null) {
        LOGGER.info(Markers.TERMINAL, "'{}' is not a valid command.", programCommand.getCommand());
        printHelp();
        return;
    }
    if (command == Command.HELP) {
        printHelp();
        return;
    }
    SpringApplication application = new SpringApplication(HbaseSchemaManager.class);
    application.setBannerMode(Banner.Mode.OFF);
    application.run(args);
}
 

public static void main(String[] args) {

		SpringApplication application = new SpringApplication(OpenzalySpringBoot.class);
		application.setBannerMode(Banner.Mode.OFF);
		// application.setDefaultProperties(properties);
		application.run(args);
	}
 

public static void startfor3Party(String[] args, Set<Class> coreBean, Set<Class> childContextBean) {
    logger.info("***** STARTING GEMINI POSTRESQL 3PARTY MAIN *****");
    ConfigurableApplicationContext root = getGeminiRootContext(args, coreBean);

    logger.info("STARTING - GEMINI-CHILD CONTEXT ");
    SpringApplicationBuilder webAppBuilder = new SpringApplicationBuilder()
            .parent(root).sources(AutoConfiguration.class).web(WebApplicationType.NONE);
    if (childContextBean.size() != 0) {
        webAppBuilder.sources(childContextBean.toArray(new Class[0]));
    }
    ConfigurableApplicationContext gui = webAppBuilder.bannerMode(Banner.Mode.OFF)
            .run(args);
    gui.setId("GEMINI-CHILD");
    logger.info("STARTED - GEMINI-CHILD CONTEXT");
}
 

public static void main(String[] args) {

        ConfigurableApplicationContext root = new SpringApplicationBuilder()
                .parent(Gemini.class, TestAppMain.class).web(WebApplicationType.NONE)
                .bannerMode(Banner.Mode.OFF)
                .run(args);
        root.setId("Root");

        ConfigurableApplicationContext webApp = new SpringApplicationBuilder()
                .parent(root).sources(Api.class, TestAppMain.class).web(WebApplicationType.SERVLET)
                .bannerMode(Banner.Mode.OFF)
                .run(args);
        webApp.setId("API");
    }
 

private static ConfigurableApplicationContext loadRealAppApplicationContext(Class... classes) {
    return new SpringApplicationBuilder()
            .parent(Autoconfiguration.class, Gemini.class).web(WebApplicationType.NONE)
            .sources(classes)
            .bannerMode(Banner.Mode.OFF)
            .run();
}
 

public static ConfigurableApplicationContext initializeFullIntegrationWebApp(Set<Class> coreBean, Set<Class> apiBean) {
    ConfigurableApplicationContext root = initializeGemini(coreBean.toArray(new Class[0]));
    ConfigurableApplicationContext webApp = new SpringApplicationBuilder()
            .parent(root).sources(Api.class, Autoconfiguration.class).sources(apiBean.toArray(new Class[0]))
            .web(WebApplicationType.SERVLET)
            .bannerMode(Banner.Mode.OFF)
            .run();
    return webApp;
}
 

public static void main(String[] args) {
	SpringApplication app = new SpringApplication(XmlParserApplication.class);
	// disable spring banner
	app.setBannerMode(Banner.Mode.OFF);
	app.run(args);

}
 

public Environment getEnvironment(Map<String, Object> properties) {
	SpringApplicationBuilder builder = new SpringApplicationBuilder(TestApp.class)
		.web(WebApplicationType.NONE);
	if (!CollectionUtils.isEmpty(properties)) {
		builder.properties(properties);
	}
	builder.bannerMode(Banner.Mode.OFF);
	ApplicationContext applicationContext = builder.run();
	Environment environment = applicationContext.getEnvironment();
	((ConfigurableApplicationContext) applicationContext).close();
	return environment;
}
 

public Environment getEnvironment() {
	SpringApplicationBuilder builder = new SpringApplicationBuilder(TestApp.class)
			.web(WebApplicationType.NONE);
	builder.bannerMode(Banner.Mode.OFF);
	ApplicationContext applicationContext = builder.run();
	return applicationContext.getEnvironment();
}
 

@Override
public void printBanner(Environment environment, Class<?> sourceClass, PrintStream out) {
    for (String line : BANNER) {
        out.println(AnsiOutput.toString(BRIGHT_BLUE, line));
    }

    String version = Banner.class.getPackage().getImplementationVersion();
    version = (version == null ? "" : " (v" + version + ")...");
    out.println(AnsiOutput.toString(BRIGHT_YELLOW, SPRING_BOOT, version));
    out.println();
}
 

public static void main(String[] args) {
    new SpringApplicationBuilder()
            .banner(new TheEmbersBanner())
            .bannerMode(Banner.Mode.LOG)
            .sources(Application.class)
            .run(args);
}
 

public static void main(String[] args) {

		SpringApplication application = new SpringApplication(OpenzalySpringBoot.class);
		application.setBannerMode(Banner.Mode.OFF);
		// application.setDefaultProperties(properties);
		application.run(args);
	}
 

/**
 * Required per http://docs.spring.io/spring-boot/docs/current/reference/html/howto-traditional-deployment.html
 * in order produce a traditional deployable war file.
 *
 * @param application
 * @return
 */

@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
    ConfigurableApplicationContext sharedAc = ((SpringCompMgr) ComponentManager.getInstance()).getApplicationContext();
    application.parent(sharedAc);
    return application.bannerMode(Banner.Mode.OFF).sources(RubricsApplication.class);
}
 

@Override
protected WebApplicationContext run(SpringApplication application) {
    application.setBannerMode(Banner.Mode.OFF);
    WebApplicationContext webApplicationContext = super.run(application);
    bootstrap(webApplicationContext);
    return webApplicationContext;
}
 

public static void main(String[] args) {

		SpringApplication application = new SpringApplication(OpenzalySpringBoot.class);
		application.setBannerMode(Banner.Mode.OFF);
		// application.setDefaultProperties(properties);
		application.run(args);
	}
 

public static void main(String[] args) {
	new SpringApplicationBuilder(SpringBoot2IntroApplication.class)
			.bannerMode(Banner.Mode.OFF)
			.initializers((GenericApplicationContext genericApplicationContext) -> {
									genericApplicationContext.registerBean("internet", InternetHealthIndicator.class);
							  })
			.run(args);
}
 

public static void main(String[] args) {

    String pidFile = System.getenv("LOGSEARCH_PID_FILE") == null ? "logsearch.pid" : System.getenv("LOGSEARCH_PID_FILE");
    new SpringApplicationBuilder(LogSearch.class)
      .bannerMode(Banner.Mode.OFF)
      .listeners(new ApplicationPidFileWriter(pidFile))
      .web(WebApplicationType.SERVLET)
      .run(args);
  }
 

public static void main(String[] args) {
  String pidFile = System.getenv("LOGFEEDER_PID_FILE") == null ? "logfeeder.pid" : System.getenv("LOGFEEDER_PID_FILE");
  new SpringApplicationBuilder(LogFeeder.class)
    .bannerMode(Banner.Mode.OFF)
    .listeners(new ApplicationPidFileWriter(pidFile))
    .run(args);
}