请解释以下有关 Spring 中 NoSuchBeanDefinitionException 异常的信息:
这篇文章旨在对使用 Spring 的应用程序中出现的
NoSuchBeanDefinitionException 进行全面的问答。
最佳答案
javadoc of NoSuchBeanDefinitionException 解释
Exception thrown when a
BeanFactoryis asked for a bean instance for which it cannot find a definition. This may point to a non-existing bean, a non-unique bean, or a manually registered singleton instance without an associated bean definition.
A
BeanFactory 基本上是代表 Spring's Inversion of Control container 的抽象。它在内部和外部向您的应用程序公开 bean。当它无法找到或检索这些 bean 时，它会抛出 NoSuchBeanDefinitionException 。以下是
BeanFactory(或相关类)无法找到 bean 的简单原因以及如何确保它。bean 不存在，它没有被注册
在下面的例子中
@Configuration
public class Example {
public static void main(String[] args) throws Exception {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Example.class);
ctx.getBean(Foo.class);
}
}
class Foo {}
Foo 方法、@Bean 扫描、XML 定义或任何其他方式为 @Component 类型注册 bean 定义。因此，由 BeanFactory 管理的 AnnotationConfigApplicationContext 没有指示从何处获取 getBean(Foo.class) 请求的 bean。上面的片段抛出Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException:
No qualifying bean of type [com.example.Foo] is defined
@Autowired 依赖项时可能已抛出异常。例如，@Configuration
@ComponentScan
public class Example {
public static void main(String[] args) throws Exception {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Example.class);
}
}
@Component
class Foo { @Autowired Bar bar; }
class Bar { }
Foo 到 @ComponentScan 注册了一个 bean 定义。但是 Spring 对 Bar 一无所知。因此，在尝试 Autowiring bar bean 实例的 Foo 字段时，它无法找到相应的 bean。它抛出(嵌套在 UnsatisfiedDependencyException 内)Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException:
No qualifying bean of type [com.example.Bar] found for dependency [com.example.Bar]:
expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
@Bean 类中的方法 @Configuration 或 XML 配置中的 <bean> @Component(及其元注释，例如 @Repository )至 @ComponentScan 或 0x251843141 中的 0x25181223134319 XML2319 2319 19 231212124124<context:component-scan ... /> GenericApplicationContext#registerBeanDefinition ...和更多。
确保您期望的 bean 已正确注册。
一个常见的错误是多次注册bean，即。混合上述相同类型的选项。例如，我可能有
@Component
public class Foo {}
<context:component-scan base-packages="com.example" />
<bean name="eg-different-name" class="com.example.Foo />
BeanDefinitionRegistryPostProcessor 的 bean，一个名称为 Foo ，另一个名称为 foo 。确保您不会意外注册比您想要的更多的 bean。这导致我们...如果您同时使用 XML 和基于注释的配置，请确保从另一个中导入一个。 XML 提供
<import resource=""/>
eg-different-name 注释。预期单个匹配 bean，但发现 2 个(或更多)
有时您需要多个 bean 用于相同类型(或接口(interface))。例如，您的应用程序可能使用两个数据库，一个 MySQL 实例和一个 Oracle 实例。在这种情况下，您将有两个
@ImportResource bean 来管理与每个 bean 的连接。对于(简化)示例，以下@Configuration
public class Example {
public static void main(String[] args) throws Exception {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Example.class);
System.out.println(ctx.getBean(DataSource.class));
}
@Bean(name = "mysql")
public DataSource mysql() { return new MySQL(); }
@Bean(name = "oracle")
public DataSource oracle() { return new Oracle(); }
}
interface DataSource{}
class MySQL implements DataSource {}
class Oracle implements DataSource {}
Exception in thread "main" org.springframework.beans.factory.NoUniqueBeanDefinitionException:
No qualifying bean of type [com.example.DataSource] is defined:
expected single matching bean but found 2: oracle,mysql
DataSource 方法注册的两个 bean 都满足 @Bean 的要求，即。他们都实现了 BeanFactory#getBean(Class) 。在这个例子中，Spring 没有机制来区分或优先考虑两者。但是这样的机制是存在的。您可以使用
DataSource (及其在 XML 中的等效项)，如 documentation 和 this post 中所述。有了这个变化@Bean(name = "mysql")
@Primary
public DataSource mysql() { return new MySQL(); }
@Primary bean。您还可以使用
mysql(及其在 XML 中的等效项)来更好地控制 bean 选择过程，如 documentation 中所述。虽然 @Qualifier 主要用于按类型 Autowiring ，但 @Autowired 可让您按名称 Autowiring 。例如，@Bean(name = "mysql")
@Qualifier(value = "main")
public DataSource mysql() { return new MySQL(); }
@Qualifier("main") // or @Qualifier("mysql"), to use the bean name
private DataSource dataSource;
@Qualifier 也是一个选项。使用错误的 bean 名称
正如注册 bean 的方法有多种一样，命名它们的方法也有多种。
@Resource 有 @Bean The name of this bean, or if plural, aliases for this bean. If left unspecified the name of the bean is the name of the annotated method. If specified, the method name is ignored.
name 具有 <bean> 属性来表示 bean 的唯一标识符，id 可用于在 (XML) id 中创建一个或多个非法别名。name 及其元注释有 @Component The value may indicate a suggestion for a logical component name, to be turned into a Spring bean in case of an autodetected component.
如果未指定，则会为带注释的类型自动生成一个 bean 名称，通常是类型名称的小驼峰版本。例如
value 变为 MyClassName 作为其 bean 名称。 Bean 名称区分大小写。另请注意，错误的名称/大写通常出现在由 myClassName 或 XML 配置文件等字符串引用的 bean 中。如前所述，
@DependsOn("my BeanName") 允许您向 bean 添加更多别名。确保在引用 bean 时使用正确的名称。
更高级的案例
简介
Bean definition profiles 允许您有条件地注册bean。
@Qualifier ，具体来说，Indicates that a component is eligible for registration when one or more specified profiles are active.
A profile is a named logical grouping that may be activated programmatically via
ConfigurableEnvironment.setActiveProfiles(java.lang.String...)or declaratively by setting thespring.profiles.activeproperty as a JVM system property, as an environment variable, or as a Servlet context parameter in web.xml for web applications. Profiles may also be activated declaratively in integration tests via the@ActiveProfilesannotation.
考虑未设置
@Profile 属性的示例。@Configuration
@ComponentScan
public class Example {
public static void main(String[] args) throws Exception {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Example.class);
System.out.println(Arrays.toString(ctx.getEnvironment().getActiveProfiles()));
System.out.println(ctx.getBean(Foo.class));
}
}
@Profile(value = "StackOverflow")
@Component
class Foo {
}
spring.profiles.active bean 抛出 NoSuchBeanDefinitionException。由于 Foo 配置文件未处于 Activity 状态，因此该 bean 未注册。相反，如果我在注册适当的配置文件时初始化
StackOverflowAnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.getEnvironment().setActiveProfiles("StackOverflow");
ctx.register(Example.class);
ctx.refresh();
AOP 代理
Spring 大量使用 AOP proxies 来实现高级行为。一些例子包括:
ApplicationContext @Transactional @Cacheable 和 @Async 为此，Spring 有两种选择:
以 JDK 代理为例(通过
@Scheduled 的默认值 @EnableAsync 的 proxyTargetClass 实现)@Configuration
@EnableAsync
public class Example {
public static void main(String[] args) throws Exception {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Example.class);
System.out.println(ctx.getBean(HttpClientImpl.class).getClass());
}
}
interface HttpClient {
void doGetAsync();
}
@Component
class HttpClientImpl implements HttpClient {
@Async
public void doGetAsync() {
System.out.println(Thread.currentThread());
}
}
false 的 bean，我们希望找到它，因为该类型清楚地用 HttpClientImpl 进行了注释。然而，相反，我们得到了一个异常(exception)Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException:
No qualifying bean of type [com.example.HttpClientImpl] is defined
@Component bean 并通过一个仅实现 HttpClientImpl 的 Proxy 对象暴露它。所以你可以用ctx.getBean(HttpClient.class) // returns a dynamic class: com.example.$Proxy33
// or
@Autowired private HttpClient httpClient;
HttpClient ，您可以将 @EnableAsync 设置为 proxyTargetClass 。类似的注释( true 等)具有类似的属性。 XML 也将具有等效的配置选项。EnableTransactionManagement 层次结构-Spring MVCSpring 允许您使用
ApplicationContext 构建 ApplicationContext 实例，其他 ApplicationContext 实例作为父实例。子上下文可以访问父上下文中的 bean，但反之则不然。 This post 详细介绍了这何时有用，尤其是在 Spring MVC 中。在典型的 Spring MVC 应用程序中，您定义两个上下文:一个用于整个应用程序(根)，另一个专门用于
ConfigurableApplicationContext#setParent(ApplicationContext) (路由、处理程序方法、 Controller )。您可以在此处获得更多详细信息:在官方文档 here 中也有很好的解释。
在Spring MVC配置一个常见的错误与
DispatcherServlet注解@EnableWebMvc类或在XML @Configuration，但 <mvc:annotation-driven /> bean 在servlet上下文声明在根上下文的WebMVC配置。 由于根上下文无法进入 servlet 上下文以找到任何 bean，因此没有注册处理程序并且所有请求都以 404 失败。 你不会看到 @Controller ，但效果是一样的。确保您的 bean 已在适当的上下文中注册，即。可以通过为 WebMVC 注册的 bean 找到它们(
NoSuchBeanDefinitionException 、 HandlerMapping 、 HandlerAdapter 、 ViewResolver 等)。最好的解决方案是正确隔离bean。 ExceptionResolver 负责路由和处理请求，因此所有相关的 bean 都应该进入其上下文。加载根上下文的 DispatcherServlet 应该初始化应用程序其余部分所需的任何 bean:服务、存储库等。数组、集合和映射
Spring 以特殊方式处理某些已知类型的 Bean。例如，如果您尝试将
ContextLoaderListener 的数组注入(inject)到字段中@Autowired
private MovieCatalog[] movieCatalogs;
MovieCatalog 类型的 bean，将它们包装在一个数组中，然后注入(inject)该数组。这在 Spring documentation discussing MovieCatalog 中有描述。类似的行为适用于 @Autowired 、 Set 和 List 注入(inject)目标。对于
Collection 注入(inject)目标，如果键类型为 Map，Spring 也会以这种方式运行。例如，如果你有@Autowired
private Map<String, MovieCatalog> movies;
String 的 bean，并将它们作为值添加到 MovieCatalog 中，其中相应的键将是它们的 bean 名称。如前所述，如果没有可用的请求类型的 bean，Spring 将抛出
Map 。但是，有时您只想声明这些集合类型的 bean，例如@Bean
public List<Foo> fooList() {
return Arrays.asList(new Foo());
}
@Autowired
private List<Foo> foos;
NoSuchBeanDefinitionException，因为您的上下文中没有 NoSuchBeanDefinitionException bean。但是你不想要一个 Foo bean，你想要一个 Foo bean。 Before Spring 4.3, you'd have to use List<Foo> For beans that are themselves defined as a collection/map or array type,
@Resourceis a fine solution, referring to the specific collection or array bean by unique name. That said, as of 4.3, collection/map and array types can be matched through Spring’s@Autowiredtype matching algorithm as well, as long as the element type information is preserved in@Beanreturn type signatures or collection inheritance hierarchies. In this case, qualifier values can be used to select among same-typed collections, as outlined in the previous paragraph.
这适用于构造函数、setter 和字段注入(inject)。
@Resource
private List<Foo> foos;
// or since 4.3
public Example(@Autowired List<Foo> foos) {}
@Resource 方法，即会失败。@Bean
public Bar other(List<Foo> foos) {
new Bar(foos);
}
@Bean 或 @Resource 注释该方法，因为它是 @Autowired 方法，因此不能应用文档中描述的行为。但是，您可以使用 Spring 表达式语言 (SpEL) 通过名称来引用 bean。在上面的例子中，你可以使用@Bean
public Bar other(@Value("#{fooList}") List<Foo> foos) {
new Bar(foos);
}
@Bean 的 bean 并注入(inject)它。
关于java - 什么是 NoSuchBeanDefinitionException 以及如何修复它？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39173982/