Java 类org.springframework.context.ConfigurableApplicationContext 实例源码

@SuppressWarnings("unchecked")
public static void main (String[] args){

    ConfigurableApplicationContext ac =
            new ClassPathXmlApplicationContext("/context.xml");
    PollableChannel feedChannel = ac.getBean("feedChannel", PollableChannel.class);

    for (int i = 0; i < 10; i++) {
        Message<SyndEntry> message = (Message<SyndEntry>) feedChannel.receive(1000);
        if (message != null){
            System.out.println("==========="+i+"===========");
            SyndEntry entry = message.getPayload();
            System.out.println(entry.getAuthor());
            System.out.println(entry.getPublishedDate());
            System.out.println(entry.getTitle());
            System.out.println(entry.getUri());
            System.out.println(entry.getLink());
            System.out.println("======================");

        }
    }
    ac.close();


}

public static void main(String[] args) {
    try (ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(ScopeConfig.class);) {
        Dictionary singletonDictionary = context.getBean("singletonDictionary", Dictionary.class);
        logger.info("Singleton Scope example starts");
        singletonDictionary.addWord("Give");
        singletonDictionary.addWord("Take");
        int totalWords = singletonDictionary.totalWords();
        logger.info("Need to have two words. Total words are : " + totalWords);
        logger.info(singletonDictionary.toString());
        singletonDictionary = context.getBean("singletonDictionary", Dictionary.class);
        logger.info("Need to have two words. Total words are : " + totalWords);
        logger.info(singletonDictionary.toString());
        logger.info("Singleton Scope example ends");

        Dictionary prototypeDictionary = context.getBean("prototypeDictionary", Dictionary.class);
        logger.info("Prototype scope example starts");
        prototypeDictionary.addWord("Give 2");
        prototypeDictionary.addWord("Take 2");
        logger.info("Need to have two words. Total words are: " + prototypeDictionary.totalWords());
        logger.info(prototypeDictionary.toString());
        prototypeDictionary = context.getBean("prototypeDictionary", Dictionary.class);
        logger.info("zero word count. Total words are: " + prototypeDictionary.totalWords());
        logger.info(prototypeDictionary.toString());
    }
}

/**
 * Return the {@code WebApplicationContext} passed in at construction time, if available.
 * Otherwise, attempt to retrieve a {@code WebApplicationContext} from the
 * {@code ServletContext} attribute with the {@linkplain #setContextAttribute
 * configured name} if set. Otherwise look up a {@code WebApplicationContext} under
 * the well-known "root" application context attribute. The
 * {@code WebApplicationContext} must have already been loaded and stored in the
 * {@code ServletContext} before this filter gets initialized (or invoked).
 * <p>Subclasses may override this method to provide a different
 * {@code WebApplicationContext} retrieval strategy.
 * @return the {@code WebApplicationContext} for this proxy, or {@code null} if not found
 * @see #DelegatingFilterProxy(String, WebApplicationContext)
 * @see #getContextAttribute()
 * @see WebApplicationContextUtils#getWebApplicationContext(javax.servlet.ServletContext)
 * @see WebApplicationContext#ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE
 */
protected WebApplicationContext findWebApplicationContext() {
    if (this.webApplicationContext != null) {
        // the user has injected a context at construction time -> use it
        if (this.webApplicationContext instanceof ConfigurableApplicationContext) {
            if (!((ConfigurableApplicationContext)this.webApplicationContext).isActive()) {
                // the context has not yet been refreshed -> do so before returning it
                ((ConfigurableApplicationContext)this.webApplicationContext).refresh();
            }
        }
        return this.webApplicationContext;
    }
    String attrName = getContextAttribute();
    if (attrName != null) {
        return WebApplicationContextUtils.getWebApplicationContext(getServletContext(), attrName);
    }
    else {
        return WebApplicationContextUtils.getWebApplicationContext(getServletContext());
    }
}

