|
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 |
Java API By Example, From Geeks To Geeks.