Refine search
@Override protected void addPersistenceExceptionTranslation(ProxyFactory pf, PersistenceExceptionTranslator pet) { if (AnnotationUtils.findAnnotation(pf.getTargetClass(), Repository.class) != null) { DefaultListableBeanFactory bf = new DefaultListableBeanFactory(); bf.registerBeanDefinition("peti", new RootBeanDefinition(PersistenceExceptionTranslationInterceptor.class)); bf.registerSingleton("pet", pet); pf.addAdvice((PersistenceExceptionTranslationInterceptor) bf.getBean("peti")); } }
@Test public void parameterizedInstanceFactoryMethodWithIndexedArgument() { DefaultListableBeanFactory bf = new DefaultListableBeanFactory(); RootBeanDefinition rbd = new RootBeanDefinition(MocksControl.class); bf.registerBeanDefinition("mocksControl", rbd); rbd = new RootBeanDefinition(); rbd.setFactoryBeanName("mocksControl"); rbd.setFactoryMethodName("createMock"); rbd.getConstructorArgumentValues().addIndexedArgumentValue(0, Runnable.class); bf.registerBeanDefinition("mock", rbd); assertTrue(bf.isTypeMatch("mock", Runnable.class)); assertTrue(bf.isTypeMatch("mock", Runnable.class)); assertEquals(Runnable.class, bf.getType("mock")); assertEquals(Runnable.class, bf.getType("mock")); Map<String, Runnable> beans = bf.getBeansOfType(Runnable.class); assertEquals(1, beans.size()); }
private AbstractBeanDefinition beanDef(Class<?> configClass) { DefaultListableBeanFactory factory = new DefaultListableBeanFactory(); factory.registerBeanDefinition("config", new RootBeanDefinition(configClass)); ConfigurationClassPostProcessor pp = new ConfigurationClassPostProcessor(); pp.postProcessBeanFactory(factory); return (AbstractBeanDefinition) factory.getBeanDefinition("foo"); }
@Override public String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType) { List<String> result = new ArrayList<>(); for (String beanName : this.beanDefinitionNames) { BeanDefinition beanDefinition = getBeanDefinition(beanName); if (!beanDefinition.isAbstract() && findAnnotationOnBean(beanName, annotationType) != null) { result.add(beanName); } } for (String beanName : this.manualSingletonNames) { if (!result.contains(beanName) && findAnnotationOnBean(beanName, annotationType) != null) { result.add(beanName); } } return StringUtils.toStringArray(result); }
@Override @SuppressWarnings("unchecked") public <T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit) throws BeansException { String[] beanNames = getBeanNamesForType(type, includeNonSingletons, allowEagerInit); Map<String, T> result = new LinkedHashMap<>(beanNames.length); for (String beanName : beanNames) { try { Object beanInstance = getBean(beanName); if (!(beanInstance instanceof NullBean)) { result.put(beanName, (T) beanInstance); BeanCreationException bce = (BeanCreationException) rootCause; String exBeanName = bce.getBeanName(); if (exBeanName != null && isCurrentlyInCreation(exBeanName)) { if (logger.isTraceEnabled()) { logger.trace("Ignoring match to currently created bean '" + exBeanName + "': " + ex.getMessage()); onSuppressedException(ex);
@Test public void testBeanDefinitionOverriding() { DefaultListableBeanFactory lbf = new DefaultListableBeanFactory(); lbf.registerBeanDefinition("test", new RootBeanDefinition(TestBean.class)); lbf.registerBeanDefinition("test", new RootBeanDefinition(NestedTestBean.class)); lbf.registerAlias("otherTest", "test2"); lbf.registerAlias("test", "test2"); assertTrue(lbf.getBean("test") instanceof NestedTestBean); assertTrue(lbf.getBean("test2") instanceof NestedTestBean); }
@Test public void testStaticFactoryMethodFoundByNonEagerTypeMatching() { DefaultListableBeanFactory lbf = new DefaultListableBeanFactory(); RootBeanDefinition rbd = new RootBeanDefinition(TestBeanFactory.class); rbd.setFactoryMethodName("createTestBean"); lbf.registerBeanDefinition("x1", rbd); TestBeanFactory.initialized = false; String[] beanNames = lbf.getBeanNamesForType(TestBean.class, true, false); assertEquals(1, beanNames.length); assertEquals("x1", beanNames[0]); assertFalse(lbf.containsSingleton("x1")); assertTrue(lbf.containsBean("x1")); assertFalse(lbf.containsBean("&x1")); assertTrue(lbf.isSingleton("x1")); assertFalse(lbf.isSingleton("&x1")); assertFalse(lbf.isPrototype("x1")); assertFalse(lbf.isPrototype("&x1")); assertTrue(lbf.isTypeMatch("x1", TestBean.class)); assertFalse(lbf.isTypeMatch("&x1", TestBean.class)); assertEquals(TestBean.class, lbf.getType("x1")); assertEquals(null, lbf.getType("&x1")); assertFalse(TestBeanFactory.initialized); }
@Test public void byTypeAutowireWithPrimaryInParentFactory() throws Exception { CountingFactory.reset(); DefaultListableBeanFactory parent = getBeanFactory("autowire-with-exclusion.xml"); parent.getBeanDefinition("props1").setPrimary(true); parent.preInstantiateSingletons(); DefaultListableBeanFactory child = new DefaultListableBeanFactory(parent); RootBeanDefinition robDef = new RootBeanDefinition(TestBean.class); robDef.setAutowireMode(RootBeanDefinition.AUTOWIRE_BY_TYPE); robDef.getPropertyValues().add("spouse", new RuntimeBeanReference("sally")); child.registerBeanDefinition("rob2", robDef); RootBeanDefinition propsDef = new RootBeanDefinition(PropertiesFactoryBean.class); propsDef.getPropertyValues().add("properties", "name=props3"); child.registerBeanDefinition("props3", propsDef); TestBean rob = (TestBean) child.getBean("rob2"); assertEquals("props1", rob.getSomeProperties().getProperty("name")); assertEquals(1, CountingFactory.getFactoryBeanInstanceCount()); }
@Test public void testServiceLoaderFactoryBean() { assumeTrue(ServiceLoader.load(DocumentBuilderFactory.class).iterator().hasNext()); DefaultListableBeanFactory bf = new DefaultListableBeanFactory(); RootBeanDefinition bd = new RootBeanDefinition(ServiceLoaderFactoryBean.class); bd.getPropertyValues().add("serviceType", DocumentBuilderFactory.class.getName()); bf.registerBeanDefinition("service", bd); ServiceLoader<?> serviceLoader = (ServiceLoader<?>) bf.getBean("service"); assertTrue(serviceLoader.iterator().next() instanceof DocumentBuilderFactory); }
@Test public void testLazyInitFactory() { DefaultListableBeanFactory lbf = new DefaultListableBeanFactory(); lbf.registerBeanDefinition("test", new RootBeanDefinition(LazyInitFactory.class)); lbf.preInstantiateSingletons(); LazyInitFactory factory = (LazyInitFactory) lbf.getBean("&test"); assertFalse(factory.initialized); }
@Test public void testAutowireBeanByTypeWithTwoMatchesAndPriority() { DefaultListableBeanFactory lbf = new DefaultListableBeanFactory(); lbf.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE); RootBeanDefinition bd = new RootBeanDefinition(HighPriorityTestBean.class); RootBeanDefinition bd2 = new RootBeanDefinition(LowPriorityTestBean.class); lbf.registerBeanDefinition("test", bd); lbf.registerBeanDefinition("spouse", bd2); DependenciesBean bean = (DependenciesBean) lbf.autowire(DependenciesBean.class, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, true); assertThat(bean.getSpouse(), equalTo(lbf.getBean("test"))); }
@Test public void testRegisterExistingSingletonWithAutowire() { DefaultListableBeanFactory lbf = new DefaultListableBeanFactory(); MutablePropertyValues pvs = new MutablePropertyValues(); pvs.add("name", "Tony"); pvs.add("age", "48"); RootBeanDefinition bd = new RootBeanDefinition(DependenciesBean.class); bd.setPropertyValues(pvs); bd.setDependencyCheck(RootBeanDefinition.DEPENDENCY_CHECK_OBJECTS); bd.setAutowireMode(RootBeanDefinition.AUTOWIRE_BY_TYPE); lbf.registerBeanDefinition("test", bd); Object singletonObject = new TestBean(); lbf.registerSingleton("singletonObject", singletonObject); assertTrue(lbf.containsBean("singletonObject")); assertTrue(lbf.isSingleton("singletonObject")); assertEquals(TestBean.class, lbf.getType("singletonObject")); assertEquals(0, lbf.getAliases("singletonObject").length); DependenciesBean test = (DependenciesBean) lbf.getBean("test"); assertEquals(singletonObject, lbf.getBean("singletonObject")); assertEquals(singletonObject, test.getSpouse()); }
@Test public void testNonStaticPrototypeFactoryMethodFoundByNonEagerTypeMatching() { DefaultListableBeanFactory lbf = new DefaultListableBeanFactory(); RootBeanDefinition factoryBd = new RootBeanDefinition(TestBeanFactory.class); lbf.registerBeanDefinition("factory", factoryBd); RootBeanDefinition rbd = new RootBeanDefinition(); rbd.setFactoryBeanName("factory"); lbf.registerBeanDefinition("x1", rbd); String[] beanNames = lbf.getBeanNamesForType(TestBean.class, true, false); assertEquals(1, beanNames.length); assertEquals("x1", beanNames[0]); assertFalse(lbf.containsSingleton("x1")); assertTrue(lbf.containsBean("x1")); assertFalse(lbf.containsBean("&x1")); assertTrue(lbf.containsLocalBean("x1")); assertFalse(lbf.containsLocalBean("&x1")); assertFalse(lbf.isSingleton("x1")); assertFalse(lbf.isSingleton("&x1")); assertTrue(lbf.isPrototype("x1")); assertFalse(lbf.isPrototype("&x1")); assertTrue(lbf.isTypeMatch("x1", TestBean.class)); assertFalse(lbf.isTypeMatch("&x1", TestBean.class)); assertTrue(lbf.isTypeMatch("x1", Object.class)); assertFalse(lbf.isTypeMatch("&x1", Object.class)); assertEquals(TestBean.class, lbf.getType("x1")); assertEquals(null, lbf.getType("&x1")); assertFalse(TestBeanFactory.initialized);
@SuppressWarnings("unchecked") @Nullable private <T> NamedBeanHolder<T> resolveNamedBean( ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) throws BeansException { String[] candidateNames = getBeanNamesForType(requiredType); if (!containsBeanDefinition(beanName) || getBeanDefinition(beanName).isAutowireCandidate()) { autowireCandidates.add(beanName); return new NamedBeanHolder<>(beanName, (T) getBean(beanName, requiredType.toClass(), args)); if (containsSingleton(beanName) && args == null) { Object beanInstance = getBean(beanName); candidates.put(beanName, (beanInstance instanceof NullBean ? null : beanInstance)); candidates.put(beanName, getType(beanName)); String candidateName = determinePrimaryCandidate(candidates, requiredType.toClass()); if (candidateName == null) { candidateName = determineHighestPriorityCandidate(candidates, requiredType.toClass()); beanInstance = getBean(candidateName, requiredType.toClass(), args);
@Test public void testNonPublicEnum() { DefaultListableBeanFactory bf = new DefaultListableBeanFactory(); RootBeanDefinition bd = new RootBeanDefinition(NonPublicEnumHolder.class); bd.getConstructorArgumentValues().addGenericArgumentValue("VALUE_1"); bf.registerBeanDefinition("holderBean", bd); NonPublicEnumHolder holder = (NonPublicEnumHolder) bf.getBean("holderBean"); assertEquals(NonPublicEnum.VALUE_1, holder.getNonPublicEnum()); }
if (!this.scriptBeanFactory.containsBeanDefinition(scriptedObjectBeanName)) { this.scriptBeanFactory.registerBeanDefinition( scriptFactoryBeanName, createScriptFactoryBeanDefinition(bd)); ScriptFactory scriptFactory = this.scriptBeanFactory.getBean(scriptFactoryBeanName, ScriptFactory.class); ScriptSource scriptSource = getScriptSource(scriptFactoryBeanName, scriptFactory.getScriptSourceLocator()); if (scriptFactory.requiresConfigInterface() && !bd.getPropertyValues().isEmpty()) { Class<?> configInterface = createConfigInterface(bd, interfaces); scriptedInterfaces = ObjectUtils.addObjectToArray(interfaces, configInterface); long refreshCheckDelay = resolveRefreshCheckDelay(bd); if (refreshCheckDelay >= 0) { objectBd.setScope(BeanDefinition.SCOPE_PROTOTYPE); this.scriptBeanFactory.registerBeanDefinition(scriptedObjectBeanName, objectBd);
@Test public void emptyJavaUtilOptionalBean() { DefaultListableBeanFactory bf = new DefaultListableBeanFactory(); RootBeanDefinition bd = new RootBeanDefinition(Optional.class); bd.setFactoryMethodName("empty"); bf.registerBeanDefinition("optionalBean", bd); assertSame(Optional.empty(), bf.getBean(Optional.class)); }
@Test public void testScopeInheritanceForChildBeanDefinitions() { RootBeanDefinition parent = new RootBeanDefinition(); parent.setScope("bonanza!"); AbstractBeanDefinition child = new ChildBeanDefinition("parent"); child.setBeanClass(TestBean.class); DefaultListableBeanFactory factory = new DefaultListableBeanFactory(); factory.registerBeanDefinition("parent", parent); factory.registerBeanDefinition("child", child); BeanDefinition def = factory.getMergedBeanDefinition("child"); assertEquals("Child 'scope' not inherited", "bonanza!", def.getScope()); }
@Override @Nullable public Class<?> predictBeanType(Class<?> beanClass, String beanName) { prepareScriptBeans(bd, scriptFactoryBeanName, scriptedObjectBeanName); ScriptFactory scriptFactory = this.scriptBeanFactory.getBean(scriptFactoryBeanName, ScriptFactory.class); ScriptSource scriptSource = getScriptSource(scriptFactoryBeanName, scriptFactory.getScriptSourceLocator()); Class<?>[] interfaces = scriptFactory.getScriptInterfaces(); if (bd.isSingleton()) { return this.scriptBeanFactory.getBean(scriptedObjectBeanName).getClass();
/** * Tests support for parameterized static {@code factory-method} declarations such as * Mockito's {@code mock()} method which has the following signature. * <pre> * {@code * public static <T> T mock(Class<T> classToMock) * } * </pre> * <p>See SPR-9493 */ @Test public void parameterizedStaticFactoryMethod() { RootBeanDefinition rbd = new RootBeanDefinition(Mockito.class); rbd.setFactoryMethodName("mock"); rbd.getConstructorArgumentValues().addGenericArgumentValue(Runnable.class); DefaultListableBeanFactory bf = new DefaultListableBeanFactory(); bf.registerBeanDefinition("mock", rbd); assertEquals(Runnable.class, bf.getType("mock")); assertEquals(Runnable.class, bf.getType("mock")); Map<String, Runnable> beans = bf.getBeansOfType(Runnable.class); assertEquals(1, beans.size()); }