@Override
public void afterPropertiesSet() throws Exception {
    if (this.propertySources == null) {
        this.propertySources = deducePropertySources();
    }

    if (this.conversionService == null) {
        this.conversionService = getOptionalBean(
                ConfigurableApplicationContext.CONVERSION_SERVICE_BEAN_NAME,
                ConfigurableConversionService.class);
    }

    // If no explicit conversion service is provided we add one so that (at least)
    // comma-separated arrays of convertibles can be bound automatically
    if (this.conversionService == null) {
        this.conversionService = getDefaultConversionService();
    }

    this.propertyResolver = new PropertySourcesPropertyResolver(this.propertySources);
    this.propertyResolver.setConversionService(this.conversionService);
}

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    if (bean instanceof LoadTimeWeaverAware) {
        LoadTimeWeaver ltw = this.loadTimeWeaver;
        if (ltw == null) {
            Assert.state(this.beanFactory != null,
                    "BeanFactory required if no LoadTimeWeaver explicitly specified");
            ltw = this.beanFactory.getBean(
                    ConfigurableApplicationContext.LOAD_TIME_WEAVER_BEAN_NAME, LoadTimeWeaver.class);
        }
        ((LoadTimeWeaverAware) bean).setLoadTimeWeaver(ltw);
    }
    return bean;
}

public static void main(String[] args) {
    SpringApplicationBuilder builder = new SpringApplicationBuilder(Launcher.class);
    Set<ApplicationListener<?>> listeners = builder.application().getListeners();
    for (Iterator<ApplicationListener<?>> it = listeners.iterator(); it.hasNext();) {
        ApplicationListener<?> listener = it.next();
        if (listener instanceof LoggingApplicationListener) {
            it.remove();
        }
    }
    builder.application().setListeners(listeners);
    ConfigurableApplicationContext context = builder.run(args);
    LOGGER.info("collector metrics start successfully");

    KafkaConsumer kafkaConsumer = (KafkaConsumer<byte[], String>) context.getBean("kafkaConsumer");
    Task task = (Task) context.getBean("metricsTask");

    // 优雅停止项目
    Runtime.getRuntime().addShutdownHook(new ShutdownHookRunner(kafkaConsumer, task));
    task.doTask();
}

/**
 * Return the ApplicationContext that this base class manages; may be
 * {@code null}.
 */
public final ConfigurableApplicationContext getApplicationContext() {
    // lazy load, in case setUp() has not yet been called.
    if (this.applicationContext == null) {
        try {
            this.applicationContext = getContext(contextKey());
        }
        catch (Exception e) {
            // log and continue...
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Caught exception while retrieving the ApplicationContext for test [" +
                        getClass().getName() + "." + getName() + "].", e);
            }
        }
    }

    return this.applicationContext;
}

public static void main(String[] args) throws Exception {
    ConfigurableApplicationContext context = SpringApplication.run(AemOrchestrator.class, args);

    //Need to wait for Author ELB is be in a healthy state before reading messages from the SQS queue
    ResourceReadyChecker resourceReadyChecker = context.getBean(ResourceReadyChecker.class);

    boolean isStartupOk = false;

    if(resourceReadyChecker.isResourcesReady()) {
        OrchestratorMessageListener messageReceiver = context.getBean(OrchestratorMessageListener.class);

        try {
            messageReceiver.start();
            isStartupOk = true;
        } catch (Exception e) {
            logger.error("Failed to start message receiver", e);
        }
    }

    if(isStartupOk) {
        logger.info("AEM Orchestrator started");
    } else {
        logger.info("Failed to start AEM Orchestrator");
        context.close(); //Exit the application
    }
}

