Java 类org.springframework.beans.factory.ListableBeanFactory 实例源码

private void setListableBeanFactory() {
    ListableBeanFactory beanFactory = new StaticWebApplicationContext() {

        @Override
        public String[] getBeanNamesForType(Class<?> type,
                boolean includeNonSingletons, boolean allowEagerInit) {
            if (type.isAssignableFrom(
                    ResourceServerTokenServicesConfiguration.class)) {
                return new String[] { "ResourceServerTokenServicesConfiguration" };
            }
            return new String[0];
        }

    };
    this.properties.setBeanFactory(beanFactory);
}

/**
 * @throws SQLException If Setup of emulation database failed, or if the
 *         application JDBC work fails.
 */
static public void main(String[] sa) throws SQLException {
    if (sa.length != 1) throw new IllegalArgumentException(SYNTAX_MSG);
    String authSpringFile = null;
    if (sa[0].equals("LDAP")) {
        authSpringFile = "ldapbeans.xml";
    } else if (sa[0].equals("JAAS")) {
        authSpringFile = "jaasbeans.xml";
    } else if (sa[0].equals("HsqldbSlave")) {
        authSpringFile = "slavebeans.xml";
    } else if (sa[0].equals("JAAS_LDAP")) {
        authSpringFile = "jaasldapbeans.xml";
    }
    if (authSpringFile == null)
        throw new IllegalArgumentException(SYNTAX_MSG);

    SpringExtAuth.prepMemoryDatabases(!sa[0].equals("HsqldbSlave"));
    ApplicationContext ctx =
        new ClassPathXmlApplicationContext("beandefs.xml", authSpringFile);
    ListableBeanFactory bf = (ListableBeanFactory) ctx;
    JdbcAppClass appBean = bf.getBean("appBean", JdbcAppClass.class);
    appBean.doJdbcWork();
}

public void testAppContextClassHierarchy() {
    Class<?>[] clazz =
            ClassUtils.getClassHierarchy(OsgiBundleXmlApplicationContext.class, ClassUtils.ClassSet.ALL_CLASSES);

       //Closeable.class,
    Class<?>[] expected =
            new Class<?>[] { OsgiBundleXmlApplicationContext.class,
                    AbstractDelegatedExecutionApplicationContext.class, AbstractOsgiBundleApplicationContext.class,
                    AbstractRefreshableApplicationContext.class, AbstractApplicationContext.class,
                    DefaultResourceLoader.class, ResourceLoader.class,
                    AutoCloseable.class,
                    DelegatedExecutionOsgiBundleApplicationContext.class,
                    ConfigurableOsgiBundleApplicationContext.class, ConfigurableApplicationContext.class,
                    ApplicationContext.class, Lifecycle.class, Closeable.class, EnvironmentCapable.class, ListableBeanFactory.class,
                    HierarchicalBeanFactory.class, ApplicationEventPublisher.class, ResourcePatternResolver.class,
                    MessageSource.class, BeanFactory.class, DisposableBean.class };

    assertTrue(compareArrays(expected, clazz));
}

protected Scheduler findScheduler(String schedulerName) throws SchedulerException {
    if (this.beanFactory instanceof ListableBeanFactory) {
        ListableBeanFactory lbf = (ListableBeanFactory) this.beanFactory;
        String[] beanNames = lbf.getBeanNamesForType(Scheduler.class);
        for (String beanName : beanNames) {
            Scheduler schedulerBean = (Scheduler) lbf.getBean(beanName);
            if (schedulerName.equals(schedulerBean.getSchedulerName())) {
                return schedulerBean;
            }
        }
    }
    Scheduler schedulerInRepo = SchedulerRepository.getInstance().lookup(schedulerName);
    if (schedulerInRepo == null) {
        throw new IllegalStateException("No Scheduler named '" + schedulerName + "' found");
    }
    return schedulerInRepo;
}

/**
 * Find an EntityManagerFactory with the given name in the given
 * Spring application context (represented as ListableBeanFactory).
 * <p>The specified unit name will be matched against the configured
 * persistence unit, provided that a discovered EntityManagerFactory
 * implements the {@link EntityManagerFactoryInfo} interface. If not,
 * the persistence unit name will be matched against the Spring bean name,
 * assuming that the EntityManagerFactory bean names follow that convention.
 * <p>If no unit name has been given, this method will search for a default
 * EntityManagerFactory through {@link ListableBeanFactory#getBean(Class)}.
 * @param beanFactory the ListableBeanFactory to search
 * @param unitName the name of the persistence unit (may be {@code null} or empty,
 * in which case a single bean of type EntityManagerFactory will be searched for)
 * @return the EntityManagerFactory
 * @throws NoSuchBeanDefinitionException if there is no such EntityManagerFactory in the context
 * @see EntityManagerFactoryInfo#getPersistenceUnitName()
 */
