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