public HandlerMethodService(ConversionService conversionService,
        List<HandlerMethodArgumentResolver> customArgumentResolvers,
        ObjectMapper objectMapper, ApplicationContext applicationContext) {
    this.conversionService = conversionService;
    this.parameterNameDiscoverer = new DefaultParameterNameDiscoverer();

    this.argumentResolvers = new HandlerMethodArgumentResolverComposite();

    ConfigurableBeanFactory beanFactory = ClassUtils.isAssignableValue(
            ConfigurableApplicationContext.class, applicationContext)
                    ? ((ConfigurableApplicationContext) applicationContext)
                            .getBeanFactory()
                    : null;

    this.argumentResolvers.addResolver(
            new HeaderMethodArgumentResolver(this.conversionService, beanFactory));
    this.argumentResolvers.addResolver(new HeadersMethodArgumentResolver());
    this.argumentResolvers.addResolver(new WampMessageMethodArgumentResolver());
    this.argumentResolvers.addResolver(new PrincipalMethodArgumentResolver());
    this.argumentResolvers.addResolver(new WampSessionIdMethodArgumentResolver());
    this.argumentResolvers.addResolvers(customArgumentResolvers);

    this.objectMapper = objectMapper;
}

public void run(Class clazz, String[] args) {
        SpringApplication springApplication = new SpringApplication(clazz);
//        springApplication.addListeners(new ApplicationPidFileWriter("application.pid"));
        ConfigurableApplicationContext ctx = springApplication.run(args);
        Environment env = ctx.getEnvironment();
        if (env.acceptsProfiles(ProfileConstant.RT_SCRIPT)) {
            if (args.length > 0) {
                String shellClass = args[0];
                ScriptInterface script = (ScriptInterface) ctx.getBean(shellClass);
                if (null != script) {
                    try {
                        if (args.length > 1) {
                            script.run(Arrays.copyOfRange(args, 1, args.length));
                        } else {
                            script.run(new String[]{});
                        }
                    } catch (Exception e) {
                        scriptLogger.error("error occur", e);
                    }
                }
            }
        }
    }

public static void main(String[] args) throws InterruptedException {
    log.info("Initializing channel node");
    ConfigurableApplicationContext context = SpringApplication.run(ChannelNodeApplication.class, args);
    log.info("Starting API interfaces");
    context.start();
    NodeServer nodeServer = context.getBean(NodeServer.class);
    log.info("Channel node started");
    nodeServer.awaitTermination();
}

public static void main(String[] args) {
    SpringApplicationBuilder builder = new SpringApplicationBuilder(Launcher.class);
    Set<ApplicationListener<?>> listeners = builder.application().getListeners();
    for (Iterator<ApplicationListener<?>> it = listeners.iterator(); it.hasNext();) {
        ApplicationListener<?> listener = it.next();
        if (listener instanceof LoggingApplicationListener) {
            it.remove();
        }
    }
    builder.application().setListeners(listeners);
    ConfigurableApplicationContext context = builder.run(args);
    LOGGER.info("collector indexer start successfully");

    KafkaConsumer kafkaConsumer = (KafkaConsumer<byte[], String>) context.getBean("kafkaConsumer");
    Task task = (Task) context.getBean("indexerTask");

    // 优雅停止项目
    Runtime.getRuntime().addShutdownHook(new ShutdownHookRunner(kafkaConsumer, task));
    task.doTask();
}

@Override
public void customizeContext(ConfigurableApplicationContext context, MergedContextConfiguration mergedConfig) {
    Class<?> testClass = mergedConfig.getTestClass();
    FlywayTest flywayAnnotation = AnnotatedElementUtils.findMergedAnnotation(testClass, FlywayTest.class);

    BeanDefinitionRegistry registry = getBeanDefinitionRegistry(context);
    RootBeanDefinition registrarDefinition = new RootBeanDefinition();

    registrarDefinition.setBeanClass(PreloadableEmbeddedPostgresRegistrar.class);
    registrarDefinition.getConstructorArgumentValues()
            .addIndexedArgumentValue(0, databaseAnnotation);
    registrarDefinition.getConstructorArgumentValues()
            .addIndexedArgumentValue(1, flywayAnnotation);

    registry.registerBeanDefinition("preloadableEmbeddedPostgresRegistrar", registrarDefinition);
}