public static EntityManagerFactory findEntityManagerFactory(
        ListableBeanFactory beanFactory, String unitName) throws NoSuchBeanDefinitionException {

    Assert.notNull(beanFactory, "ListableBeanFactory must not be null");
    if (StringUtils.hasLength(unitName)) {
        // See whether we can find an EntityManagerFactory with matching persistence unit name.
        String[] candidateNames =
                BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, EntityManagerFactory.class);
        for (String candidateName : candidateNames) {
            EntityManagerFactory emf = (EntityManagerFactory) beanFactory.getBean(candidateName);
            if (emf instanceof EntityManagerFactoryInfo) {
                if (unitName.equals(((EntityManagerFactoryInfo) emf).getPersistenceUnitName())) {
                    return emf;
                }
            }
        }
        // No matching persistence unit found - simply take the EntityManagerFactory
        // with the persistence unit name as bean name (by convention).
        return beanFactory.getBean(unitName, EntityManagerFactory.class);
    }
    else {
        // Find unique EntityManagerFactory bean in the context, falling back to parent contexts.
        return beanFactory.getBean(EntityManagerFactory.class);
    }
}

/**
 * @throws SQLException If Setup of emulation database failed, or if the
 *         application JDBC work fails.
 */
static public void main(String[] sa) throws SQLException {
    if (sa.length != 1) throw new IllegalArgumentException(SYNTAX_MSG);
    String authSpringFile = null;
    if (sa[0].equals("LDAP")) {
        authSpringFile = "ldapbeans.xml";
    } else if (sa[0].equals("JAAS")) {
        authSpringFile = "jaasbeans.xml";
    } else if (sa[0].equals("HsqldbSlave")) {
        authSpringFile = "slavebeans.xml";
    } else if (sa[0].equals("JAAS_LDAP")) {
        authSpringFile = "jaasldapbeans.xml";
    }
    if (authSpringFile == null)
        throw new IllegalArgumentException(SYNTAX_MSG);

    SpringExtAuth.prepMemoryDatabases(!sa[0].equals("HsqldbSlave"));
    ApplicationContext ctx =
        new ClassPathXmlApplicationContext("beandefs.xml", authSpringFile);
    ListableBeanFactory bf = (ListableBeanFactory) ctx;
    JdbcAppClass appBean = bf.getBean("appBean", JdbcAppClass.class);
    appBean.doJdbcWork();
}

/**
 * Get the {@link DataSource} type bean name which corresponds to given data context id
 * @param registry Bean registry
 * @param beanFactory Bean factory
 * @param dataContextId Optional data context id
 * @return The DataSource bean name, or <code>null</code> if not found
 */
private static String getDataSourceBeanName(BeanDefinitionRegistry registry, BeanFactory beanFactory,
        String dataContextId) {
    // check unique DataSource if no data context id specified
    if (dataContextId == null && beanFactory instanceof ListableBeanFactory) {
        String[] dataSourceBeanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                (ListableBeanFactory) beanFactory, DataSource.class, false, false);
        if (dataSourceBeanNames != null && dataSourceBeanNames.length == 1) {
            return dataSourceBeanNames[0];
        }
    }
    // check bean name using data context id
    String dsBeanName = BeanRegistryUtils.buildBeanName(dataContextId,
            EnableDataSource.DEFAULT_DATASOURCE_BEAN_NAME);
    if (registry.containsBeanDefinition(dsBeanName) && beanFactory.isTypeMatch(dsBeanName, DataSource.class)) {
        return dsBeanName;
    }
    return null;
}

/**
 * Checks if a bean of given type and bound to given data context id is already registered
 * @param beanFactory Bean factory
 * @param registry Bean registry
 * @param type Bean type to check
 * @param dataContextId Data context id
 * @param defaultBeanName Default bean name to check
 * @return The registered bean name if found, <code>null</code> otherwise
 */
