@Override public Object get() throws BeansException { return this.beanFactory.getBean(this.targetBeanName); } }
@Override public Object getObject() { if (this.proxy == null) { throw new FactoryBeanNotInitializedException(); } return this.proxy; }
/** * Set the {@code BeanFactory} to be used when looking up executors by qualifier. */ @Override public void setBeanFactory(BeanFactory beanFactory) { if (this.advice instanceof BeanFactoryAware) { ((BeanFactoryAware) this.advice).setBeanFactory(beanFactory); } }
@Override public boolean containsBean(String name) { String beanName = transformedBeanName(name); if (containsSingleton(beanName) || containsBeanDefinition(beanName)) { return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(name)); } // Not found -> check parent. BeanFactory parentBeanFactory = getParentBeanFactory(); return (parentBeanFactory != null && parentBeanFactory.containsBean(originalBeanName(name))); }
@Override public Object get(String name, ObjectFactory<?> objectFactory) { scopeCount++; return objectFactory.getObject(); }
/** * Return all bean names in the factory, including ancestor factories. * @param lbf the bean factory * @return the array of matching bean names, or an empty array if none * @see #beanNamesForTypeIncludingAncestors */ public static String[] beanNamesIncludingAncestors(ListableBeanFactory lbf) { return beanNamesForTypeIncludingAncestors(lbf, Object.class); }
@Override public void afterPropertiesSet() throws Exception { for (ViewResolver viewResolver : this.viewResolvers) { if (viewResolver instanceof InitializingBean) { ((InitializingBean) viewResolver).afterPropertiesSet(); } } }
@Override public T getObject() throws BeansException { T resolved = resolveBean(requiredType, null, false); if (resolved == null) { throw new NoSuchBeanDefinitionException(requiredType); } return resolved; } @Override
@Override public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException { if (bean instanceof BeanNameAware) { ((BeanNameAware) bean).setBeanName(null); } }
/** * Count all beans in any hierarchy in which this factory participates. * Includes counts of ancestor bean factories. * <p>Beans that are "overridden" (specified in a descendant factory * with the same name) are only counted once. * @param lbf the bean factory * @return count of beans including those defined in ancestor factories * @see #beanNamesIncludingAncestors */ public static int countBeansIncludingAncestors(ListableBeanFactory lbf) { return beanNamesIncludingAncestors(lbf).length; }
/** * Create a new BeanCreationException. * @param beanName the name of the bean requested * @param msg the detail message * @param cause the root cause */ public BeanCreationException(String beanName, String msg, Throwable cause) { this(beanName, msg); initCause(cause); }
@Override public boolean equals(Object other) { if (this == other) { return true; } if (!super.equals(other)) { return false; } DependencyDescriptor otherDesc = (DependencyDescriptor) other; return (this.required == otherDesc.required && this.eager == otherDesc.eager && this.nestingLevel == otherDesc.nestingLevel && this.containingClass == otherDesc.containingClass); }
@Override public Object resolveShortcut(BeanFactory beanFactory) { return beanFactory.getBean(this.shortcut, this.requiredType); } }
@Override public Object get(String name, ObjectFactory<?> objectFactory) { return objectFactory.getObject(); } @Override
@Override public T getObject(Object... args) throws BeansException { T resolved = resolveBean(requiredType, args, false); if (resolved == null) { throw new NoSuchBeanDefinitionException(requiredType); } return resolved; } @Override
@Override public Object getObject() { if (this.proxy == null) { throw new FactoryBeanNotInitializedException(); } return this.proxy; }
@Override public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) { return beanFactory.getBean(beanName, args); } };
@Override public Object getObject() throws BeansException { return this.beanFactory.getBean(this.targetBeanName); } }
/** * A template method that subclasses may override to provide a * fresh target object for the given bean factory and bean name. * <p>This default implementation fetches a new target bean * instance from the bean factory. * @see org.springframework.beans.factory.BeanFactory#getBean */ protected Object obtainFreshBean(BeanFactory beanFactory, String beanName) { return beanFactory.getBean(beanName); }
@Override public T getObject() { if (instance == null) { instance = beanFactory.getBean(instanceName, type); } return instance; }