public static void main(String[] args) {
    final SpringApplication app = new SpringApplication(Application.class);
    // save the pid into a file...
    app.addListeners(new ApplicationPidFileWriter("smarti.pid"));

    final ConfigurableApplicationContext context = app.run(args);
    final ConfigurableEnvironment env = context.getEnvironment();

    try {
        //http://localhost:8080/admin/index.html
        final URI uri = new URI(
                (env.getProperty("server.ssl.enabled", Boolean.class, false) ? "https" : "http"),
                null,
                (env.getProperty("server.address", "localhost")),
                (env.getProperty("server.port", Integer.class, 8080)),
                (env.getProperty("server.context-path", "/")).replaceAll("//+", "/"),
                null, null);

        log.info("{} started: {}",
                env.getProperty("server.display-name", context.getDisplayName()),
                uri);
    } catch (URISyntaxException e) {
        log.warn("Could not build launch-url: {}", e.getMessage());
    }
}

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    /**
     * 注册通用Dao
     */
    registerBaseCommonDao(registry);
    /**
     * 注册代理类
     */
    registerProxyHandler(registry);
    /**
     * 加载其他层接口
     */
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry, annotation);
    scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
}

@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
    this.environment = applicationContext.getEnvironment();
    this.resourceLoader = applicationContext;
    this.profile = Profiles.getActiveProfile(environment);

    NameLocationPair pair = getPropertySourceFirst();
    if(pair != null){
        addPropertySource(pair.getName(),pair.getLocation());
    }
    addPropertySource(OVERRIDE_PROPERTIES_SOURCE_NAME, System.getProperty(OVERRIDE_PROPERTIES_SOURCE_LOCATION));
    addPropertySource(PROJECT_PROPERTIES_SOURCE_NAME, PROJECT_PROPERTIES_SOURCE_LOCATION);
    addPropertySource(PROJECT_PROPERTIES_SOURCE_DEFAULT_NAME, PROJECT_PROPERTIES_SOURCE_DEFAULT_LOCATION);
    addPropertySource(PARENT_PROPERTIES_SOURCE_NAME, PARENT_PROPERTIES_SOURCE_LOCATION);
    addPropertySource(PARENT_PROPERTIES_SOURCE_DEFAULT_NAME, PARENT_PROPERTIES_SOURCE_DEFAULT_LOCATION);

    LogbackConfig.init(LOGBACK_CONFIG_LOCATION);
}

public static void main(String[] args) {
    ConfigurableApplicationContext ctx = SpringApplication.run(Application.class, args);
    String welcomeMsg = ctx.getEnvironment().getProperty("app.open.msg");
    ZeroMQEventSubscriber sub = ctx.getBean(ZeroMQEventSubscriber.class);
    System.out.println(welcomeMsg);
    sub.receive();
}

@SuppressWarnings("unchecked")
private Class<ApplicationContextInitializer<ConfigurableApplicationContext>> loadInitializerClass(String className) {
    try {
        Class<?> clazz = ClassUtils.forName(className, ClassUtils.getDefaultClassLoader());
        Assert.isAssignable(ApplicationContextInitializer.class, clazz);
        return (Class<ApplicationContextInitializer<ConfigurableApplicationContext>>) clazz;
    }
    catch (ClassNotFoundException ex) {
        throw new ApplicationContextException("Failed to load context initializer class [" + className + "]", ex);
    }
}

@Override
public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
    EnvironmentTestUtils.addEnvironment("testcontainers", configurableApplicationContext.getEnvironment(),
            "cassandra.host=" + cassandra.getContainerIpAddress(),
            "cassandra.port=" + cassandra.getMappedPort(9042)
    );
}

@Override
protected Set<ConfigurableApplicationContext> findApplicationContexts() {
    Set<ConfigurableApplicationContext> contexts = new LinkedHashSet<ConfigurableApplicationContext>();
    Enumeration<String> attrNames = this.servletContext.getAttributeNames();
    while (attrNames.hasMoreElements()) {
        String attrName = attrNames.nextElement();
        Object attrValue = this.servletContext.getAttribute(attrName);
        if (attrValue instanceof ConfigurableApplicationContext) {
            contexts.add((ConfigurableApplicationContext) attrValue);
        }
    }
    return contexts;
}