private static String isBeanRegistered(ListableBeanFactory beanFactory, BeanDefinitionRegistry registry,
        Class<?> type, String dataContextId, String defaultBeanName) {
    String[] beanNames = beanFactory.getBeanNamesForType(type);
    if (beanNames != null && beanNames.length > 0) {
        for (String beanName : beanNames) {
            BeanDefinition bd = registry.getBeanDefinition(beanName);
            if (bd instanceof DataContextBoundBeanDefinition) {
                String did = ((DataContextBoundBeanDefinition) bd).getDataContextId().orElse(null);
                if ((dataContextId == null && did == null)
                        || (dataContextId != null && dataContextId.equals(did))) {
                    return beanName;
                }
            } else {
                if (dataContextId == null) {
                    return beanName;
                }
            }
        }
    }
    if (defaultBeanName != null && registry.containsBeanDefinition(defaultBeanName)) {
        return defaultBeanName;
    }
    return null;
}

@Override
public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
    // Register JPA Datastore (transactional)
    if (beanFactory instanceof ListableBeanFactory) {
        String[] emfBeanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                (ListableBeanFactory) beanFactory, EntityManagerFactory.class, true, false);
        if (emfBeanNames == null || emfBeanNames.length == 0) {
            emfBeanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors((ListableBeanFactory) beanFactory,
                    AbstractEntityManagerFactoryBean.class, true, false);
        }
        if (emfBeanNames != null && emfBeanNames.length == 1) {
            String emfBeanName = (emfBeanNames[0].startsWith("&")) ? emfBeanNames[0].substring(1) : emfBeanNames[0];
            JpaDatastoreRegistrar.registerDatastore(registry, null, PrimaryMode.AUTO, emfBeanName, true, false,
                    beanClassLoader);
        }
    }
}

public void addParameter(Object askFor, Object valueParam)
throws InstantiationException, IllegalAccessException {
    try {
        Class clz = ClassUtils.forName((String)askFor);
        if (log.isDebugEnabled()) {
            log.debug("trying to resolve the following class from the Spring bean container: " + clz.getName());
        }

        Map beansOfType = ((ListableBeanFactory)beanFactory).getBeansOfType(clz);
        if (log.isDebugEnabled()) {
            log.debug("beans: " + beansOfType + " - " + beansOfType.size());
        }
        if (beansOfType.size() == 0) {
            log.debug("adding parameter the normal way");
            super.addParameter(askFor, valueParam);
        } else if (beansOfType.size() > 1) {
            // TODO: handle multiple declarations
            throw new InstantiationException("multiple beans of type '" + clz.getName() + "' were found in the spring configuration");
        } else {
            this.beans.put(askFor, beansOfType.values().iterator().next());
        }
    } catch (ClassNotFoundException e) {
        super.addParameter(askFor, valueParam);
    }
}

public Collection getBeanNames()
{
    List names = new ArrayList();

    // Snarf the beans from Spring
    if (beanFactory instanceof ListableBeanFactory)
    {
        ListableBeanFactory listable = (ListableBeanFactory) beanFactory;
        names.addAll(Arrays.asList(listable.getBeanDefinitionNames()));
    }
    else
    {
        log.warn("List of beanNames does not include Spring beans since your BeanFactory is not a ListableBeanFactory.");
    }

    // And append the DWR ones
    names.addAll(super.getBeanNames());

    return Collections.unmodifiableCollection(names);
}

/**
 * Register {@link DatastoreResolver}s bean into given <code>datastore</code>.
 * @param datastore Datastore
 * @param datastoreBeanName Datastore bean name
 * @param factory BeanFactory
 */
public static void configureDatastore(Datastore datastore, String datastoreBeanName, BeanFactory factory) {
    ObjectUtils.argumentNotNull(datastore, "Null Datastore");
    ObjectUtils.argumentNotNull(datastoreBeanName, "Null Datastore bean name");
    ObjectUtils.argumentNotNull(factory, "Null BeanFactory");

    if (factory instanceof ListableBeanFactory) {
        configureDatastoreResolvers(datastore, datastoreBeanName, (ListableBeanFactory) factory);
        configureDatastoreCommodityFactories(datastore, datastoreBeanName, (ListableBeanFactory) factory);
        configureDatastorePostProcessors(datastore, datastoreBeanName, (ListableBeanFactory) factory);
    } else {
        LOGGER.warn(
                "The BeanFactory [" + factory + "] is not a ListableBeanFactory: skipping Datastore configuration");
    }

}

