@Test
public void testProxyFactory2Lazy() throws NoSuchMethodException {
ITestBean testBean = (ITestBean) factory.getBean("proxyFactory2Lazy");
assertFalse(factory.containsSingleton("target"));
assertEquals(666, testBean.getAge());
assertTrue(factory.containsSingleton("target"));
}
@SuppressWarnings("resource")
@Before
public void setup() throws Exception {
DefaultListableBeanFactory dlbf = new DefaultListableBeanFactory();
dlbf.registerSingleton("mvcValidator", testValidator());
GenericApplicationContext ctx = new GenericApplicationContext(dlbf);
ctx.refresh();
this.resolver =
new PayloadArgumentResolver(
ctx, new MethodParameterConverter(new ObjectMapper(), new GenericConversionService()));
this.payloadMethod =
getClass()
.getDeclaredMethod(
"handleMessage",
String.class,
String.class,
String.class,
String.class,
String.class,
String.class,
String.class,
Integer.class);
this.paramAnnotated = getMethodParameter(this.payloadMethod, 0);
this.paramAnnotatedNotRequired = getMethodParameter(this.payloadMethod, 1);
this.paramAnnotatedRequired = getMethodParameter(this.payloadMethod, 2);
this.paramWithSpelExpression = getMethodParameter(this.payloadMethod, 3);
this.paramValidated = getMethodParameter(this.payloadMethod, 4);
this.paramValidated.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
this.paramValidatedNotAnnotated = getMethodParameter(this.payloadMethod, 5);
this.paramNotAnnotated = getMethodParameter(this.payloadMethod, 6);
}
@SuppressWarnings({"rawtypes", "unchecked"})
public void testRegisterNotificationListenerWithObjectNameBeforeBeanNameMappedToSameBeanInstance()
throws Exception {
String beanName = "testBean";
ObjectName objectName = ObjectName.getInstance("spring:name=Test");
SelfNamingTestBean testBean = new SelfNamingTestBean();
testBean.setObjectName(objectName);
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
factory.registerSingleton(beanName, testBean);
Map<String, Object> beans = new HashMap<String, Object>();
beans.put(beanName, testBean);
Map listenerMappings = new HashMap();
CountingAttributeChangeNotificationListener listener =
new CountingAttributeChangeNotificationListener();
listenerMappings.put(objectName, listener);
listenerMappings.put(beanName, listener);
MBeanExporter exporter = new MBeanExporter();
exporter.setServer(server);
exporter.setBeans(beans);
exporter.setNotificationListenerMappings(listenerMappings);
exporter.setBeanFactory(factory);
exporter.afterPropertiesSet();
assertIsRegistered("Should have registered MBean", objectName);
server.setAttribute(objectName, new Attribute("Age", new Integer(77)));
assertEquals("Listener should have been notified exactly once", 1, listener.getCount("Age"));
}
@Test
public void parseInternal_withMinimalConfig_shouldCreateDefaultTemplate() throws Exception {
// Arrange
DefaultListableBeanFactory registry = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(registry);
// Act
reader.loadBeanDefinitions(
new ClassPathResource(getClass().getSimpleName() + "-minimal.xml", getClass()));
// Assert
NotificationMessagingTemplate notificationMessagingTemplate =
registry.getBean(NotificationMessagingTemplate.class);
assertSame(
registry.getBean(AmazonSNSClient.class),
ReflectionTestUtils.getField(notificationMessagingTemplate, "amazonSns"));
Object cachingDestinationResolverProxy =
ReflectionTestUtils.getField(notificationMessagingTemplate, "destinationResolver");
Object targetDestinationResolver =
ReflectionTestUtils.getField(cachingDestinationResolverProxy, "targetDestinationResolver");
assertEquals(
registry.getBean(GlobalBeanDefinitionUtils.RESOURCE_ID_RESOLVER_BEAN_NAME),
ReflectionTestUtils.getField(targetDestinationResolver, "resourceIdResolver"));
assertTrue(
StringMessageConverter.class.isInstance(
notificationMessagingTemplate.getMessageConverter()));
assertEquals(
String.class,
ReflectionTestUtils.getField(
notificationMessagingTemplate.getMessageConverter(), "serializedPayloadClass"));
}
protected void setUp() {
parent = new DefaultListableBeanFactory();
Map m = new HashMap();
m.put("name", "Albert");
parent.registerBeanDefinition(
"father", new RootBeanDefinition(TestBean.class, new MutablePropertyValues(m)));
m = new HashMap();
m.put("name", "Roderick");
parent.registerBeanDefinition(
"rod", new RootBeanDefinition(TestBean.class, new MutablePropertyValues(m)));
this.factory = new XmlBeanFactory(new ClassPathResource("test.xml", getClass()), parent);
this.factory.addBeanPostProcessor(
new BeanPostProcessor() {
public Object postProcessBeforeInitialization(Object bean, String name)
throws BeansException {
if (bean instanceof TestBean) {
((TestBean) bean).setPostProcessed(true);
}
if (bean instanceof DummyFactory) {
((DummyFactory) bean).setPostProcessed(true);
}
return bean;
}
public Object postProcessAfterInitialization(Object bean, String name)
throws BeansException {
return bean;
}
});
this.factory.addBeanPostProcessor(new LifecycleBean.PostProcessor());
this.factory.addBeanPostProcessor(new ProtectedLifecycleBean.PostProcessor());
// this.factory.preInstantiateSingletons();
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException {
if (!(beanFactory instanceof DefaultListableBeanFactory)) {
log.error("if speed up spring, bean factory must be type of DefaultListableBeanFactory");
return;
}
DefaultListableBeanFactory listableBeanFactory = (DefaultListableBeanFactory) beanFactory;
for (String beanName : listableBeanFactory.getBeanDefinitionNames()) {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
// 如果匹配模式 就移除掉
if (needRemove(beanName, beanDefinition)) {
listableBeanFactory.removeBeanDefinition(beanName);
continue;
}
// 否则设置为lazy
if (needLazyInit(beanName)) {
beanDefinition.setLazyInit(true);
}
}
}
private void doTestValidation(String resourceName) throws Exception {
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
;
Resource resource = new ClassPathResource(resourceName, getClass());
new XmlBeanDefinitionReader(factory).loadBeanDefinitions(resource);
TestBean bean = (TestBean) factory.getBean("testBean");
assertNotNull(bean);
}
/**
* Customize the internal bean factory used by this context. Called for each {@link #refresh()}
* attempt.
*
* <p>The default implementation applies this context's {@linkplain
* #setAllowBeanDefinitionOverriding "allowBeanDefinitionOverriding"} and {@linkplain
* #setAllowCircularReferences "allowCircularReferences"} settings, if specified. Can be
* overridden in subclasses to customize any of {@link DefaultListableBeanFactory}'s settings.
*
* @param beanFactory the newly created bean factory for this context
* @see DefaultListableBeanFactory#setAllowBeanDefinitionOverriding
* @see DefaultListableBeanFactory#setAllowCircularReferences
* @see DefaultListableBeanFactory#setAllowRawInjectionDespiteWrapping
* @see DefaultListableBeanFactory#setAllowEagerClassLoading
*/
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
if (this.allowBeanDefinitionOverriding != null) {
beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
if (this.allowCircularReferences != null) {
beanFactory.setAllowCircularReferences(this.allowCircularReferences);
}
beanFactory.setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
}
private boolean reconfigureBean(
DefaultListableBeanFactory beanFactory, Class<?> beanClass, String beanName) {
Object serviceConnector = this.cloud.getSingletonServiceConnector(beanClass, null);
beanFactory.registerSingleton(getServiceBeanName(), serviceConnector);
beanFactory.removeBeanDefinition(beanName);
beanFactory.registerAlias(getServiceBeanName(), beanName);
return true;
}
public void testSunnyDayWithBonaFideScopeClassname() throws Exception {
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
Map scopes = new HashMap();
scopes.put(FOO_SCOPE, NoOpScope.class.getName());
CustomScopeConfigurer figurer = new CustomScopeConfigurer();
figurer.setScopes(scopes);
figurer.postProcessBeanFactory(factory);
assertTrue(factory.getRegisteredScope(FOO_SCOPE) instanceof NoOpScope);
}
@Test
public void testPrivateFactoryMethod() {
DefaultListableBeanFactory xbf = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(xbf);
reader.loadBeanDefinitions(new ClassPathResource("factory-methods.xml", getClass()));
TestBean tb = (TestBean) xbf.getBean("defaultTestBean.private");
assertEquals(1, tb.getAge());
}
@Test
public void testFactoryMethodForJavaMailSession() {
DefaultListableBeanFactory xbf = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(xbf);
reader.loadBeanDefinitions(new ClassPathResource("factory-methods.xml", getClass()));
MailSession session = (MailSession) xbf.getBean("javaMailSession");
assertEquals("someuser", session.getProperty("mail.smtp.user"));
assertEquals("somepw", session.getProperty("mail.smtp.password"));
}
@Test
public void eventBusElement() {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition("eventBus");
assertNotNull("Bean definition not created", beanDefinition);
assertEquals(
"Wrong bean class", SimpleEventBus.class.getName(), beanDefinition.getBeanClassName());
SimpleEventBus eventBus = beanFactory.getBean("eventBus", SimpleEventBus.class);
assertNotNull(eventBus);
}
@Test
public void testParseWithQueues() throws Exception {
SimpleMessageListenerContainer container =
beanFactory.getBean("container2", SimpleMessageListenerContainer.class);
Queue queue = beanFactory.getBean("bar", Queue.class);
assertEquals(
"[foo, " + queue.getName() + "]", Arrays.asList(container.getQueueNames()).toString());
assertTrue(TestUtils.getPropertyValue(container, "missingQueuesFatal", Boolean.class));
assertFalse(TestUtils.getPropertyValue(container, "autoDeclare", Boolean.class));
}
/** Tests where the static factory method is on a different class. */
@Test
public void testFactoryMethodsOnExternalClass() {
DefaultListableBeanFactory xbf = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(xbf);
reader.loadBeanDefinitions(new ClassPathResource("factory-methods.xml", getClass()));
assertEquals(TestBean.class, xbf.getType("externalFactoryMethodWithoutArgs"));
assertEquals(TestBean.class, xbf.getType("externalFactoryMethodWithArgs"));
String[] names = xbf.getBeanNamesForType(TestBean.class);
assertTrue(Arrays.asList(names).contains("externalFactoryMethodWithoutArgs"));
assertTrue(Arrays.asList(names).contains("externalFactoryMethodWithArgs"));
TestBean tb = (TestBean) xbf.getBean("externalFactoryMethodWithoutArgs");
assertEquals(2, tb.getAge());
assertEquals("Tristan", tb.getName());
tb = (TestBean) xbf.getBean("externalFactoryMethodWithArgs");
assertEquals(33, tb.getAge());
assertEquals("Rod", tb.getName());
assertEquals(TestBean.class, xbf.getType("externalFactoryMethodWithoutArgs"));
assertEquals(TestBean.class, xbf.getType("externalFactoryMethodWithArgs"));
names = xbf.getBeanNamesForType(TestBean.class);
assertTrue(Arrays.asList(names).contains("externalFactoryMethodWithoutArgs"));
assertTrue(Arrays.asList(names).contains("externalFactoryMethodWithArgs"));
}
@Test
public void testFactoryMethodsWithAutowire() {
DefaultListableBeanFactory xbf = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(xbf);
reader.loadBeanDefinitions(new ClassPathResource("factory-methods.xml", getClass()));
FactoryMethods fm = (FactoryMethods) xbf.getBean("fullWithAutowire");
assertEquals(27, fm.getNum());
assertEquals("gotchaAutowired", fm.getName());
assertEquals("Juergen", fm.getTestBean().getName());
}
@Test
public void testPostProcessorWithNullBean() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.addBeanPostProcessor(new CommonAnnotationBeanPostProcessor());
RootBeanDefinition rbd = new RootBeanDefinition(NullFactory.class);
rbd.setFactoryMethodName("create");
bf.registerBeanDefinition("bean", rbd);
assertNull(bf.getBean("bean"));
bf.destroySingletons();
}
@Test
public void testPostConstructAndPreDestroy() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.addBeanPostProcessor(new CommonAnnotationBeanPostProcessor());
bf.registerBeanDefinition("annotatedBean", new RootBeanDefinition(AnnotatedInitDestroyBean.class));
AnnotatedInitDestroyBean bean = (AnnotatedInitDestroyBean) bf.getBean("annotatedBean");
assertTrue(bean.initCalled);
bf.destroySingletons();
assertTrue(bean.destroyCalled);
}
@Test
public void testFactoryMethodNoMatchingStaticMethod() {
DefaultListableBeanFactory xbf = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(xbf);
reader.loadBeanDefinitions(new ClassPathResource("factory-methods.xml", getClass()));
try {
xbf.getBean("noMatchPrototype");
fail("No static method matched");
} catch (BeanCreationException ex) {
// Ok
}
}
@After
public void tearDown() {
final ConfigurableApplicationContext ctx =
(ConfigurableApplicationContext) Registry.getApplicationContext();
final DefaultListableBeanFactory beanFactory =
(DefaultListableBeanFactory) ctx.getBeanFactory();
beanFactory.removeBeanDefinition(PROCEDURAL_ACTION_ID);
beanFactory.removeBeanDefinition(JOURNAL_ID);
processDefinitionsCache.clear();
}
@Test
public void testCannotSpecifyFactoryMethodArgumentsOnSingleton() {
DefaultListableBeanFactory xbf = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(xbf);
reader.loadBeanDefinitions(new ClassPathResource("factory-methods.xml", getClass()));
try {
xbf.getBean("testBeanOnly", new TestBean());
fail("Shouldn't allow args to be passed to a singleton");
} catch (BeanDefinitionStoreException ex) {
// OK
}
}
@Test
public void testAnonListeners() throws Exception {
beanFactory.getBean(
"org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer#0",
SimpleMessageListenerContainer.class);
beanFactory.getBean(
"org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer#1",
SimpleMessageListenerContainer.class);
beanFactory.getBean("namedListener", SimpleMessageListenerContainer.class);
beanFactory.getBean(
"org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer#2",
SimpleMessageListenerContainer.class);
}
/** Check that we fail gracefully if the user doesn't set any transaction attributes. */
@Test
public void testNoTransactionAttributeSource() {
try {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
new XmlBeanDefinitionReader(bf)
.loadBeanDefinitions(
new ClassPathResource("noTransactionAttributeSource.xml", getClass()));
bf.getBean("noTransactionAttributeSource");
fail("Should require TransactionAttributeSource to be set");
} catch (FatalBeanException ex) {
// Ok
}
}
@Test
public void testFactoryMethodsWithInvalidDestroyMethod() {
DefaultListableBeanFactory xbf = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(xbf);
reader.loadBeanDefinitions(new ClassPathResource("factory-methods.xml", getClass()));
try {
xbf.getBean("defaultTestBeanWithInvalidDestroyMethod");
fail("Should have thrown BeanCreationException");
} catch (BeanCreationException ex) {
// expected
}
}
@Test
public void logBeansInContext() {
DefaultListableBeanFactory factory = (DefaultListableBeanFactory) beanFactory;
if (factory != null) {
logger.debug("Bean Factory: '{}'", factory);
}
if (applicationContext.getParent() != null) {
logger.debug("Bean Factory: '{}'", applicationContext.getParentBeanFactory());
}
logger.debug("******************************************************************************");
String[] beans = applicationContext.getBeanDefinitionNames();
for (String o : beans) {
logger.debug("________________________");
logger.debug("BEAN id: '{}'", o);
logger.debug("\tType: '{}'", applicationContext.getType(o));
String[] aliases = applicationContext.getAliases(o);
if (factory.isFactoryBean(o)) logger.debug("\tFACTORY");
if (aliases != null && aliases.length > 0) {
for (String a : aliases) {
logger.debug("\tAliased as: '{}'", a);
}
}
if (factory.getBeanDefinition(o).isAbstract()) {
logger.debug("\tABSTRACT");
} else {
if (applicationContext.isPrototype(o)) logger.debug("\tScope: 'Prototype'");
if (applicationContext.isSingleton(o)) logger.debug("\tScope: 'Singleton'");
Annotation[] annotations = applicationContext.getBean(o).getClass().getAnnotations();
if (annotations != null && annotations.length > 0) {
logger.debug("\tAnnotations:");
for (Annotation annotation : annotations) {
logger.debug("\t\t'{}'", annotation.annotationType());
}
}
if (!applicationContext
.getBean(o)
.toString()
.startsWith(applicationContext.getType(o).toString() + "@")) {
logger.debug("\tContents: {}", applicationContext.getBean(o).toString());
}
}
}
logger.debug("******************************************************************************");
logger.debug("*** Number of Beans={} ***", applicationContext.getBeanDefinitionCount());
logger.debug("*** Number of Bean Post Processors={} ***", factory.getBeanPostProcessorCount());
logger.debug("******************************************************************************");
}
@Before
public void setup() {
BeanDefinitionBuilder builder =
BeanDefinitionBuilder.rootBeanDefinition(DummyRepositoryFactoryBean.class);
builder.addPropertyValue("repositoryInterface", EntityRepository.class);
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
factory.registerBeanDefinition("provider", builder.getBeanDefinition());
context = new GenericApplicationContext(factory);
context.refresh();
registrar = new DomainClassPropertyEditorRegistrar();
}
@Test
public void eventBusElement() {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition("eventBus");
assertNotNull("Bean definition not created", beanDefinition);
assertEquals(
"Wrong bean class", SimpleEventBus.class.getName(), beanDefinition.getBeanClassName());
assertEquals(
"wrong amount of constructor arguments",
0,
beanDefinition.getConstructorArgumentValues().getArgumentCount());
EventBus eventBus = beanFactory.getBean("eventBus", EventBus.class);
assertNotNull(eventBus);
}
/**
* Load the template BeanDefinition and call {@link #transform(ConfigurableListableBeanFactory,
* BeanDefinition, Element, ParserContext)} to apply runtime configuration value to it. <code>
* builder</code> will be configured to instantiate the bean in the Spring context that we are
* parsing.
*
* <p>During parsing, an instance of {@link
* TemplateBeanDefinitionParser.TemplateComponentDefinition} is pushed onto <code>ParserContext
* </code> so that nested tags can access the enclosing template configuration with a call to
* {@link #findEnclosingTemplateFactory(ParserContext)}. Subclasses can override {@link
* #newComponentDefinition(String, Object, DefaultListableBeanFactory)} to provide a subclass of
* {@link TemplateBeanDefinitionParser.TemplateComponentDefinition} to the parser context if
* necessary.
*/
@Override
protected final void doParse(
Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
// if we have multiple nested bean definitions, we only parse the template factory
// once. this allows configuration changes made by enclosing bean parsers to be inherited
// by contained beans, which is quite useful.
DefaultListableBeanFactory templateFactory = findEnclosingTemplateFactory(parserContext);
TemplateComponentDefinition tcd = null;
if (templateFactory == null) {
// no nesting -- load the template XML configuration from the classpath.
final BeanFactory parentFactory = (BeanFactory) parserContext.getRegistry();
templateFactory = new DefaultListableBeanFactory(parentFactory);
// load template bean definitions
DefaultResourceLoader loader = new DefaultResourceLoader();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(templateFactory);
reader.setResourceLoader(loader);
reader.setEntityResolver(new ResourceEntityResolver(loader));
reader.loadBeanDefinitions(templateResource);
// propagate factory post-processors from the source factory into the template
// factory.
BeanDefinition ppChain = new RootBeanDefinition(ChainingBeanFactoryPostProcessor.class);
ppChain.getPropertyValues().addPropertyValue("targetFactory", templateFactory);
parserContext.getReaderContext().registerWithGeneratedName(ppChain);
// push component definition onto the parser stack for the benefit of
// nested bean definitions.
tcd =
newComponentDefinition(
element.getNodeName(), parserContext.extractSource(element), templateFactory);
parserContext.pushContainingComponent(tcd);
}
try {
// allow subclasses to apply overrides to the template bean definition.
BeanDefinition def = templateFactory.getBeanDefinition(templateId);
transform(templateFactory, def, element, parserContext);
// setup our factory bean to instantiate the modified bean definition upon request.
builder.addPropertyValue("beanFactory", templateFactory);
builder.addPropertyValue("beanName", templateId);
builder.getRawBeanDefinition().setAttribute("id", def.getAttribute("id"));
} finally {
if (tcd != null) parserContext.popContainingComponent();
}
}
/** @param args */
public static void main(String[] args) {
final DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
// reader.setValidating(false);
reader.loadBeanDefinitions(new ClassPathResource("spring-container.xml"));
BeanFactoryContainer.LOGGER.info(" Bean definitions loaded ");
final Employee employee = (Employee) beanFactory.getBean("employee");
BeanFactoryContainer.LOGGER.info("Employee : " + employee);
}
@Test
public void testPostConstructAndPreDestroyWithManualConfiguration() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
InitDestroyAnnotationBeanPostProcessor bpp = new InitDestroyAnnotationBeanPostProcessor();
bpp.setInitAnnotationType(PostConstruct.class);
bpp.setDestroyAnnotationType(PreDestroy.class);
bf.addBeanPostProcessor(bpp);
bf.registerBeanDefinition("annotatedBean", new RootBeanDefinition(AnnotatedInitDestroyBean.class));
AnnotatedInitDestroyBean bean = (AnnotatedInitDestroyBean) bf.getBean("annotatedBean");
assertTrue(bean.initCalled);
bf.destroySingletons();
assertTrue(bean.destroyCalled);
}