public static void main(String[] args) {
    SpringApplication bootstrap = new  SpringApplication(SpringBootRunner.class);

    bootstrap.addListeners(new MyStartListner());
    //  对Context进行最后的设置工作
    bootstrap.addInitializers(new MyContextInitializer());
    //  增加命令

    ConfigurableApplicationContext context = bootstrap.run(args);

    //  触发一个事件
    MyTellEvent event = new MyTellEvent(context, "测试的事件信息");
    context.publishEvent(event);
}

@Override
public void initialize(final ConfigurableApplicationContext ctx) {
    final DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService(true);
    conversionService.setEmbeddedValueResolver(new CasConfigurationEmbeddedValueResolver(ctx));
    ctx.getEnvironment().setConversionService(conversionService);

}

private String resolve(String value) {
    if (StringUtils.hasText(value)
            && this.resourceLoader instanceof ConfigurableApplicationContext) {
        return ((ConfigurableApplicationContext) this.resourceLoader).getEnvironment()
                .resolvePlaceholders(value);
    }
    return value;
}

@Bean
public BinderTestPropertiesInitializer loadProps(ConfigurableApplicationContext context) {
    // minimal properties for the context to load
    Properties properties = new Properties();
    properties.put("modelLocation", "classpath:tensorflow/model/linear_regression_graph.proto");
    properties.put("outputName", "add");
    return new BinderTestPropertiesInitializer(context, properties);
}

@Before
public void setup() {
    // Prepare
    appContext = Mockito.mock(ConfigurableApplicationContext.class);
    confEnv = Mockito.mock(ConfigurableEnvironment.class);
    healthCheck = new GracefulShutdownHealthCheck();
    final HashMap<String, IProbeController> beans = new HashMap<>();
    beans.put(GracefulShutdownHealthCheck.class.getName(), healthCheck);

    // Test
    when(confEnv.getProperty(GracefulShutdownHook.GRACEFUL_SHUTDOWN_WAIT_SECONDS, "20")).thenReturn(String.valueOf(SHUTDOWN_WAIT_S));
    when(appContext.getEnvironment()).thenReturn(confEnv);
    when(appContext.getBeansOfType(IProbeController.class)).thenReturn(beans);
}

public void testProxy() throws Exception {
    // publish service
    bundleContext.registerService(new String[] { DataSource.class.getName(), Comparator.class.getName(),
        InitializingBean.class.getName(), Constants.class.getName() }, new Service(), new Hashtable());

    ConfigurableApplicationContext ctx = getNestedContext();
    assertNotNull(ctx);
    Object proxy = ctx.getBean("service");
    assertNotNull(proxy);
    assertTrue(proxy instanceof DataSource);
    assertTrue(proxy instanceof Comparator);
    assertTrue(proxy instanceof Constants);
    assertTrue(proxy instanceof InitializingBean);
    ctx.close();
}

public void testInterfacesHierarchy() {
       //Closeable.class,
    Class<?>[] clazz = ClassUtils.getAllInterfaces(DelegatedExecutionOsgiBundleApplicationContext.class);
    Class<?>[] expected =
            { ConfigurableOsgiBundleApplicationContext.class, ConfigurableApplicationContext.class,
                    ApplicationContext.class, Lifecycle.class, Closeable.class, EnvironmentCapable.class, ListableBeanFactory.class,
                    HierarchicalBeanFactory.class, MessageSource.class, ApplicationEventPublisher.class,
                    ResourcePatternResolver.class, BeanFactory.class, ResourceLoader.class, AutoCloseable.class };

    assertTrue(compareArrays(expected, clazz));
}