/**
 * Register {@link DatastoreResolver} annotated beans as <code>datastore</code> {@link ExpressionResolver}s.
 * @param datastore Datastore to configure
 * @param datastoreBeanName Datastore bean name to configure
 * @param beanFactory Bean factory
 */
private static void configureDatastoreResolvers(Datastore datastore, String datastoreBeanName,
        ListableBeanFactory beanFactory) {
    final String[] beanNames = beanFactory.getBeanNamesForAnnotation(DatastoreResolver.class);
    if (beanNames != null && beanNames.length > 0) {
        for (String beanName : beanNames) {
            if (!ExpressionResolver.class.isAssignableFrom(beanFactory.getType(beanName))) {
                throw new BeanNotOfRequiredTypeException(beanName, ExpressionResolver.class,
                        beanFactory.getType(beanName));
            }
            DatastoreResolver dr = beanFactory.findAnnotationOnBean(beanName, DatastoreResolver.class);
            String datastoreRef = AnnotationUtils.getStringValue(dr.datastoreBeanName());
            if (datastoreRef == null || datastoreRef.equals(datastoreBeanName)) {
                // register resolver
                ExpressionResolver<?, ?> resolver = (ExpressionResolver<?, ?>) beanFactory.getBean(beanName);
                datastore.addExpressionResolver(resolver);
                LOGGER.debug(() -> "Registered expression resolver [" + resolver.getClass().getName()
                        + "] into Datastore with bean name [" + datastoreBeanName + "]");
            }
        }
    }
}

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

    if (beanFactory instanceof ListableBeanFactory) {

        String[] dataSourceBeanNames = ((ListableBeanFactory) beanFactory).getBeanNamesForType(DataSource.class,
                false, true);
        if (dataSourceBeanNames != null) {
            for (String dataSourceBeanName : dataSourceBeanNames) {
                BeanDefinition bd = registry.getBeanDefinition(dataSourceBeanName);
                if (bd instanceof DataContextBoundBeanDefinition) {
                    DataSourceRegistrar.registerDataSourceTransactionManager(registry, dataSourceBeanName,
                            ((DataContextBoundBeanDefinition) bd).getDataContextId().orElse(null),
                            PrimaryMode.AUTO);
                }
            }
        }

    }

}

@Override
public void afterPropertiesSet() throws Exception {
    if (beanFactory instanceof ListableBeanFactory) {
        Map<String, HandlerMethodArgumentResolver> instances =
                ((ListableBeanFactory) this.beanFactory).getBeansOfType(HandlerMethodArgumentResolver.class);
        if (null != instances && instances.size() > 0) {
            handlerMethodArgumentResolvers.addAll(instances.values());
        }
    }

    if (null == messageHandlerMethodFactory) {
        messageHandlerMethodFactory = createDefaultJmsHandlerMethodFactory();
    }

    if (endpointRegistry instanceof JmsListenerEndpointRegistryAdapter) {
        JmsListenerEndpointRegistryAdapter methodEndpointRegistry =
                (JmsListenerEndpointRegistryAdapter) endpointRegistry;
        methodEndpointRegistry.setMessageHandlerMethodFactory(messageHandlerMethodFactory);
    }
}

/**
 * 初始化Fetcher容器
 *
 * @param factory
 */
public static void initFetcherContainer(ListableBeanFactory factory) {
    if (initing.get()) {
        waitInit();
        return;
    }
    if (initing.compareAndSet(false, true)) {
        Map<String, Object> fetcherServices = factory.getBeansWithAnnotation(TaskService.class);
        for (Object service : fetcherServices.values()) {
            regiserOneService(service);
        }
        hasInit.countDown();
    } else {
        waitInit();
    }
}

@PostConstruct
public void customizedSupportedMediaTypes() {
    if (this.beanFactory instanceof ListableBeanFactory) {
        Map<String, RequestMappingHandlerAdapter> handlerAdapters = ((ListableBeanFactory) this.beanFactory)
                .getBeansOfType(RequestMappingHandlerAdapter.class);
        for (Entry<String, RequestMappingHandlerAdapter> entry : handlerAdapters
                .entrySet()) {
            RequestMappingHandlerAdapter handlerAdapter = entry.getValue();
            for (HttpMessageConverter<?> converter : handlerAdapter
                    .getMessageConverters()) {
                if (converter instanceof TypeConstrainedMappingJackson2HttpMessageConverter) {
                    ((TypeConstrainedMappingJackson2HttpMessageConverter) converter)
                            .setSupportedMediaTypes(
                                    Arrays.asList(MediaTypes.HAL_JSON,
                                            MediaType.APPLICATION_JSON));
                }
            }

        }
    }
}

