java类org.springframework.beans.factory.config.ConfigurableBeanFactory的实例源码

@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
@Bean(name = "verifier-context", initMethod = "start", destroyMethod = "stop")
public static CamelContext verifierContext() {
    CamelContext context = new DefaultCamelContext();
    context.setNameStrategy(new ExplicitCamelContextNameStrategy("verifier-context"));
    context.disableJMX();

    return context;
}

@Bean("twitter")
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
@Lazy
@ConditionalOnProperty(prefix = "io.syndesis.connector.twitter.verifier", name = "enabled", matchIfMissing = true)
public Verifier twitterVerifier() {
    return new TwitterVerifier();
}

public SpringParameterProvider(ConfigurableBeanFactory beanFactory, HttpServletRequest request) {
    this.request = request;
    this.beanFactory = beanFactory;

    List<HttpMessageConverter<?>> messageConverters = getHttpMessageConverters();
    argumentResolvers = new HandlerMethodArgumentResolverComposite()
            .addResolvers(getArgumentResolvers(messageConverters));

}

@Bean
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@ConditionalOnBean(SqlSession.class)
@ConditionalOnMissingBean
public SqlMapper sqlMapper(SqlSession sqlSession) {
    return new SqlMapper(sqlSession);
}

private AccessControlContext getAcc() {
    AutowireCapableBeanFactory beanFactory = context.getAutowireCapableBeanFactory();
    if (beanFactory instanceof ConfigurableBeanFactory) {
        return ((ConfigurableBeanFactory) beanFactory).getAccessControlContext();
    }
    return null;
}

private void createEmbeddedBeanFactory() {
    synchronized (monitor) {
        DefaultListableBeanFactory bf = new DefaultListableBeanFactory(owningBeanFactory);
        if (owningBeanFactory instanceof ConfigurableBeanFactory) {
            bf.copyConfigurationFrom((ConfigurableBeanFactory) owningBeanFactory);
        }
        // just to be on the safe side
        bf.setBeanClassLoader(classLoader);
        // add autowiring processor
        bf.addBeanPostProcessor(new InitialInjectionProcessor());

        beanFactory = bf;
    }
}

public static AccessControlContext getAccFrom(BeanFactory beanFactory) {
    AccessControlContext acc = null;
    if (beanFactory != null) {
        if (beanFactory instanceof ConfigurableBeanFactory) {
            return ((ConfigurableBeanFactory) beanFactory).getAccessControlContext();
        }
    }
    return acc;
}

private void addBeanFactoryDependency() {
    if (beanFactory instanceof ConfigurableBeanFactory) {
        ConfigurableBeanFactory cbf = (ConfigurableBeanFactory) beanFactory;
        if (StringUtils.hasText(beanName) && cbf.containsBean(beanName)) {
            // no need to validate targetBeanName (already did)
            cbf.registerDependentBean(targetBeanName, BeanFactory.FACTORY_BEAN_PREFIX + beanName);
            cbf.registerDependentBean(targetBeanName, beanName);
        }
    } else {
        log.warn("The running bean factory cannot support dependencies between beans "
                + "- importer/exporter dependency cannot be enforced");
    }
}

protected void setUp() throws Exception {
    exporter = new OsgiServiceFactoryBean();
    beanFactoryControl = createControl();
    beanFactory = this.beanFactoryControl.createMock(ConfigurableBeanFactory.class);
    bundleContext = new MockBundleContext();
    ctxCtrl = createControl();
    ctx = ctxCtrl.createMock(BundleContext.class);

    exporter.setBeanFactory(beanFactory);
    exporter.setBundleContext(bundleContext);
}

private ConfigurableBeanFactory createMockBF(Object target) {
    ConfigurableBeanFactory cbf = createNiceMock(ConfigurableBeanFactory.class);

    expect(cbf.getBean(BEAN_NAME)).andReturn(target);
    expect(cbf.getType(BEAN_NAME)).andReturn((Class)target.getClass());

    replay(cbf);
    return cbf;
}