@Test
public void testReplicated() throws Exception {
    RedisRunner.RedisProcess master = new RedisRunner()
            .requirepass("do_not_use_if_it_is_not_set")
            .nosave()
            .randomDir()
            .run();
    RedisRunner.RedisProcess slave1 = new RedisRunner()
            .requirepass("do_not_use_if_it_is_not_set")
            .masterauth("do_not_use_if_it_is_not_set")
            .port(6380)
            .nosave()
            .randomDir()
            .slaveof("127.0.0.1", 6379)
            .run();
    RedisRunner.RedisProcess slave2 = new RedisRunner()
            .requirepass("do_not_use_if_it_is_not_set")
            .masterauth("do_not_use_if_it_is_not_set")
            .port(6381)
            .nosave()
            .randomDir()
            .slaveof("127.0.0.1", 6379)
            .run();
    try {
        ((ConfigurableApplicationContext)
                new ClassPathXmlApplicationContext("classpath:org/redisson/spring/support/namespace_wiki_replicated.xml"))
                .close();
    } finally {
        master.stop();
        slave1.stop();
        slave2.stop();
    }
}

@Test
public void testCluster() throws Exception {
    ClusterRunner clusterRunner = new ClusterRunner()
            .addNode(new RedisRunner()
                    .requirepass("do_not_use_if_it_is_not_set")
                    .port(6379)
                    .randomDir()
                    .nosave())
            .addNode(new RedisRunner()
                    .requirepass("do_not_use_if_it_is_not_set")
                    .port(6380)
                    .randomDir()
                    .nosave())
            .addNode(new RedisRunner()
                    .requirepass("do_not_use_if_it_is_not_set")
                    .port(6381)
                    .randomDir()
                    .nosave());
    ClusterRunner.ClusterProcesses cluster = clusterRunner.run();

    try {
        ((ConfigurableApplicationContext)
                new ClassPathXmlApplicationContext("classpath:org/redisson/spring/support/namespace_wiki_cluster.xml"))
                .close();
    } finally {
        cluster.shutdown();
    }
}

public synchronized static ConfigurableApplicationContext getApplicationContext(ServletContext servletContext, final String[] configLocations,
        final String[] classLocations) throws IOException
{
    final AbstractApplicationContext ctx = (AbstractApplicationContext)BaseApplicationContextHelper.getApplicationContext(configLocations, classLocations);
    DefaultListableBeanFactory dlbf = new DefaultListableBeanFactory(ctx.getBeanFactory());
    GenericWebApplicationContext gwac = new GenericWebApplicationContext(dlbf);
    CmisServiceFactory factory = (CmisServiceFactory)ctx.getBean("CMISServiceFactory");

    servletContext.setAttribute(GenericWebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, gwac);
       servletContext.setAttribute(CmisRepositoryContextListener.SERVICES_FACTORY, factory);
    gwac.setServletContext(servletContext);
    gwac.refresh();

    return gwac;
}

private ConfigurableApplicationContext getAppCtx(String symBundle) {
    ServiceReference ref = OsgiServiceReferenceUtils.getServiceReference(bundleContext, "("
            + ConfigurableOsgiBundleApplicationContext.APPLICATION_CONTEXT_SERVICE_PROPERTY_NAME + "=" + symBundle
            + ")");

    if (ref == null)
        throw new IllegalArgumentException("cannot find appCtx for bundle " + symBundle);
    return (ConfigurableApplicationContext) bundleContext.getService(ref);
}

public static void main(String[] args)
{
    ConfigurableApplicationContext context = new AnnotationConfigApplicationContext("hei2017.config");


    /*
    SprintService sprintService = context.getBean(SprintService.class);
    Sprint sprintTest = new Sprint();
    sprintTest.setNom("test sprint");
    sprintService.saveSprint(sprintTest);
     */
    context.close();
}

/**
 * Generate a JSON snapshot of current beans and their dependencies,
 * finding all active ApplicationContexts through {@link #findApplicationContexts()},
 * then delegating to {@link #generateJson(java.util.Set)}.
 */
@Override
public String getSnapshotAsJson() {
    Set<ConfigurableApplicationContext> contexts;
    if (this.applicationContext != null) {
        contexts = Collections.singleton(this.applicationContext);
    }
    else {
        contexts = findApplicationContexts();
    }
    return generateJson(contexts);
}

/**
 * {@inheritDoc}
 * 
 * <p/>This implementation will create an empty bundle context in case no
 * locations are specified.
 */