/**
 * Find an EntityManagerFactory with the given name in the given
 * Spring application context (represented as ListableBeanFactory).
 * <p>The specified unit name will be matched against the configured
 * persistence unit, provided that a discovered EntityManagerFactory
 * implements the {@link EntityManagerFactoryInfo} interface. If not,
 * the persistence unit name will be matched against the Spring bean name,
 * assuming that the EntityManagerFactory bean names follow that convention.
 * <p>If no unit name has been given, this method will search for a default
 * EntityManagerFactory through {@link ListableBeanFactory#getBean(Class)}.
 * @param beanFactory the ListableBeanFactory to search
 * @param unitName the name of the persistence unit (may be {@code null} or empty,
 * in which case a single bean of type EntityManagerFactory will be searched for)
 * @return the EntityManagerFactory
 * @throws NoSuchBeanDefinitionException if there is no such EntityManagerFactory in the context
 * @see EntityManagerFactoryInfo#getPersistenceUnitName()
 */
public static EntityManagerFactory findEntityManagerFactory(
        ListableBeanFactory beanFactory, String unitName) throws NoSuchBeanDefinitionException {

    Assert.notNull(beanFactory, "ListableBeanFactory must not be null");
    if (StringUtils.hasLength(unitName)) {
        // See whether we can find an EntityManagerFactory with matching persistence unit name.
        String[] candidateNames =
                BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, EntityManagerFactory.class);
        for (String candidateName : candidateNames) {
            EntityManagerFactory emf = (EntityManagerFactory) beanFactory.getBean(candidateName);
            if (emf instanceof EntityManagerFactoryInfo) {
                if (unitName.equals(((EntityManagerFactoryInfo) emf).getPersistenceUnitName())) {
                    return emf;
                }
            }
        }
        // No matching persistence unit found - simply take the EntityManagerFactory
        // with the persistence unit name as bean name (by convention).
        return beanFactory.getBean(unitName, EntityManagerFactory.class);
    }
    else {
        // Find unique EntityManagerFactory bean in the context, falling back to parent contexts.
        return beanFactory.getBean(EntityManagerFactory.class);
    }
}

protected Scheduler findScheduler(String schedulerName) throws SchedulerException {
    if (this.beanFactory instanceof ListableBeanFactory) {
        ListableBeanFactory lbf = (ListableBeanFactory) this.beanFactory;
        String[] beanNames = lbf.getBeanNamesForType(Scheduler.class);
        for (String beanName : beanNames) {
            Scheduler schedulerBean = (Scheduler) lbf.getBean(beanName);
            if (schedulerName.equals(schedulerBean.getSchedulerName())) {
                return schedulerBean;
            }
        }
    }
    Scheduler schedulerInRepo = SchedulerRepository.getInstance().lookup(schedulerName);
    if (schedulerInRepo == null) {
        throw new IllegalStateException("No Scheduler named '" + schedulerName + "' found");
    }
    return schedulerInRepo;
}

@Bean
public MetricManager metricManager() {

    String[] beanNames = ((ListableBeanFactory) beanFactory)
            .getBeanNamesForType(Metric.class);

    if (beanNames == null) {
        throw new RuntimeException(
                "At least 1 Metric bean must be specified");
    }

    Metric[] metrics = new Metric[beanNames.length];
    int i = 0;
    for (String metricName : beanNames) {
        metrics[i++] = beanFactory.getBean(metricName, Metric.class);
    }

    return new SimpleMetricManager(metrics);
}

private void addServletContextInitializerBean(Class<?> type, String beanName,
        ServletContextInitializer initializer, ListableBeanFactory beanFactory,
        Object source) {
    this.initializers.add(type, initializer);
    if (source != null) {
        // Mark the underlying source as seen in case it wraps an existing bean
        this.seen.add(source);
    }
    if (ServletContextInitializerBeans.logger.isDebugEnabled()) {
        String resourceDescription = getResourceDescription(beanName, beanFactory);
        int order = getOrder(initializer);
        ServletContextInitializerBeans.logger.debug("Added existing "
                + type.getSimpleName() + " initializer bean '" + beanName
                + "'; order=" + order + ", resource=" + resourceDescription);
    }
}

