|
1
16
17 package org.springframework.beans.factory;
18
19 import java.text.NumberFormat  ;
20 import java.util.Locale ;
21 import java.util.Map ;
22 import java.util.Properties ;
23
24 import junit.framework.TestCase;
25
26 import org.springframework.aop.interceptor.SideEffectBean;
27 import org.springframework.beans.BeansException;
28 import org.springframework.beans.ITestBean;
29 import org.springframework.beans.MutablePropertyValues;
30 import org.springframework.beans.NestedTestBean;
31 import org.springframework.beans.PropertyValue;
32 import org.springframework.beans.TestBean;
33 import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
34 import org.springframework.beans.factory.config.BeanPostProcessor;
35 import org.springframework.beans.factory.config.RuntimeBeanReference;
36 import org.springframework.beans.factory.support.AbstractBeanFactory;
37 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
38 import org.springframework.beans.factory.support.PropertiesBeanDefinitionReader;
39 import org.springframework.beans.factory.support.RootBeanDefinition;
40 import org.springframework.beans.factory.xml.ConstructorDependenciesBean;
41 import org.springframework.beans.factory.xml.DependenciesBean;
42 import org.springframework.beans.propertyeditors.CustomNumberEditor;
43
44
49 public class DefaultListableBeanFactoryTests extends TestCase {
50
51 public void testUnreferencedSingletonWasInstantiated() {
52 KnowsIfInstantiated.clearInstantiationRecord();
53 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
54 Properties p = new Properties ();
55 p.setProperty("x1.class", KnowsIfInstantiated.class.getName());
56 assertTrue("singleton not instantiated", !KnowsIfInstantiated.wasInstantiated());
57 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
58 lbf.preInstantiateSingletons();
59 assertTrue("singleton was instantiated", KnowsIfInstantiated.wasInstantiated());
60 }
61
62 public void testLazyInitialization() {
63 KnowsIfInstantiated.clearInstantiationRecord();
64 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
65 Properties p = new Properties ();
66 p.setProperty("x1.class", KnowsIfInstantiated.class.getName());
67 p.setProperty("x1.(lazy-init)", "true");
68 assertTrue("singleton not instantiated", !KnowsIfInstantiated.wasInstantiated());
69 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
70 assertTrue("singleton not instantiated", !KnowsIfInstantiated.wasInstantiated());
71 lbf.preInstantiateSingletons();
72
73 assertTrue("singleton not instantiated", !KnowsIfInstantiated.wasInstantiated());
74 lbf.getBean("x1");
75 assertTrue("singleton was instantiated", KnowsIfInstantiated.wasInstantiated());
76 }
77
78 public void testFactoryBeanDidNotCreatePrototype() {
79 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
80 Properties p = new Properties ();
81 p.setProperty("x1.class", DummyFactory.class.getName());
82 DummyFactory.reset();
84 p.setProperty("x1.singleton", "false");
85 assertTrue("prototype not instantiated", !DummyFactory.wasPrototypeCreated());
86 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
87 assertTrue("prototype not instantiated", !DummyFactory.wasPrototypeCreated());
88 assertEquals(TestBean.class, lbf.getType("x1"));
89 lbf.preInstantiateSingletons();
90
91 assertTrue("prototype not instantiated", !DummyFactory.wasPrototypeCreated());
92 lbf.getBean("x1");
93 assertEquals(TestBean.class, lbf.getType("x1"));
94 assertTrue("prototype was instantiated", DummyFactory.wasPrototypeCreated());
95 }
96
97 public void testEmpty() {
98 ListableBeanFactory lbf = new DefaultListableBeanFactory();
99 assertTrue("No beans defined --> array != null", lbf.getBeanDefinitionNames() != null);
100 assertTrue("No beans defined after no arg constructor", lbf.getBeanDefinitionNames().length == 0);
101 assertTrue("No beans defined after no arg constructor", lbf.getBeanDefinitionCount() == 0);
102 }
103
104 public void testEmptyPropertiesPopulation() throws BeansException {
105 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
106 Properties p = new Properties ();
107 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
108 assertTrue("No beans defined after ignorable invalid", lbf.getBeanDefinitionCount() == 0);
109 }
110
111 public void testHarmlessIgnorableRubbish() throws BeansException {
112 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
113 Properties p = new Properties ();
114 p.setProperty("foo", "bar");
115 p.setProperty("qwert", "er");
116 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p, "test");
117 assertTrue("No beans defined after harmless ignorable rubbish", lbf.getBeanDefinitionCount() == 0);
118 }
119
120 public void testPropertiesPopulationWithNullPrefix() throws Exception {
121 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
122 Properties p = new Properties ();
123 p.setProperty("test.class", "org.springframework.beans.TestBean");
124 p.setProperty("test.name", "Tony");
125 p.setProperty("test.age", "48");
126 int count = (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
128 assertTrue("1 beans registered, not " + count, count == 1);
129 testSingleTestBean(lbf);
130 }
131
132 public void testPropertiesPopulationWithPrefix() throws Exception {
133 String PREFIX = "beans.";
134 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
135 Properties p = new Properties ();
136 p.setProperty(PREFIX + "test.class", "org.springframework.beans.TestBean");
137 p.setProperty(PREFIX + "test.name", "Tony");
138 p.setProperty(PREFIX + "test.age", "48");
139 int count = (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p, PREFIX);
141 assertTrue("1 beans registered, not " + count, count == 1);
142 testSingleTestBean(lbf);
143 }
144
145 public void testSimpleReference() throws Exception {
146 String PREFIX = "beans.";
147 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
148 Properties p = new Properties ();
149
150 p.setProperty(PREFIX + "rod.class", "org.springframework.beans.TestBean");
151 p.setProperty(PREFIX + "rod.name", "Rod");
152
153 p.setProperty(PREFIX + "kerry.class", "org.springframework.beans.TestBean");
154 p.setProperty(PREFIX + "kerry.class", "org.springframework.beans.TestBean");
155 p.setProperty(PREFIX + "kerry.name", "Kerry");
156 p.setProperty(PREFIX + "kerry.age", "35");
157 p.setProperty(PREFIX + "kerry.spouse(ref)", "rod");
158
159 int count = (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p, PREFIX);
160 assertTrue("2 beans registered, not " + count, count == 2);
161
162 TestBean kerry = (TestBean) lbf.getBean("kerry", TestBean.class);
163 assertTrue("Kerry name is Kerry", "Kerry".equals(kerry.getName()));
164 ITestBean spouse = kerry.getSpouse();
165 assertTrue("Kerry spouse is non null", spouse != null);
166 assertTrue("Kerry spouse name is Rod", "Rod".equals(spouse.getName()));
167 }
168
169 public void testPropertiesWithDotsInKey() {
170 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
171 Properties p = new Properties ();
172
173 p.setProperty("tb.class", "org.springframework.beans.TestBean");
174 p.setProperty("tb.someMap[my.key]", "my.value");
175
176 int count = (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
177 assertTrue("1 beans registered, not " + count, count == 1);
178 assertEquals(1, lbf.getBeanDefinitionCount());
179
180 TestBean tb = (TestBean) lbf.getBean("tb", TestBean.class);
181 assertEquals("my.value", tb.getSomeMap().get("my.key"));
182 }
183
184 public void testUnresolvedReference() throws Exception {
185 String PREFIX = "beans.";
186 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
187 Properties p = new Properties ();
188
189 try {
190 p.setProperty(PREFIX + "kerry.class", "org.springframework.beans.TestBean");
191 p.setProperty(PREFIX + "kerry.class", "org.springframework.beans.TestBean");
192 p.setProperty(PREFIX + "kerry.name", "Kerry");
193 p.setProperty(PREFIX + "kerry.age", "35");
194 p.setProperty(PREFIX + "kerry.spouse(ref)", "rod");
195
196 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p, PREFIX);
197
198 Object kerry = lbf.getBean("kerry");
199 fail ("Unresolved reference should have been detected");
200 }
201 catch (BeansException ex) {
202 }
204 }
205
206 public void testSelfReference() {
207 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
208 MutablePropertyValues pvs = new MutablePropertyValues();
209 pvs.addPropertyValue("spouse", new RuntimeBeanReference("self"));
210 lbf.registerBeanDefinition("self", new RootBeanDefinition(TestBean.class, pvs));
211 TestBean self = (TestBean) lbf.getBean("self");
212 assertEquals(self, self.getSpouse());
213 }
214
215 public void testPrototype() throws Exception {
216 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
217 Properties p = new Properties ();
218 p.setProperty("kerry.class", "org.springframework.beans.TestBean");
219 p.setProperty("kerry.age", "35");
220 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
221 TestBean kerry1 = (TestBean) lbf.getBean("kerry");
222 TestBean kerry2 = (TestBean) lbf.getBean("kerry");
223 assertTrue("Non null", kerry1 != null);
224 assertTrue("Singletons equal", kerry1 == kerry2);
225
226 lbf = new DefaultListableBeanFactory();
227 p = new Properties ();
228 p.setProperty("kerry.class", "org.springframework.beans.TestBean");
229 p.setProperty("kerry.(singleton)", "false");
230 p.setProperty("kerry.age", "35");
231 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
232 kerry1 = (TestBean) lbf.getBean("kerry");
233 kerry2 = (TestBean) lbf.getBean("kerry");
234 assertTrue("Non null", kerry1 != null);
235 assertTrue("Prototypes NOT equal", kerry1 != kerry2);
236
237 lbf = new DefaultListableBeanFactory();
238 p = new Properties ();
239 p.setProperty("kerry.class", "org.springframework.beans.TestBean");
240 p.setProperty("kerry.(singleton)", "true");
241 p.setProperty("kerry.age", "35");
242 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
243 kerry1 = (TestBean) lbf.getBean("kerry");
244 kerry2 = (TestBean) lbf.getBean("kerry");
245 assertTrue("Non null", kerry1 != null);
246 assertTrue("Specified singletons equal", kerry1 == kerry2);
247 }
248
249 public void testPrototypeExtendsPrototype() throws Exception {
250 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
251 Properties p = new Properties ();
252 p.setProperty("wife.class", "org.springframework.beans.TestBean");
253 p.setProperty("wife.name", "kerry");
254
255 p.setProperty("kerry.parent", "wife");
256 p.setProperty("kerry.age", "35");
257 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
258 TestBean kerry1 = (TestBean) lbf.getBean("kerry");
259 TestBean kerry2 = (TestBean) lbf.getBean("kerry");
260 assertEquals("kerry", kerry1.getName());
261 assertTrue("Non null", kerry1 != null);
262 assertTrue("Singletons equal", kerry1 == kerry2);
263
264 lbf = new DefaultListableBeanFactory();
265 p = new Properties ();
266 p.setProperty("wife.class", "org.springframework.beans.TestBean");
267 p.setProperty("wife.name", "kerry");
268 p.setProperty("wife.(singleton)", "false");
269 p.setProperty("kerry.parent", "wife");
270 p.setProperty("kerry.(singleton)", "false");
271 p.setProperty("kerry.age", "35");
272 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
273 assertFalse(lbf.isSingleton("kerry"));
274 kerry1 = (TestBean) lbf.getBean("kerry");
275 kerry2 = (TestBean) lbf.getBean("kerry");
276 assertTrue("Non null", kerry1 != null);
277 assertTrue("Prototypes NOT equal", kerry1 != kerry2);
278
279 lbf = new DefaultListableBeanFactory();
280 p = new Properties ();
281 p.setProperty("kerry.class", "org.springframework.beans.TestBean");
282 p.setProperty("kerry.(singleton)", "true");
283 p.setProperty("kerry.age", "35");
284 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
285 kerry1 = (TestBean) lbf.getBean("kerry");
286 kerry2 = (TestBean) lbf.getBean("kerry");
287 assertTrue("Non null", kerry1 != null);
288 assertTrue("Specified singletons equal", kerry1 == kerry2);
289 }
290
291 public void testNameAlreadyBound() throws Exception {
292 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
293 Properties p = new Properties ();
294 p.setProperty("kerry.class", "org.springframework.beans.TestBean");
295 p.setProperty("kerry.age", "35");
296 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
297 try {
298 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
299 }
300 catch (BeanDefinitionStoreException ex) {
301 assertEquals("kerry", ex.getBeanName());
302 }
304 }
305
306 private void testSingleTestBean(ListableBeanFactory lbf) throws BeansException {
307 assertTrue("1 beans defined", lbf.getBeanDefinitionCount() == 1);
308 String [] names = lbf.getBeanDefinitionNames();
309 assertTrue("Array length == 1", names.length == 1);
310 assertTrue("0th element == test", names[0].equals("test"));
311 TestBean tb = (TestBean) lbf.getBean("test");
312 assertTrue("Test is non null", tb != null);
313 assertTrue("Test bean name is Tony", "Tony".equals(tb.getName()));
314 assertTrue("Test bean age is 48", tb.getAge() == 48);
315 }
316
317 public void testBeanDefinitionOverriding() throws BeansException {
318 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
319 lbf.registerBeanDefinition("test", new RootBeanDefinition(TestBean.class, null));
320 lbf.registerBeanDefinition("test", new RootBeanDefinition(NestedTestBean.class, null));
321 assertTrue(lbf.getBean("test") instanceof NestedTestBean);
322 }
323
324 public void testBeanDefinitionOverridingNotAllowed() throws BeansException {
325 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
326 lbf.setAllowBeanDefinitionOverriding(false);
327 lbf.registerBeanDefinition("test", new RootBeanDefinition(TestBean.class, null));
328 try {
329 lbf.registerBeanDefinition("test", new RootBeanDefinition(NestedTestBean.class, null));
330 fail("Should have thrown BeanDefinitionStoreException");
331 }
332 catch (BeanDefinitionStoreException ex) {
333 assertEquals("test", ex.getBeanName());
334 }
336 }
337
338 public void testBeanReferenceWithNewSyntax() {
339 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
340 lbf = new DefaultListableBeanFactory();
341 Properties p = new Properties ();
342 p.setProperty("r.class", TestBean.class.getName());
343 p.setProperty("r.name", "rod");
344 p.setProperty("k.class", TestBean.class.getName());
345 p.setProperty("k.name", "kerry");
346 p.setProperty("k.spouse", "*r");
347 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
348 TestBean k = (TestBean) lbf.getBean("k");
349 TestBean r = (TestBean) lbf.getBean("r");
350 assertTrue(k.getSpouse() == r);
351 }
352
353 public void testCanEscapeBeanReferenceSyntax() {
354 String name = "*name";
355 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
356 lbf = new DefaultListableBeanFactory();
357 Properties p = new Properties ();
358 p.setProperty("r.class", TestBean.class.getName());
359 p.setProperty("r.name", "*" + name);
360 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
361 TestBean r = (TestBean) lbf.getBean("r");
362 assertTrue(r.getName().equals(name));
363 }
364
365 public void testCustomEditor() {
366 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
367 NumberFormat nf = NumberFormat.getInstance(Locale.UK);
368 lbf.registerCustomEditor(Float .class, new CustomNumberEditor(Float .class, nf, true));
369 MutablePropertyValues pvs = new MutablePropertyValues();
370 pvs.addPropertyValue("myFloat", "1.1");
371 lbf.registerBeanDefinition("testBean", new RootBeanDefinition(TestBean.class, pvs));
372 TestBean testBean = (TestBean) lbf.getBean("testBean");
373 assertTrue(testBean.getMyFloat().floatValue() == 1.1f);
375 }
376
377 public void testRegisterExistingSingletonWithReference() {
378 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
379 Properties p = new Properties ();
380 p.setProperty("test.class", "org.springframework.beans.TestBean");
381 p.setProperty("test.name", "Tony");
382 p.setProperty("test.age", "48");
383 p.setProperty("test.spouse(ref)", "singletonObject");
384 (new PropertiesBeanDefinitionReader(lbf)).registerBeanDefinitions(p);
385 Object singletonObject = new TestBean();
386 lbf.registerSingleton("singletonObject", singletonObject);
387
388 assertTrue(lbf.isSingleton("singletonObject"));
389 assertEquals(TestBean.class, lbf.getType("singletonObject"));
390 TestBean test = (TestBean) lbf.getBean("test");
391 assertEquals(singletonObject, lbf.getBean("singletonObject"));
392 assertEquals(singletonObject, test.getSpouse());
393
394 Map beansOfType = lbf.getBeansOfType(TestBean.class, false, true);
395 assertEquals(2, beansOfType.size());
396 assertTrue(beansOfType.containsValue(test));
397 assertTrue(beansOfType.containsValue(singletonObject));
398
399 beansOfType = lbf.getBeansOfType(null, false, true);
400 assertEquals(2, beansOfType.size());
401 }
402
403 public void testRegisterExistingSingletonWithAutowire() {
404 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
405 MutablePropertyValues pvs = new MutablePropertyValues();
406 pvs.addPropertyValue("name", "Tony");
407 pvs.addPropertyValue("age", "48");
408 RootBeanDefinition bd = new RootBeanDefinition(DependenciesBean.class, pvs, true);
409 bd.setDependencyCheck(RootBeanDefinition.DEPENDENCY_CHECK_OBJECTS);
410 bd.setAutowireMode(RootBeanDefinition.AUTOWIRE_BY_TYPE);
411 lbf.registerBeanDefinition("test", bd);
412 Object singletonObject = new TestBean();
413 lbf.registerSingleton("singletonObject", singletonObject);
414
415 assertTrue(lbf.containsBean("singletonObject"));
416 assertTrue(lbf.isSingleton("singletonObject"));
417 assertEquals(TestBean.class, lbf.getType("singletonObject"));
418 assertEquals(0, lbf.getAliases("singletonObject").length);
419 DependenciesBean test = (DependenciesBean) lbf.getBean("test");
420 assertEquals(singletonObject, lbf.getBean("singletonObject"));
421 assertEquals(singletonObject, test.getSpouse());
422 }
423
424 public void testRegisterExistingSingletonWithAlreadyBound() {
425 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
426 Object singletonObject = new TestBean();
427 lbf.registerSingleton("singletonObject", singletonObject);
428 try {
429 lbf.registerSingleton("singletonObject", singletonObject);
430 fail("Should have thrown BeanDefinitionStoreException");
431 }
432 catch (BeanDefinitionStoreException ex) {
433 }
435 }
436
437 public void testAutowireConstructor() {
438 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
439 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, new MutablePropertyValues());
440 lbf.registerBeanDefinition("spouse", bd);
441 ConstructorDependenciesBean bean =
442 (ConstructorDependenciesBean) lbf.autowire(
443 ConstructorDependenciesBean.class, AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, true);
444 Object spouse = lbf.getBean("spouse");
445 assertTrue(bean.getSpouse1() == spouse);
446 assertTrue(BeanFactoryUtils.beanOfType(lbf, TestBean.class) == spouse);
447 }
448
449 public void testAutowireBeanByName() {
450 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
451 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, new MutablePropertyValues());
452 lbf.registerBeanDefinition("spouse", bd);
453 DependenciesBean bean = (DependenciesBean)
454 lbf.autowire(DependenciesBean.class, AutowireCapableBeanFactory.AUTOWIRE_BY_NAME, true);
455 TestBean spouse = (TestBean) lbf.getBean("spouse");
456 assertEquals(bean.getSpouse(), spouse);
457 assertTrue(BeanFactoryUtils.beanOfType(lbf, TestBean.class) == spouse);
458 }
459
460 public void testAutowireBeanByNameWithDependencyCheck() {
461 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
462 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, new MutablePropertyValues());
463 lbf.registerBeanDefinition("spous", bd);
464 try {
465 lbf.autowire(DependenciesBean.class, AutowireCapableBeanFactory.AUTOWIRE_BY_NAME, true);
466 fail("Should have thrown UnsatisfiedDependencyException");
467 }
468 catch (UnsatisfiedDependencyException ex) {
469 }
471 }
472
473 public void testAutowireBeanByNameWithNoDependencyCheck() {
474 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
475 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, new MutablePropertyValues());
476 lbf.registerBeanDefinition("spous", bd);
477 DependenciesBean bean = (DependenciesBean)
478 lbf.autowire(DependenciesBean.class, AutowireCapableBeanFactory.AUTOWIRE_BY_NAME, false);
479 assertNull(bean.getSpouse());
480 }
481
482 public void testAutowireBeanByType() {
483 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
484 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, new MutablePropertyValues());
485 lbf.registerBeanDefinition("test", bd);
486 DependenciesBean bean = (DependenciesBean)
487 lbf.autowire(DependenciesBean.class, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, true);
488 TestBean test = (TestBean) lbf.getBean("test");
489 assertEquals(bean.getSpouse(), test);
490 }
491
492 public void testAutowireBeanByTypeWithDependencyCheck() {
493 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
494 try {
495 lbf.autowire(DependenciesBean.class, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, true);
496 fail("Should have thrown UnsatisfiedDependencyException");
497 }
498 catch (UnsatisfiedDependencyException ex) {
499 }
501 }
502
503 public void testAutowireBeanByTypeWithNoDependencyCheck() {
504 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
505 DependenciesBean bean = (DependenciesBean)
506 lbf.autowire(DependenciesBean.class, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false);
507 assertNull(bean.getSpouse());
508 }
509
510 public void testAutowireExistingBeanByName() {
511 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
512 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, new MutablePropertyValues());
513 lbf.registerBeanDefinition("spouse", bd);
514 DependenciesBean existingBean = new DependenciesBean();
515 lbf.autowireBeanProperties(existingBean, AutowireCapableBeanFactory.AUTOWIRE_BY_NAME, true);
516 TestBean spouse = (TestBean) lbf.getBean("spouse");
517 assertEquals(existingBean.getSpouse(), spouse);
518 assertTrue(BeanFactoryUtils.beanOfType(lbf, TestBean.class) == spouse);
519 }
520
521 public void testAutowireExistingBeanByNameWithDependencyCheck() {
522 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
523 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, new MutablePropertyValues());
524 lbf.registerBeanDefinition("spous", bd);
525 DependenciesBean existingBean = new DependenciesBean();
526 try {
527 lbf.autowireBeanProperties(existingBean, AutowireCapableBeanFactory.AUTOWIRE_BY_NAME, true);
528 fail("Should have thrown UnsatisfiedDependencyException");
529 }
530 catch (UnsatisfiedDependencyException ex) {
531 }
533 }
534
535 public void testAutowireExistingBeanByNameWithNoDependencyCheck() {
536 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
537 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, new MutablePropertyValues());
538 lbf.registerBeanDefinition("spous", bd);
539 DependenciesBean existingBean = new DependenciesBean();
540 lbf.autowireBeanProperties(existingBean, AutowireCapableBeanFactory.AUTOWIRE_BY_NAME, false);
541 assertNull(existingBean.getSpouse());
542 }
543
544 public void testAutowireExistingBeanByType() {
545 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
546 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, new MutablePropertyValues());
547 lbf.registerBeanDefinition("test", bd);
548 DependenciesBean existingBean = new DependenciesBean();
549 lbf.autowireBeanProperties(existingBean, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, true);
550 TestBean test = (TestBean) lbf.getBean("test");
551 assertEquals(existingBean.getSpouse(), test);
552 }
553
554 public void testAutowireExistingBeanByTypeWithDependencyCheck() {
555 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
556 DependenciesBean existingBean = new DependenciesBean();
557 try {
558 lbf.autowireBeanProperties(existingBean, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, true);
559 fail("Should have thrown UnsatisfiedDependencyException");
560 }
561 catch (UnsatisfiedDependencyException ex) {
562 }
564 }
565
566 public void testAutowireExistingBeanByTypeWithNoDependencyCheck() {
567 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
568 DependenciesBean existingBean = new DependenciesBean();
569 lbf.autowireBeanProperties(existingBean, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false);
570 assertNull(existingBean.getSpouse());
571 }
572
573 public void testInvalidAutowireMode() {
574 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
575 try {
576 lbf.autowireBeanProperties(new TestBean(), 0, false);
577 fail("Should have thrown IllegalArgumentException");
578 }
579 catch (IllegalArgumentException ex) {
580 }
582 }
583
584 public void testAutowireWithNoDependencies() {
585 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
586 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, new MutablePropertyValues());
587 lbf.registerBeanDefinition("rod", bd);
588 assertEquals(1, lbf.getBeanDefinitionCount());
589 Object registered = lbf.autowire(
590 NoDependencies.class, AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT, false);
591 assertEquals(1, lbf.getBeanDefinitionCount());
592 assertTrue(registered instanceof NoDependencies);
593 }
594
595 public void testAutowireWithSatisfiedJavaBeanDependency() {
596 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
597 MutablePropertyValues pvs = new MutablePropertyValues();
598 pvs.addPropertyValue(new PropertyValue("name", "Rod"));
599 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, pvs);
600 lbf.registerBeanDefinition("rod", bd);
601 assertEquals(1, lbf.getBeanDefinitionCount());
602 Object registered = lbf.autowire(
604 DependenciesBean.class, AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT, true);
605 assertEquals(1, lbf.getBeanDefinitionCount());
606 DependenciesBean kerry = (DependenciesBean) registered;
607 TestBean rod = (TestBean) lbf.getBean("rod");
608 assertSame(rod, kerry.getSpouse());
609 }
610
611 public void testAutowireWithSatisfiedConstructorDependency() {
612 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
613 MutablePropertyValues pvs = new MutablePropertyValues();
614 pvs.addPropertyValue(new PropertyValue("name", "Rod"));
615 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, pvs);
616 lbf.registerBeanDefinition("rod", bd);
617 assertEquals(1, lbf.getBeanDefinitionCount());
618 Object registered = lbf.autowire(
619 ConstructorDependency.class, AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT, false);
620 assertEquals(1, lbf.getBeanDefinitionCount());
621 ConstructorDependency kerry = (ConstructorDependency) registered;
622 TestBean rod = (TestBean) lbf.getBean("rod");
623 assertSame(rod, kerry.spouse);
624 }
625
626 public void testAutowireWithUnsatisfiedConstructorDependency() {
627 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
628 MutablePropertyValues pvs = new MutablePropertyValues();
629 pvs.addPropertyValue(new PropertyValue("name", "Rod"));
630 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, pvs);
631 lbf.registerBeanDefinition("rod", bd);
632 assertEquals(1, lbf.getBeanDefinitionCount());
633 try {
634 lbf.autowire(
635 UnsatisfiedConstructorDependency.class, AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT, true);
636 fail("Should have unsatisfied constructor dependency on SideEffectBean");
637 }
638 catch (UnsatisfiedDependencyException ex) {
639 }
641 }
642
643 public void testExtensiveCircularReference() {
644 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
645 for (int i = 0; i < 1000; i++) {
646 MutablePropertyValues pvs = new MutablePropertyValues();
647 pvs.addPropertyValue(new PropertyValue("spouse", new RuntimeBeanReference("bean" + (i < 99 ? i+1 : 0))));
648 RootBeanDefinition bd = new RootBeanDefinition(TestBean.class, pvs);
649 lbf.registerBeanDefinition("bean" + i, bd);
650 }
651 lbf.preInstantiateSingletons();
652 for (int i = 0; i < 1000; i++) {
653 TestBean bean = (TestBean) lbf.getBean("bean" + i);
654 TestBean otherBean = (TestBean) lbf.getBean("bean" + (i < 99 ? i+1 : 0));
655 assertTrue(bean.getSpouse() == otherBean);
656 }
657 }
658
659 public void testCircularReferenceThroughAutowiring() {
660 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
661 lbf.registerBeanDefinition("test", new RootBeanDefinition(
662 ConstructorDependencyBean.class, RootBeanDefinition.AUTOWIRE_CONSTRUCTOR));
663 try {
664 lbf.preInstantiateSingletons();
665 }
666 catch (UnsatisfiedDependencyException ex) {
667 }
669 }
670
671 public void testCircularReferenceThroughFactoryBeanAutowiring() {
672 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
673 lbf.registerBeanDefinition("test", new RootBeanDefinition(
674 ConstructorDependencyFactoryBean.class, RootBeanDefinition.AUTOWIRE_CONSTRUCTOR));
675 try {
676 lbf.preInstantiateSingletons();
677 }
678 catch (UnsatisfiedDependencyException ex) {
679 }
681 }
682
683 public void testAvoidCircularReferenceThroughAutowiring() {
684 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
685 lbf.registerBeanDefinition("test", new RootBeanDefinition(
686 ConstructorDependencyFactoryBean.class, RootBeanDefinition.AUTOWIRE_CONSTRUCTOR));
687 lbf.registerBeanDefinition("string",
688 new RootBeanDefinition(String .class, RootBeanDefinition.AUTOWIRE_CONSTRUCTOR));
689 lbf.preInstantiateSingletons();
690 }
691
692 public void testApplyPropertyValues() {
693 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
694 MutablePropertyValues pvs = new MutablePropertyValues();
695 pvs.addPropertyValue("age", "99");
696 lbf.registerBeanDefinition("test", new RootBeanDefinition(TestBean.class, pvs));
697 TestBean tb = new TestBean();
698 assertEquals(0, tb.getAge());
699 lbf.applyBeanPropertyValues(tb, "test");
700 assertEquals(99, tb.getAge());
701 }
702
703 public void testApplyPropertyValuesWithIncompleteDefinition() {
704 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
705 MutablePropertyValues pvs = new MutablePropertyValues();
706 pvs.addPropertyValue("age", "99");
707 lbf.registerBeanDefinition("test", new RootBeanDefinition(null, pvs));
708 TestBean tb = new TestBean();
709 assertEquals(0, tb.getAge());
710 lbf.applyBeanPropertyValues(tb, "test");
711 assertEquals(99, tb.getAge());
712 }
713
714 public void testBeanDefinitionWithInterface() {
715 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
716 lbf.registerBeanDefinition("test", new RootBeanDefinition(ITestBean.class, null));
717 try {
718 lbf.getBean("test");
719 fail("Should have thrown BeanCreationException");
720 }
721 catch (BeanCreationException ex) {
722 assertEquals("test", ex.getBeanName());
723 assertTrue(ex.getMessage().toLowerCase().indexOf("interface") != -1);
724 }
725 }
726
727 public void testBeanDefinitionWithAbstractClass() {
728 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
729 lbf.registerBeanDefinition("test", new RootBeanDefinition(AbstractBeanFactory.class, null));
730 try {
731 lbf.getBean("test");
732 fail("Should have thrown BeanCreationException");
733 }
734 catch (BeanCreationException ex) {
735 assertEquals("test", ex.getBeanName());
736 assertTrue(ex.getMessage().toLowerCase().indexOf("abstract") != -1);
737 }
738 }
739
740 public void testBeanPostProcessorWithWrappedObjectAndDisposableBean() {
741 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
742 RootBeanDefinition bd = new RootBeanDefinition(BeanWithDisposableBean.class, null);
743 lbf.registerBeanDefinition("test", bd);
744 lbf.addBeanPostProcessor(new BeanPostProcessor() {
745 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
746 return new TestBean();
747 }
748 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
749 return bean;
750 }
751 });
752 BeanWithDisposableBean.closed = false;
753 lbf.preInstantiateSingletons();
754 lbf.destroySingletons();
755 assertTrue("Destroy method invoked", BeanWithDisposableBean.closed);
756 }
757
758 public void testBeanPostProcessorWithWrappedObjectAndDestroyMethod() {
759 DefaultListableBeanFactory lbf = new DefaultListableBeanFactory();
760 RootBeanDefinition bd = new RootBeanDefinition(BeanWithDestroyMethod.class, null);
761 bd.setDestroyMethodName("close");
762 lbf.registerBeanDefinition("test", bd);
763 lbf.addBeanPostProcessor(new BeanPostProcessor() {
764 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
765 return new TestBean();
766 }
767 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
768 return bean;
769 }
770 });
771 BeanWithDestroyMethod.closed = false;
772 lbf.preInstantiateSingletons();
773 lbf.destroySingletons();
774 assertTrue("Destroy method invoked", BeanWithDestroyMethod.closed);
775 }
776
777
778 public static class NoDependencies {
779
780 private NoDependencies() {
781 }
782 }
783
784
785 public static class ConstructorDependency {
786
787 public TestBean spouse;
788
789 public ConstructorDependency(TestBean spouse) {
790 this.spouse = spouse;
791 }
792
793 private ConstructorDependency(TestBean spouse, TestBean otherSpouse) {
794 throw new IllegalArgumentException ("Should never be called");
795 }
796 }
797
798
799 public static class UnsatisfiedConstructorDependency {
800
801 public UnsatisfiedConstructorDependency(TestBean t, SideEffectBean b) {
802 }
803 }
804
805
806 public static class ConstructorDependencyBean {
807
808 public ConstructorDependencyBean(ConstructorDependencyBean dependency) {
809 }
810 }
811
812
813 public static class ConstructorDependencyFactoryBean implements FactoryBean {
814
815 public ConstructorDependencyFactoryBean(String dependency) {
816 }
817
818 public Object getObject() throws Exception {
819 return "test";
820 }
821
822 public Class getObjectType() {
823 return String .class;
824 }
825
826 public boolean isSingleton() {
827 return true;
828 }
829 }
830
831
832 public static class BeanWithDisposableBean implements DisposableBean {
833
834 private static boolean closed;
835
836 public void destroy() {
837 closed = true;
838 }
839 }
840
841
842 public static class BeanWithDestroyMethod {
843
844 private static boolean closed;
845
846 public void close() {
847 closed = true;
848 }
849 }
850
851 }
852 |
Popular Tags |
Java API By Example, From Geeks To Geeks.