Java DefaultListableBeanFactory.getBeansOfType方法代码示例

import org.springframework.beans.factory.support.DefaultListableBeanFactory; //导入方法依赖的package包/类
@Test
public void testAbstractParentBeans() {
	DefaultListableBeanFactory parent = new DefaultListableBeanFactory();
	new XmlBeanDefinitionReader(parent).loadBeanDefinitions(PARENT_CONTEXT);
	parent.preInstantiateSingletons();
	assertTrue(parent.isSingleton("inheritedTestBeanWithoutClass"));

	// abstract beans should not match
	Map<?, ?> tbs = parent.getBeansOfType(TestBean.class);
	assertEquals(2, tbs.size());
	assertTrue(tbs.containsKey("inheritedTestBeanPrototype"));
	assertTrue(tbs.containsKey("inheritedTestBeanSingleton"));

	// abstract bean should throw exception on creation attempt
	try {
		parent.getBean("inheritedTestBeanWithoutClass");
		fail("Should have thrown BeanIsAbstractException");
	}
	catch (BeanIsAbstractException ex) {
		// expected
	}

	// non-abstract bean should work, even if it serves as parent
	assertTrue(parent.getBean("inheritedTestBeanPrototype") instanceof TestBean);
}
 

import org.springframework.beans.factory.support.DefaultListableBeanFactory; //导入方法依赖的package包/类
public <T> T getBean(BeanFactory beanFactory, Class<T> requiredType) throws BeansException {
	DefaultListableBeanFactory factory = (DefaultListableBeanFactory) beanFactory;
	Map<String, T> matchingBeans = factory.getBeansOfType(requiredType);
	if (matchingBeans.isEmpty()) {
		throw new NoSuchBeanDefinitionException(requiredType);
	}
	if (matchingBeans.size() == 1) {
		return matchingBeans.entrySet().iterator().next().getValue();
	}
	for (Entry<String, T> entry : matchingBeans.entrySet()) {
		T bean = entry.getValue();
		// TODO 还没有支持Bean有AOP
		Primary primary = bean.getClass().getDeclaredAnnotation(Primary.class);
		if (primary != null) {
			return bean;
		}
	}
	throw new NoUniqueBeanDefinitionException(requiredType, matchingBeans.keySet());
}
 

import org.springframework.beans.factory.support.DefaultListableBeanFactory; //导入方法依赖的package包/类
private static PropertySourcesPlaceholderConfigurer getSinglePropertySourcesPlaceholderConfigurer(DefaultListableBeanFactory beanFactory) {
    Map<String, PropertySourcesPlaceholderConfigurer> beans = beanFactory.getBeansOfType(PropertySourcesPlaceholderConfigurer.class, false, false);
    if (beans.size() == 1) {
        return beans.values().iterator().next();
    }
    return null;
}
 

import org.springframework.beans.factory.support.DefaultListableBeanFactory; //导入方法依赖的package包/类
/**
 * Create a new instance of the {@link SQLErrorCodesFactory} class.
 * <p>Not public to enforce Singleton design pattern. Would be private
 * except to allow testing via overriding the
 * {@link #loadResource(String)} method.
 * <p><b>Do not subclass in application code.</b>
 * @see #loadResource(String)
 */
protected SQLErrorCodesFactory() {
	Map<String, SQLErrorCodes> errorCodes;

	try {
		DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
		lbf.setBeanClassLoader(getClass().getClassLoader());
		XmlBeanDefinitionReader bdr = new XmlBeanDefinitionReader(lbf);

		// Load default SQL error codes.
		Resource resource = loadResource(SQL_ERROR_CODE_DEFAULT_PATH);
		if (resource != null && resource.exists()) {
			bdr.loadBeanDefinitions(resource);
		}
		else {
			logger.warn("Default sql-error-codes.xml not found (should be included in spring.jar)");
		}

		// Load custom SQL error codes, overriding defaults.
		resource = loadResource(SQL_ERROR_CODE_OVERRIDE_PATH);
		if (resource != null && resource.exists()) {
			bdr.loadBeanDefinitions(resource);
			logger.info("Found custom sql-error-codes.xml file at the root of the classpath");
		}

		// Check all beans of type SQLErrorCodes.
		errorCodes = lbf.getBeansOfType(SQLErrorCodes.class, true, false);
		if (logger.isInfoEnabled()) {
			logger.info("SQLErrorCodes loaded: " + errorCodes.keySet());
		}
	}
	catch (BeansException ex) {
		logger.warn("Error loading SQL error codes from config file", ex);
		errorCodes = Collections.emptyMap();
	}

	this.errorCodesMap = errorCodes;
}
 