private <T, B extends T> void addAsRegistrationBean(ListableBeanFactory beanFactory,
        Class<T> type, Class<B> beanType, RegistrationBeanAdapter<T> adapter) {
    List<Map.Entry<String, B>> beans = getOrderedBeansOfType(beanFactory, beanType,
            this.seen);
    for (Entry<String, B> bean : beans) {
        if (this.seen.add(bean.getValue())) {
            int order = getOrder(bean.getValue());
            String beanName = bean.getKey();
            // One that we haven't already seen
            RegistrationBean registration = adapter.createRegistrationBean(beanName,
                    bean.getValue(), beans.size());
            registration.setName(beanName);
            registration.setOrder(order);
            this.initializers.add(type, registration);
            if (ServletContextInitializerBeans.logger.isDebugEnabled()) {
                ServletContextInitializerBeans.logger.debug(
                        "Created " + type.getSimpleName() + " initializer for bean '"
                                + beanName + "'; order=" + order + ", resource="
                                + getResourceDescription(beanName, beanFactory));
            }
        }
    }
}

@PostConstruct
public void customizedSupportedMediaTypes() {
    if (this.beanFactory instanceof ListableBeanFactory) {
        Map<String, RequestMappingHandlerAdapter> handlerAdapters = ((ListableBeanFactory) this.beanFactory)
                .getBeansOfType(RequestMappingHandlerAdapter.class);
        for (Entry<String, RequestMappingHandlerAdapter> entry : handlerAdapters
                .entrySet()) {
            RequestMappingHandlerAdapter handlerAdapter = entry.getValue();
            for (HttpMessageConverter<?> converter : handlerAdapter
                    .getMessageConverters()) {
                if (converter instanceof TypeConstrainedMappingJackson2HttpMessageConverter) {
                    ((TypeConstrainedMappingJackson2HttpMessageConverter) converter)
                            .setSupportedMediaTypes(
                                    Arrays.asList(MediaTypes.HAL_JSON,
                                            MediaType.APPLICATION_JSON));
                }
            }

        }
    }
}

private <T, B extends T> void addAsRegistrationBean(ListableBeanFactory beanFactory,
        Class<T> type, Class<B> beanType, RegistrationBeanAdapter<T> adapter) {
    List<Map.Entry<String, B>> beans = getOrderedBeansOfType(beanFactory, beanType,
            this.seen);
    for (Entry<String, B> bean : beans) {
        if (this.seen.add(bean.getValue())) {
            int order = getOrder(bean.getValue());
            String beanName = bean.getKey();
            // One that we haven't already seen
            RegistrationBean registration = adapter.createRegistrationBean(beanName,
                    bean.getValue(), beans.size());
            registration.setName(beanName);
            registration.setOrder(order);
            this.initializers.add(type, registration);
            if (ServletContextInitializerBeans.logger.isDebugEnabled()) {
                ServletContextInitializerBeans.logger.debug(
                        "Created " + type.getSimpleName() + " initializer for bean '"
                                + beanName + "'; order=" + order + ", resource="
                                + getResourceDescription(beanName, beanFactory));
            }
        }
    }
}

private void addServletContextInitializerBean(Class<?> type, String beanName,
        ServletContextInitializer initializer, ListableBeanFactory beanFactory,
        Object source) {
    this.initializers.add(type, initializer);
    if (source != null) {
        // Mark the underlying source as seen in case it wraps an existing bean
        this.seen.add(source);
    }
    if (ServletContextInitializerBeans.logger.isDebugEnabled()) {
        String resourceDescription = getResourceDescription(beanName, beanFactory);
        int order = getOrder(initializer);
        ServletContextInitializerBeans.logger.debug("Added existing "
                + type.getSimpleName() + " initializer bean '" + beanName
                + "'; order=" + order + ", resource=" + resourceDescription);
    }
}

