同步操作将从 xuchengsheng/spring-reading 强制同步,此操作会覆盖自 Fork 仓库以来所做的任何修改,且无法恢复!!!
确定后同步将在后台操作,完成时将刷新页面,请耐心等待。
✒️ 作者 - Lex 📝 博客 - 掘金 📚 源码地址 - github
ListableBeanFactory
接口是 Spring 框架中的一个子接口,扩展了 BeanFactory
,用于表示能够以列表形式获取 bean 定义的容器。它提供了方法来检索容器中所有 bean 的数量、名称,以及按类型或注解过滤的 bean 实例。通过这个接口,我们可以方便地获取有关容器中 bean 的信息,如动态查找 bean 名称、按类型检索 bean 实例等,为运行时动态管理和处理 bean 提供了灵活性和便利性。
获取 Bean 定义数量
获取所有 Bean 的名称
按类型获取 Bean 的名称
按类型获取 Bean 实例
按注解获取 Bean 实例
/**
* {@link BeanFactory}接口的扩展,由可以枚举其所有bean实例而不是按名称一个个查找bean的工厂实现。
* 预加载所有bean定义(例如基于XML的工厂)的BeanFactory可以实现此接口。
*
* <p>如果这是一个{@link HierarchicalBeanFactory},返回值将<i>不会</i>考虑任何BeanFactory层次结构,
* 而只会与当前工厂中定义的bean相关联。使用{@link BeanFactoryUtils}助手类来考虑祖先工厂中的bean。
*
* <p>此接口中的方法只会尊重此工厂的bean定义。它们将忽略通过其他手段注册的任何单例bean,
* 例如{@link org.springframework.beans.factory.config.ConfigurableBeanFactory}的
* {@code registerSingleton}方法,但 {@code getBeanNamesForType} 和 {@code getBeansOfType}
* 将检查这样手动注册的单例。当然,BeanFactory的 {@code getBean} 也允许透明访问这样的特殊bean。
* 但是,在典型情况下,所有bean都将由外部bean定义来定义,因此大多数应用程序不需要担心这种区分。
*
* <p><b>注意:</b>除了 {@code getBeanDefinitionCount} 和 {@code containsBeanDefinition},
* 此接口中的方法并非设计用于频繁调用。实现可能会很慢。
*
* @author Rod Johnson
* @author Juergen Hoeller
* @since 2001年4月16日
* @see HierarchicalBeanFactory
* @see BeanFactoryUtils
*/
public interface ListableBeanFactory extends BeanFactory {
/**
* 检查此bean工厂是否包含给定名称的bean定义。
* <p>不考虑此工厂可能参与的任何层次结构,并忽略通过bean定义之外的其他手段注册的任何单例bean。
* @param beanName 要查找的bean的名称
* @return 如果此bean工厂包含给定名称的bean定义,则为true
* @see #containsBean
*/
boolean containsBeanDefinition(String beanName);
/**
* 返回工厂中定义的bean的数量。
* <p>不考虑此工厂可能参与的任何层次结构,并忽略通过bean定义之外的其他手段注册的任何单例bean。
* @return 工厂中定义的bean的数量
*/
int getBeanDefinitionCount();
/**
* 返回此工厂中定义的所有bean的名称。
* <p>不考虑此工厂可能参与的任何层次结构,并忽略通过bean定义之外的其他手段注册的任何单例bean。
* @return 此工厂中定义的所有bean的名称,如果没有定义,则为空数组
*/
String[] getBeanDefinitionNames();
/**
* 返回指定bean的提供程序,允许按需延迟检索实例,包括可用性和唯一性选项。
* @param requiredType bean必须匹配的类型;可以是接口或超类
* @param allowEagerInit 是否允许基于流的访问初始化<i>懒加载单例</i>和<i>由FactoryBeans创建的对象</i>
* (或通过带有 "factory-bean" 引用的工厂方法创建的对象)进行类型检查
* @return 相应的提供程序处理
* @since 5.3
* @see #getBeanProvider(ResolvableType, boolean)
* @see #getBeanProvider(Class)
* @see #getBeansOfType(Class, boolean, boolean)
* @see #getBeanNamesForType(Class, boolean, boolean)
*/
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType, boolean allowEagerInit);
/**
* 返回指定bean的提供程序,允许按需延迟检索实例,包括可用性和唯一性选项。
* @param requiredType bean必须匹配的类型;可以是泛型类型声明。
* 请注意,此处不支持集合类型,与反射注入点形成对比。要以编程方式检索匹配特定类型的bean列表,请在此处指定实际的bean类型,
* 然后随后使用{@link ObjectProvider#orderedStream()}或其延迟流/迭代选项。
* @param allowEagerInit 是否允许基于流的访问初始化<i>懒加载单例</i>和<i>由FactoryBeans创建的对象</i>
* (或通过带有 "factory-bean" 引用的工厂方法创建的对象)进行类型检查
* @return 相应的提供程序处理
* @since 5.3
* @see #getBeanProvider(ResolvableType)
* @see ObjectProvider#iterator()
* @see ObjectProvider#stream()
* @see ObjectProvider#orderedStream()
* @see #getBeanNamesForType(ResolvableType, boolean, boolean)
*/
<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType, boolean allowEagerInit);
/**
* 返回使用提供的{@link Annotation}类型进行注释的所有bean的名称,而不会实际创建相应的bean实例。
* <p>请注意,此方法会考虑由FactoryBeans创建的对象,这意味着将初始化FactoryBeans以确定其对象类型。
* @param annotationType 要查找的注释类型
* (在指定bean的类、接口或工厂方法级别)
* @return 所有匹配的bean的名称
* @since 4.0
* @see #findAnnotationOnBean
*/
String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
/**
* 查找使用提供的{@link Annotation}类型进行注释的所有bean,返回具有相应的bean名称和相应bean实例的Map。
* <p>请注意,此方法会考虑由FactoryBeans创建的对象,这意味着将初始化FactoryBeans以确定其对象类型。
* @param annotationType 要查找的注释类型
* (在指定bean的类、接口或工厂方法级别)
* @return 包含匹配bean的Map,其中包含bean名称作为键和相应的bean实例作为值
* @throws BeansException 如果无法创建bean
* @since 3.0
* @see #findAnnotationOnBean
*/
Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
/**
* 在指定的bean上查找{@code annotationType}的{@link Annotation},
* 遍历其接口和超类如果在给定类本身上找不到注释,则检查bean的工厂方法(如果有的话)。
* @param beanName 要查找注释的bean的名称
* @param annotationType 要查找的注释类型
* (在指定bean的类、接口或工厂方法级别)
* @return 如果找到给定类型的注释,则为该注释;否则为{@code null}
* @throws NoSuchBeanDefinitionException 如果没有给定名称的bean
* @since 3.0
* @see #getBeanNamesForAnnotation
* @see #getBeansWithAnnotation
*/
@Nullable
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
throws NoSuchBeanDefinitionException;
/**
* 返回使用提供的{@link Annotation}类型进行注释的所有bean的名称,
* 返回具有相应的bean名称和相应bean实例的Map。
* <p>请注意,此方法会考虑由FactoryBeans创建的对象,这意味着将初始化FactoryBeans以确定其对象类型。
* @param annotationType 要查找的注释类型
* (在指定bean的类、接口或工厂方法级别)
* @return 包含匹配bean的Map,其中包含bean名称作为键和相应的bean实例作为值
* @throws BeansException 如果无法创建bean
* @since 3.0
* @see #findAnnotationOnBean
*/
Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
/**
* 在指定的bean上查找{@code annotationType}的{@link Annotation},
* 遍历其接口和超类如果在给定类本身上找不到注释,则检查bean的工厂方法(如果有的话)。
* @param beanName 要查找注释的bean的名称
* @param annotationType 要查找的注释类型
* (在指定bean的类、接口或工厂方法级别)
* @return 如果找到给定类型的注释,则为该注释;否则为{@code null}
* @throws NoSuchBeanDefinitionException 如果没有给定名称的bean
* @since 3.0
* @see #getBeanNamesForAnnotation
* @see #getBeansWithAnnotation
*/
@Nullable
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
throws NoSuchBeanDefinitionException;
/**
* 返回与给定对象类型(包括子类)匹配的所有bean的名称,从bean定义或FactoryBeans的{@code getObjectType}的值判断。
* <p><b>注意:此方法仅内省顶级bean。</b>它不会检查可能也匹配指定类型的嵌套bean。
* <p>如果FactoryBeans创建的对象符合条件,它将得到初始化。如果FactoryBean创建的对象不匹配,
* 则原始FactoryBean本身将与类型匹配。
* <p>不考虑此工厂可能参与的任何层次结构。使用BeanFactoryUtils的{@code beanNamesForTypeIncludingAncestors}
* 将祖先工厂中的bean包括在内。
* <p>注意:不会忽略通过bean定义之外的其他手段注册的任何单例bean。
* <p>此版本的{@code getBeanNamesForType}匹配所有类型的bean,无论是单例、原型还是FactoryBeans。
* 在大多数实现中,结果与{@code getBeanNamesForType(type, true, true)}相同。
* <p>此方法返回的bean名称应始终尽可能以后端配置中的<i>定义顺序</i>返回bean名称。
* @param type 要匹配的泛型类型或接口
* @return 匹配的对象类型(包括子类)的所有bean的名称,如果没有则为空数组
* @since 4.2
* @see #isTypeMatch(String, ResolvableType)
* @see FactoryBean#getObjectType
* @see BeanFactoryUtils#beanNamesForTypeIncludingAncestors(ListableBeanFactory, ResolvableType)
*/
String[] getBeanNamesForType(ResolvableType type);
/**
* 根据给定的类型(包括子类),从bean定义或FactoryBeans的{@code getObjectType}的值判断,返回匹配的bean的名称数组。
* <p><b>注意:此方法仅内省顶级bean。</b>它不检查可能与指定类型匹配的嵌套bean。
* <p>如果设置了“allowEagerInit”标志,会考虑由FactoryBeans创建的对象,这意味着FactoryBeans将被初始化。
* 如果由FactoryBean创建的对象不匹配,则原始FactoryBean本身将与类型匹配。
* 如果未设置“allowEagerInit”,则仅检查原始FactoryBeans(这不需要初始化每个FactoryBean)。
* <p>不考虑此工厂可能参与的任何层次结构。
* 使用BeanFactoryUtils的{@code beanNamesForTypeIncludingAncestors}以包括祖先工厂中的bean。
* <p>注意:不会忽略以非bean定义的方式注册的单例bean。
* <p>此方法返回的bean名称数组应尽可能以后端配置中<i>定义的顺序</i>返回bean名称。
*
* @param type 要匹配的泛型类型或接口
* @param includeNonSingletons 是否包括原型或作用域bean,或仅包括单例(也适用于FactoryBeans)
* @param allowEagerInit 是否初始化<i>延迟初始化的单例</i>和
* <i>由FactoryBeans创建的对象</i>(或带有
* "factory-bean"引用的工厂方法)以进行类型检查。
* 请注意,需要急切地初始化FactoryBeans和"factory-bean"引用,因此
* 请注意,为此标志传递“true”将初始化FactoryBeans和“factory-bean”引用。
* @return 匹配给定对象类型(包括子类)的bean的名称数组,如果没有则为空数组
* @since 5.2
* @see FactoryBean#getObjectType
* @see BeanFactoryUtils#beanNamesForTypeIncludingAncestors(ListableBeanFactory, ResolvableType, boolean, boolean)
*/
String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit);
/**
* 根据给定类型(包括子类)返回匹配的bean的名称数组,根据bean定义或FactoryBeans的{@code getObjectType}的值判断。
* <p><b>注意:此方法仅内省顶级bean。</b>它不检查可能与指定类型匹配的嵌套bean。
* <p>会考虑由FactoryBeans创建的对象,这意味着FactoryBeans将被初始化。
* 如果由FactoryBean创建的对象不匹配,则原始FactoryBean本身将与类型匹配。
* <p>不考虑此工厂可能参与的任何层次结构。
* 使用BeanFactoryUtils的{@code beanNamesForTypeIncludingAncestors}以包括祖先工厂中的bean。
* <p>注意:不会忽略以非bean定义的方式注册的单例bean。
* <p>此版本的{@code getBeanNamesForType}匹配所有类型的bean,无论是单例,原型还是FactoryBeans。
* 在大多数实现中,结果将与{@code getBeanNamesForType(type, true, true)}的结果相同。
* <p>此方法返回的bean名称数组应尽可能以后端配置中<i>定义的顺序</i>返回bean名称。
*
* @param type 要匹配的类或接口,或{@code null}表示所有bean名称
* @return 匹配给定对象类型(包括子类)的bean的名称数组,如果没有则为空数组
* @see FactoryBean#getObjectType
* @see BeanFactoryUtils#beanNamesForTypeIncludingAncestors(ListableBeanFactory, Class)
*/
String[] getBeanNamesForType(@Nullable Class<?> type);
/**
* 根据给定类型(包括子类)返回匹配的bean的名称数组,根据bean定义或FactoryBeans的{@code getObjectType}的值判断。
* <p><b>注意:此方法仅内省顶级bean。</b>它不检查可能与指定类型匹配的嵌套bean。
* <p>如果设置了“allowEagerInit”标志,会考虑由FactoryBeans创建的对象,这意味着FactoryBeans将被初始化。
* 如果由FactoryBean创建的对象不匹配,则原始FactoryBean本身将与类型匹配。
* 如果未设置“allowEagerInit”,则仅检查原始FactoryBeans(这不需要初始化每个FactoryBean)。
* <p>不考虑此工厂可能参与的任何层次结构。
* 使用BeanFactoryUtils的{@code beanNamesForTypeIncludingAncestors}以包括祖先工厂中的bean。
* <p>注意:不会忽略以非bean定义的方式注册的单例bean。
* <p>此方法返回的bean名称数组应尽可能以后端配置中<i>定义的顺序</i>返回bean名称。
*
* @param type 要匹配的类或接口,或{@code null}表示所有bean名称
* @param includeNonSingletons 是否包括原型或作用域bean,或仅包括单例(也适用于FactoryBeans)
* @param allowEagerInit 是否初始化<i>延迟初始化的单例</i>和
* <i>由FactoryBeans创建的对象</i>(或带有
* "factory-bean"引用的工厂方法)以进行类型检查。
* 请注意,需要急切地初始化FactoryBeans和"factory-bean"引用,因此
* 请注意,为此标志传递“true”将初始化FactoryBeans和“factory-bean”引用。
* @return 匹配给定对象类型(包括子类)的bean的名称数组,如果没有则为空数组
* @see FactoryBean#getObjectType
* @see BeanFactoryUtils#beanNamesForTypeIncludingAncestors(ListableBeanFactory, Class, boolean, boolean)
*/
String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);
/**
* 根据给定的对象类型(包括子类),从bean定义或FactoryBeans的{@code getObjectType}的值判断,
* 返回匹配的bean实例Map。
* <p><b>注意:此方法仅内省顶级bean。</b>它不检查可能与指定类型匹配的嵌套bean。
* <p>会考虑由FactoryBeans创建的对象,这意味着FactoryBeans将被初始化。
* 如果由FactoryBean创建的对象不匹配,则原始FactoryBean本身将与类型匹配。
* <p>不考虑此工厂可能参与的任何层次结构。
* 使用BeanFactoryUtils的{@code beansOfTypeIncludingAncestors}以包括祖先工厂中的bean。
* <p>注意:不会忽略以非bean定义的方式注册的单例bean。
* <p>此版本的getBeansOfType匹配所有类型的bean,无论是单例,原型还是FactoryBeans。
* 在大多数实现中,结果将与{@code getBeansOfType(type, true, true)}的结果相同。
* <p>此方法返回的Map应尽可能以后端配置中<i>定义的顺序</i>返回bean名称和相应的bean实例。
*
* @param type 要匹配的类或接口,或{@code null}表示所有具体bean
* @return 匹配的bean的Map,其中包含bean名称作为键,相应的bean实例作为值
* @throws BeansException 如果无法创建bean
* @since 1.1.2
* @see FactoryBean#getObjectType
* @see BeanFactoryUtils#beansOfTypeIncludingAncestors(ListableBeanFactory, Class)
*/
<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;
/**
* 根据给定对象类型(包括子类),从bean定义或FactoryBeans的{@code getObjectType}的值判断,
* 返回匹配的bean实例Map。
* <p><b>注意:此方法仅内省顶级bean。</b>它不检查可能与指定类型匹配的嵌套bean。
* <p>如果设置了“allowEagerInit”标志,会考虑由FactoryBeans创建的对象,
* 这意味着FactoryBeans将被初始化。如果由FactoryBean创建的对象不匹配,
* 则原始FactoryBean本身将与类型匹配。
* <p>不考虑此工厂可能参与的任何层次结构。
* 使用BeanFactoryUtils的{@code beansOfTypeIncludingAncestors}以包括祖先工厂中的bean。
* <p>注意:不会忽略以非bean定义的方式注册的单例bean。
* <p>此方法返回的Map应尽可能以后端配置中<i>定义的顺序</i>返回bean名称和相应的bean实例。
*
* @param type 要匹配的类或接口,或{@code null}表示所有具体bean
* @param includeNonSingletons 是否包括原型或作用域bean,或仅包括单例(也适用于FactoryBeans)
* @param allowEagerInit 是否初始化<i>延迟初始化的单例</i>和
* <i>由FactoryBeans创建的对象</i>(或带有
* "factory-bean"引用的工厂方法)以进行类型检查。
* 请注意,需要急切地初始化FactoryBeans和"factory-bean"引用,因此
* 请注意,为此标志传递“true”将初始化FactoryBeans和“factory-bean”引用。
* @return 匹配的bean的Map,其中包含bean名称作为键,相应的bean实例作为值
* @throws BeansException 如果无法创建bean
* @see FactoryBean#getObjectType
* @see BeanFactoryUtils#beansOfTypeIncludingAncestors(ListableBeanFactory, Class, boolean, boolean)
*/
<T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
throws BeansException;
/**
* 查找所有具有提供的{@link Annotation}类型注释的bean的名称,尚未创建相应的bean实例。
* <p>请注意,此方法考虑由FactoryBeans创建的对象,这意味着FactoryBeans将初始化以确定其对象类型。
*
* @param annotationType 要查找的注解类型
* (在指定bean的类、接口或工厂方法级别)
* @return 所有匹配bean的名称
* @since 4.0
* @see #findAnnotationOnBean
*/
String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
/**
* 查找所有具有提供的{@link Annotation}类型注释的bean,返回包含bean名称作为键和相应bean实例作为值的Map。
* <p>请注意,此方法考虑由FactoryBeans创建的对象,这意味着FactoryBeans将初始化以确定其对象类型。
*
* @param annotationType 要查找的注解类型
* (在指定bean的类、接口或工厂方法级别)
* @return 包含匹配的bean的Map,其中包含bean名称作为键,相应的bean实例作为值
* @throws BeansException 如果无法创建bean
* @since 3.0
* @see #findAnnotationOnBean
*/
Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
/**
* 在指定的bean上查找{@code annotationType}类型的{@link Annotation},
* 如果在给定类本身找不到注解,还会遍历其接口和超类,以及检查bean的工厂方法(如果有)。
*
* @param beanName 要查找注解的bean的名称
* @param annotationType 要查找的注解类型
* (在指定bean的类、接口或工厂方法级别)
* @return 如果找到,返回给定类型的注解,否则返回{@code null}
* @throws NoSuchBeanDefinitionException 如果没有给定名称的bean
* @since 3.0
* @see #getBeanNamesForAnnotation
* @see #getBeansWithAnnotation
*/
@Nullable
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
throws NoSuchBeanDefinitionException;
}
DefaultListableBeanFactory
DefaultListableBeanFactory
是Spring框架中实现BeanFactory
接口的关键类之一,负责注册、管理和初始化应用程序中的所有Bean定义。它支持依赖注入、不同作用域的Bean管理、处理FactoryBean
、层次性容器、以及各种生命周期回调等功能,是Spring IoC容器的核心实现,提供了灵活而强大的Bean管理和配置机制。使用ListableBeanFactory
接口的方法,通过Spring容器获取和检查bean定义和实例。给大家展示了如何判断是否包含特定名称的bean定义,获取所有bean定义的数量和名称,懒加载获取bean实例,根据类型和注解获取bean名称和实例,以及在指定bean上查找指定类型的注解。
public class ListableBeanFactoryDemo {
public static void main(String[] args) {
// 创建 ListableBeanFactory
ListableBeanFactory beanFactory = new AnnotationConfigApplicationContext(MyConfiguration.class).getBeanFactory();
// 判断是否包含指定名称的 bean 定义
boolean containsBeanDefinition = beanFactory.containsBeanDefinition("myService");
System.out.println("判断是否包含指定名称的Bean定义: " + containsBeanDefinition);
// 获取工厂中所有 bean 定义的数量
int beanDefinitionCount = beanFactory.getBeanDefinitionCount();
System.out.println("获取工厂中所有Bean定义数量: " + beanDefinitionCount);
// 获取工厂中所有 bean 定义的名称数组
String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
System.out.println("获取工厂中所有Bean定义名称: " + String.join(", ", beanDefinitionNames));
// 获取 ObjectProvider,并懒加载获取 bean 实例
ObjectProvider<MyService> objectProvider = beanFactory.getBeanProvider(MyService.class, true);
System.out.println("获取Bean的ObjectProvider: " + objectProvider.getObject());
// 根据类型获取所有 bean 的名称
String[] beanNamesForType = beanFactory.getBeanNamesForType(ResolvableType.forClass(MyService.class));
System.out.println("根据类型获取Bean名称: " + String.join(", ", beanNamesForType));
// 根据注解类型获取所有 bean 的名称
String[] beanNamesForAnnotation = beanFactory.getBeanNamesForAnnotation(Service.class);
System.out.println("根据注解获取Bean名称: " + String.join(", ", beanNamesForAnnotation));
// 根据注解类型获取所有 bean 实例
Map<String, Object> beansWithAnnotation = beanFactory.getBeansWithAnnotation(Service.class);
System.out.println("根据注解类型获取所有Bean实例: " + beansWithAnnotation);
// 在指定 bean 上查找指定类型的注解
Service annotation = beanFactory.findAnnotationOnBean("myService", Service.class);
System.out.println("指定Bean上查找指定类型的注解: " + annotation);
}
}
MyConfiguration
类扫描包 "com.xcs.spring.service
" 以查找Spring组件,如 @Component
、@Service
、@Repository
和 @Controller
。Spring将识别带有这些注解的类,并在应用程序上下文中将它们注册为Bean。
@Configuration
@ComponentScan("com.xcs.spring.service")
public class MyConfiguration {
}
通过 @Service
注解告诉Spring框架它是一个被管理的组件。
@Service
public class MyService {
}
运行结果发现,Spring容器中Bean的定义、数量、名称,以及通过不同方式获取Bean的相关信息。
判断是否包含指定名称的Bean定义: true
获取工厂中所有Bean定义数量: 6
获取工厂中所有Bean定义名称: org.springframework.context.annotation.internalConfigurationAnnotationProcessor, org.springframework.context.annotation.internalAutowiredAnnotationProcessor, org.springframework.context.event.internalEventListenerProcessor, org.springframework.context.event.internalEventListenerFactory, myConfiguration, myService
获取Bean的ObjectProvider: com.xcs.spring.service.MyService@4b0d79fc
根据类型获取Bean名称: myService
根据注解获取Bean名称: myService
根据注解类型获取所有Bean实例: {myService=com.xcs.spring.service.MyService@4b0d79fc}
指定Bean上查找指定类型的注解: @org.springframework.stereotype.Service(value=)
BeanFactory
接口
ListableBeanFactory
继承自 BeanFactory
接口,因此拥有 BeanFactory
的基本功能,包括获取 Bean、判断 Bean 是否存在等。ApplicationContext
接口
ApplicationContext
是 BeanFactory
的子接口,它继承了 ListableBeanFactory
,因此拥有了 ListableBeanFactory
的所有功能。ApplicationContext
还提供了更多的应用级别的功能,例如国际化、事件发布等。ConfigurableListableBeanFactory
接口
ConfigurableListableBeanFactory
是 ListableBeanFactory
的子接口,继承了 ListableBeanFactory
的功能,并在此基础上提供了配置修改的方法,例如注册 Bean 定义、销毁 Bean 等。AbstractApplicationContext
抽象类
AbstractApplicationContext
是 ApplicationContext
接口的一个抽象实现,它实现了 ConfigurableListableBeanFactory
接口,包含了 ListableBeanFactory
和 ConfigurableListableBeanFactory
的功能。GenericApplicationContext
类
GenericApplicationContext
是 AbstractApplicationContext
的具体实现,它可以通过配置文件、注解等方式进行配置,同时提供了 ListableBeanFactory
和 ConfigurableListableBeanFactory
的功能。AnnotationConfigApplicationContext
类:
AnnotationConfigApplicationContext
是 GenericApplicationContext
的一个具体实现,它通过基于注解的配置类来初始化 Spring 容器,同时支持 ListableBeanFactory
和 ConfigurableListableBeanFactory
接口。无法获取到指定类型的Bean
Bean数量不符合预期
ObjectProvider
无法获取到实例
ObjectProvider
的其他方法进行更灵活的操作。getBeansOfType
返回的结果为空
Bean名称顺序不符合期望
@Order
注解或其他方式指定 Bean 注册顺序。此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。