import org.springframework.beans.factory.support.DefaultListableBeanFactory; //导入方法依赖的package包/类
@Test
public void testRegisterExistingSingletonWithReference() {
	DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
	Properties p = new Properties();
	p.setProperty("test.(class)", TestBean.class.getName());
	p.setProperty("test.name", "Tony");
	p.setProperty("test.age", "48");
	p.setProperty("test.spouse(ref)", "singletonObject");
	(new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
	Object singletonObject = new TestBean();
	lbf.registerSingleton("singletonObject", singletonObject);

	assertTrue(lbf.isSingleton("singletonObject"));
	assertEquals(TestBean.class, lbf.getType("singletonObject"));
	TestBean test = (TestBean) lbf.getBean("test");
	assertEquals(singletonObject, lbf.getBean("singletonObject"));
	assertEquals(singletonObject, test.getSpouse());

	Map<?, ?> beansOfType = lbf.getBeansOfType(TestBean.class, false, true);
	assertEquals(2, beansOfType.size());
	assertTrue(beansOfType.containsValue(test));
	assertTrue(beansOfType.containsValue(singletonObject));

	beansOfType = lbf.getBeansOfType(null, false, true);
	assertEquals(2, beansOfType.size());

	Iterator<String> beanNames = lbf.getBeanNamesIterator();
	assertEquals("test", beanNames.next());
	assertEquals("singletonObject", beanNames.next());
	assertFalse(beanNames.hasNext());

	assertTrue(lbf.containsSingleton("test"));
	assertTrue(lbf.containsSingleton("singletonObject"));
	assertTrue(lbf.containsBeanDefinition("test"));
	assertFalse(lbf.containsBeanDefinition("singletonObject"));
}
 

import org.springframework.beans.factory.support.DefaultListableBeanFactory; //导入方法依赖的package包/类
@Test
public void testRegisterExistingSingletonWithNameOverriding() {
	DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
	Properties p = new Properties();
	p.setProperty("test.(class)", TestBean.class.getName());
	p.setProperty("test.name", "Tony");
	p.setProperty("test.age", "48");
	p.setProperty("test.spouse(ref)", "singletonObject");
	(new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
	lbf.registerBeanDefinition("singletonObject", new RootBeanDefinition(PropertiesFactoryBean.class));
	Object singletonObject = new TestBean();
	lbf.registerSingleton("singletonObject", singletonObject);
	lbf.preInstantiateSingletons();

	assertTrue(lbf.isSingleton("singletonObject"));
	assertEquals(TestBean.class, lbf.getType("singletonObject"));
	TestBean test = (TestBean) lbf.getBean("test");
	assertEquals(singletonObject, lbf.getBean("singletonObject"));
	assertEquals(singletonObject, test.getSpouse());

	Map<?, ?>  beansOfType = lbf.getBeansOfType(TestBean.class, false, true);
	assertEquals(2, beansOfType.size());
	assertTrue(beansOfType.containsValue(test));
	assertTrue(beansOfType.containsValue(singletonObject));

	beansOfType = lbf.getBeansOfType(null, false, true);

	Iterator<String> beanNames = lbf.getBeanNamesIterator();
	assertEquals("test", beanNames.next());
	assertEquals("singletonObject", beanNames.next());
	assertFalse(beanNames.hasNext());
	assertEquals(2, beansOfType.size());

	assertTrue(lbf.containsSingleton("test"));
	assertTrue(lbf.containsSingleton("singletonObject"));
	assertTrue(lbf.containsBeanDefinition("test"));
	assertTrue(lbf.containsBeanDefinition("singletonObject"));
}
 

import org.springframework.beans.factory.support.DefaultListableBeanFactory; //导入方法依赖的package包/类
@Test
public void testCircularReferenceThroughFactoryBeanTypeCheck() {
	DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
	RootBeanDefinition bd = new RootBeanDefinition(ConstructorDependencyFactoryBean.class);
	bd.setAutowireMode(RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
	lbf.registerBeanDefinition("test", bd);
	try {
		lbf.getBeansOfType(String.class);
		fail("Should have thrown UnsatisfiedDependencyException");
	}
	catch (UnsatisfiedDependencyException expected) {
	}
}
 

import org.springframework.beans.factory.support.DefaultListableBeanFactory; //导入方法依赖的package包/类
public void setBeanFactory(BeanFactory beanFactory) {
	DefaultListableBeanFactory factory = (DefaultListableBeanFactory) beanFactory;
	Map<String, Xarg> map = factory.getBeansOfType(Xarg.class);
	for (Entry<String, Xarg> entry : map.entrySet()) {
		Xarg xarg = entry.getValue();
		// System.err.println("xarg:" + xarg);
		paramMap.put(xarg.getKey(), xarg);
	}
}
 

import org.springframework.beans.factory.support.DefaultListableBeanFactory; //导入方法依赖的package包/类
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
	DefaultListableBeanFactory factory = (DefaultListableBeanFactory) beanFactory;
	Map<String, PassportValidator> map = factory.getBeansOfType(PassportValidator.class);
	for (Entry<String, PassportValidator> entry : map.entrySet()) {
		list.add(new DefaultPassportValidatorWrapper(entry.getValue()));
	}
	// System.err.println("list:" + list);
	passportChecker.setBeanFactory(beanFactory);
}
 

import org.springframework.beans.factory.support.DefaultListableBeanFactory; //导入方法依赖的package包/类
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
	DefaultListableBeanFactory factory = (DefaultListableBeanFactory) beanFactory;
	Map<String, PassportChecker> map = factory.getBeansOfType(PassportChecker.class);
	for (Entry<String, PassportChecker> entry : map.entrySet()) {
		// System.err.println("PassportCheckerImpl entry:" + entry.getValue());
		passportCheckerList.add(entry.getValue());
	}
}
 

import org.springframework.beans.factory.support.DefaultListableBeanFactory; //导入方法依赖的package包/类
@Test
public void testAbstractFactoryBeanViaType() throws Exception {
	DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
	new XmlBeanDefinitionReader(factory).loadBeanDefinitions(ABSTRACT_CONTEXT);
	factory.getBeansOfType(AbstractFactoryBean.class);
}