private Map<String, JobFactory> loadFactories(ListableBeanFactory beanFactory) {
    ImmutableMap.Builder<String, JobFactory> mb = ImmutableMap.builder();
    //load factory beans
    String[] factoryNames = beanFactory.getBeanNamesForType(JobFactory.class);
    for(String factoryName: factoryNames) {
        JobFactory factory = beanFactory.getBean(factoryName, JobFactory.class);
        if(factory == this) {
            // we do not want to load self
            continue;
        }
        Set<String> types = factory.getTypes();
        for(String type: types) {
            mb.put(type, factory);
        }
    }
    //load job beans
    String[] jobNames = beanFactory.getBeanNamesForAnnotation(JobBean.class);
    for(String jobName: jobNames) {
        Class<?> jobType = beanFactory.getType(jobName);
        JobDescription jd = descFactory.getFor(jobName);
        mb.put(jobName, new JobFactoryForBean(this, jobName, jobType, jd));
    }
    return mb.build();
}

/**
 * Returns a bean of specified type in the specified bean factory or its
 * ancestors. In contrast with Spring's BeanFactoryUtils, doesn't throw an
 * exception if no bean is found, but rather returns null.
 * 
 * @param lbf
 *            the bean factory to look for the bean
 * @param type
 *            the expected type of the bean
 * @return the bean - if exactly one is defined. null - if none is defined
 * @throws NoSuchBeanDefinitionException
 *             if more than one bean is defined
 */
public static <T> T beanOfTypeIncludingAncestors(final ListableBeanFactory lbf, final Class<T> type) {
    final Map<String, T> map = org.springframework.beans.factory.BeanFactoryUtils.beansOfTypeIncludingAncestors(lbf,
            type);
    switch (map.size()) {
    case 0:
        return null;
    case 1:
        return map.values().iterator().next();
    default:
        throw new NoSuchBeanDefinitionException(
                "More than one bean of type " + type.getName() + " found: " + map.keySet());
    }
}

public void setBeanFactory(BeanFactory beanFactory) throws BeansException
{
    ListableBeanFactory listableBeanFactory = (ListableBeanFactory)beanFactory;

    // Find bean implementaing SupportsBackgroundIndexing and register
    for(Object bgindexable : listableBeanFactory.getBeansOfType(SupportsBackgroundIndexing.class).values())
    {
        if(bgindexable instanceof SupportsBackgroundIndexing)
        {
            ((SupportsBackgroundIndexing)bgindexable).setFullTextSearchIndexer(this);
        }
    }

}

@Override
public void refresh()
{
   super.refresh();
   if (springContext != null)
   {
      Map<String, IExtensionPoint> extensionPointMap = new TreeMap<>();
      extensionPointMap.putAll(springContext.getBeansOfType(IExtensionPoint.class));
      if (springContext.getParentBeanFactory() != null &&
             springContext.getParentBeanFactory() instanceof ListableBeanFactory)
      {
         extensionPointMap.putAll(((ListableBeanFactory) springContext.getParentBeanFactory())
               .getBeansOfType(IExtensionPoint.class));
      }

      log.info("Found {} extension points from spring that will be registered",
            extensionPointMap.size());
      for (String name: extensionPointMap.keySet())
      {
         registerExtension(name, extensionPointMap.get(name), true);
      }

      // Adding our extension to dynamically add product
      // in solr when a modification is synchronized by symmetricDS
      IExtensionPoint extension = (IExtensionPoint) ApplicationContextProvider.getBean(
            SolrReplicationExtensionPoint.class);
      registerExtension("symds", extension, true);
   }
}

private Collection<String> getBeanNamesForType(ListableBeanFactory beanFactory, String type,
                                               ClassLoader classLoader, boolean considerHierarchy) throws LinkageError {
    try {
        Set<String> result = new LinkedHashSet<>();
        collectBeanNamesForType(result, beanFactory,
                ClassUtils.forName(type, classLoader), considerHierarchy);
        return result;
    } catch (ClassNotFoundException | NoClassDefFoundError ex) {
        return Collections.emptySet();
    }
}

private void collectBeanNamesForType(Set<String> result, ListableBeanFactory beanFactory, Class<?> type,
                                     boolean considerHierarchy) {
    result.addAll(BeanTypeRegistry.get(beanFactory).getNamesForType(type));
    if (considerHierarchy && beanFactory instanceof HierarchicalBeanFactory) {
        BeanFactory parent = ((HierarchicalBeanFactory) beanFactory).getParentBeanFactory();
        if (parent instanceof ListableBeanFactory) {
            collectBeanNamesForType(result, (ListableBeanFactory) parent, type, considerHierarchy);
        }
    }
}