protected ConfigurableApplicationContext createApplicationContext(String[] locations) {

    ConfigurableOsgiBundleApplicationContext context = null;

    if (ObjectUtils.isEmpty(locations)) {
        context = new EmptyOsgiApplicationContext();
       } else {
        context = new OsgiBundleXmlApplicationContext(locations);
       }

    context.setBundleContext(bundleContext);
    context.refresh();
    return context;
}

@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
    String[] basePackages = StringUtils.tokenizeToStringArray(element.getAttribute(BASE_PACKAGE_ATTRIBUTE),
            ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

    // Actually scan for bean definitions and register them.
    ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
    Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
    registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

    return null;
}

/**
 * Loads this executor into the ApplicationContext, if it
 *  isn't already there
 */
public static void registerIfNeeded(ConfigurableApplicationContext ctx)
{
   if(!ctx.containsBean(ENGINE_NAME))
   {
      // Create, and do dependencies
      DummyHelloWorldRenditionEngine hw = new DummyHelloWorldRenditionEngine();
      hw.setRuntimeActionService(
            (RuntimeActionService)ctx.getBean("actionService")
      );
      hw.setNodeService(
            (NodeService)ctx.getBean("NodeService")
      );
      hw.setContentService(
            (ContentService)ctx.getBean("ContentService")
      );
      hw.setRenditionService(
            (RenditionService)ctx.getBean("RenditionService")
      );
      hw.setBehaviourFilter(
            (BehaviourFilter)ctx.getBean("policyBehaviourFilter")
      );
      hw.setRenditionLocationResolver(
            (RenditionLocationResolver)ctx.getBean("renditionLocationResolver")
      );

      // Register
      ctx.getBeanFactory().registerSingleton(
            ENGINE_NAME, hw
      );
      hw.init();
   }
}

/**
 * Overrides the default method to refresh the ApplicationContext, invoking
 * {@link ConfigurableApplicationContext#refresh ConfigurableApplicationContext.refresh()}.
 */
@Override
protected void initializeDefinition(BeanFactory groupDef) {
    if (groupDef instanceof ConfigurableApplicationContext) {
        ((ConfigurableApplicationContext) groupDef).refresh();
    }
}

public static void main(String[] args) throws InterruptedException {
    ConfigurableApplicationContext ctx = SpringApplication.run(SpringIntegrationApplication.class, args);
    TempConverter converter = ctx.getBean(TempConverter.class);

    for (int i = 0; i < 1000; i++) {
        System.out.println(converter.fahrenheitToCelcius(68.0f));
        Thread.sleep(10);
    }

    ctx.close();
}

private ConfigurableListableBeanFactory deduceBeanFactory(BeanDefinitionRegistry source) {
    if (source instanceof ConfigurableListableBeanFactory) {
        return (ConfigurableListableBeanFactory) source;
    }
    if (source instanceof ConfigurableApplicationContext) {
        return (((ConfigurableApplicationContext) source).getBeanFactory());
    }
    return null;
}

/**
 * Build a Spring ApplicationContext for the given JCA BootstrapContext.
 * <p>The default implementation builds a {@link ResourceAdapterApplicationContext}
 * and delegates to {@link #loadBeanDefinitions} for actually parsing the
 * specified configuration files.
 * @param bootstrapContext this ResourceAdapter's BootstrapContext
 * @return the Spring ApplicationContext instance
 */
protected ConfigurableApplicationContext createApplicationContext(BootstrapContext bootstrapContext) {
    ResourceAdapterApplicationContext applicationContext =
            new ResourceAdapterApplicationContext(bootstrapContext);
    // Set ResourceAdapter's ClassLoader as bean class loader.
    applicationContext.setClassLoader(getClass().getClassLoader());
    // Extract individual config locations.
    String[] configLocations =
            StringUtils.tokenizeToStringArray(getContextConfigLocation(), CONFIG_LOCATION_DELIMITERS);
    if (configLocations != null) {
        loadBeanDefinitions(applicationContext, configLocations);
    }
    applicationContext.refresh();
    return applicationContext;
}