private void collectBeanNamesForAnnotation(Set<String> names, ListableBeanFactory beanFactory,
                                           Class<? extends Annotation> annotationType, boolean considerHierarchy) {
    names.addAll(BeanTypeRegistry.get(beanFactory).getNamesForAnnotation(annotationType));
    if (considerHierarchy) {
        BeanFactory parent = ((HierarchicalBeanFactory) beanFactory).getParentBeanFactory();
        if (parent instanceof ListableBeanFactory) {
            collectBeanNamesForAnnotation(names, (ListableBeanFactory) parent, annotationType, considerHierarchy);
        }
    }
}

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

/**
 * This callback is only required for resolution of bean names in the
 * {@link #setBeans(java.util.Map) "beans"} {@link Map} and for
 * autodetection of MBeans (in the latter case, a
 * {@code ListableBeanFactory} is required).
 * @see #setBeans
 * @see #setAutodetect
 */
@Override
public void setBeanFactory(BeanFactory beanFactory) {
    if (beanFactory instanceof ListableBeanFactory) {
        this.beanFactory = (ListableBeanFactory) beanFactory;
    }
    else {
        logger.info("MBeanExporter not running in a ListableBeanFactory: autodetection of MBeans not available.");
    }
}

/**
 * Obtains all web service beans and publishes them as JAX-WS endpoints.
 */
@Override
public void setBeanFactory(BeanFactory beanFactory) {
    if (!(beanFactory instanceof ListableBeanFactory)) {
        throw new IllegalStateException(getClass().getSimpleName() + " requires a ListableBeanFactory");
    }
    this.beanFactory = (ListableBeanFactory) beanFactory;
}

/**
 * Create a new PersistenceExceptionTranslationAdvisor.
 * @param beanFactory the ListableBeanFactory to obtaining all
 * PersistenceExceptionTranslators from
 * @param repositoryAnnotationType the annotation type to check for
 */
PersistenceExceptionTranslationAdvisor(
        ListableBeanFactory beanFactory, Class<? extends Annotation> repositoryAnnotationType) {

    this.advice = new PersistenceExceptionTranslationInterceptor(beanFactory);
    this.pointcut = new AnnotationMatchingPointcut(repositoryAnnotationType, true);
}

@Override
public void setBeanFactory(BeanFactory beanFactory) {
    if (!(beanFactory instanceof ListableBeanFactory)) {
        throw new IllegalArgumentException(
                "Cannot use PersistenceExceptionTranslator autodetection without ListableBeanFactory");
    }
    this.advisor = new PersistenceExceptionTranslationAdvisor(
            (ListableBeanFactory) beanFactory, this.repositoryAnnotationType);
}

@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    if (this.persistenceExceptionTranslator == null) {
        // No explicit exception translator specified - perform autodetection.
        if (!(beanFactory instanceof ListableBeanFactory)) {
            throw new IllegalArgumentException(
                    "Cannot use PersistenceExceptionTranslator autodetection without ListableBeanFactory");
        }
        this.beanFactory = (ListableBeanFactory) beanFactory;
    }
}

/**
 * Detect all PersistenceExceptionTranslators in the given BeanFactory.
 * @param beanFactory the ListableBeanFactory to obtaining all
 * PersistenceExceptionTranslators from
 * @return a chained PersistenceExceptionTranslator, combining all
 * PersistenceExceptionTranslators found in the factory
 * @see ChainedPersistenceExceptionTranslator
 */
protected PersistenceExceptionTranslator detectPersistenceExceptionTranslators(ListableBeanFactory beanFactory) {
    // Find all translators, being careful not to activate FactoryBeans.
    Map<String, PersistenceExceptionTranslator> pets = BeanFactoryUtils.beansOfTypeIncludingAncestors(
            beanFactory, PersistenceExceptionTranslator.class, false, false);
    ChainedPersistenceExceptionTranslator cpet = new ChainedPersistenceExceptionTranslator();
    for (PersistenceExceptionTranslator pet : pets.values()) {
        cpet.addDelegate(pet);
    }
    return cpet;
}

@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    if (!(beanFactory instanceof ListableBeanFactory)) {
        throw new FatalBeanException(
                "ServiceLocatorFactoryBean needs to run in a BeanFactory that is a ListableBeanFactory");
    }
    this.beanFactory = (ListableBeanFactory) beanFactory;
}