You have two ways to generate beans. One is to create a class with an annotation @Component. The other is to create a method and annotate it with @Bean. For those classes containing method with @Bean should be annotated with @Configuration Once you run your spring project, the class with a @ComponentScan annotation would scan every class with @Component on it, and restore the instance of this class to the Ioc Container. Another thing the @ComponentScan would do is running the methods with @Bean on it and restore the return object to the Ioc Container as a bean. So when you need to decide which kind of beans you want to create depending upon current states, you need to use @Bean. You can write the logic and return the object you want. Another thing worth to mention is the name of the method with @Bean is the default name of bean.

您可以使用@Bean使现有的第三方类对Spring框架应用程序上下文可用。

@Bean
public ViewResolver viewResolver() {

    InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();

    viewResolver.setPrefix("/WEB-INF/view/");
    viewResolver.setSuffix(".jsp");

    return viewResolver;
}

通过使用@Bean注释，您可以将第三方类(它可能没有@Component，也可能不使用Spring)包装为Spring bean。然后，一旦使用@Bean包装它，它就是一个单例对象，可以在Spring框架应用程序上下文中使用。现在，您可以使用依赖注入和@Autowired在应用程序中轻松地共享/重用此bean。

因此，可以将@Bean注释看作第三方类的包装器/适配器。您希望使第三方类对Spring框架应用程序上下文可用。

通过在上面的代码中使用@Bean，我显式地声明了一个bean，因为在方法内部，我使用new关键字显式地创建了对象。我还手动调用给定类的setter方法。所以我可以改变前缀字段的值。所以这种手工工作被称为显式创建。如果我对同一个类使用@Component，那么在Spring容器中注册的bean的前缀字段将具有默认值。

另一方面，当我们用@Component注释一个类时，我们不需要手动使用new关键字。它由Spring自动处理。

这两种方法都旨在在Spring容器中注册目标类型。

区别在于@Bean适用于方法，而@Component适用于类型。

因此，当您使用@Bean注释时，您可以在方法主体中控制实例创建逻辑(参见上面的示例)。而@Component注释则不行。

@Component auto detects and configures the beans using classpath scanning whereas @Bean explicitly declares a single bean, rather than letting Spring do it automatically. @Component does not decouple the declaration of the bean from the class definition where as @Bean decouples the declaration of the bean from the class definition. @Component is a class level annotation whereas @Bean is a method level annotation and name of the method serves as the bean name. @Component need not to be used with the @Configuration annotation where as @Bean annotation has to be used within the class which is annotated with @Configuration. We cannot create a bean of a class using @Component, if the class is outside spring container whereas we can create a bean of a class using @Bean even if the class is present outside the spring container. @Component has different specializations like @Controller, @Repository and @Service whereas @Bean has no specializations.

Spring支持多种类型的注解，比如@Component、@Service、@Repository。所有这些都可以在org.springframework.stereotype包下找到。

@Bean可以在org.springframework.context.annotation包下找到。

当应用程序中的类使用上述任何注释时，在项目启动期间spring扫描(使用@ComponentScan)每个类，并将类的实例注入到IOC容器中。@ComponentScan要做的另一件事是运行带有@Bean的方法，并将返回对象作为bean恢复到Ioc容器中。

@ component

如果我们用@Component或者其他的Stereotype注释来标记一个类，这些类将会被类路径扫描自动检测到。只要这些类在我们的基本包下，或者Spring意识到要扫描另一个包，就会为每个类创建一个新bean。

package com.beanvscomponent.controller;

import org.springframework.stereotype.Controller;

@Controller
public class HomeController {

    public String home(){
       return "Hello, World!";
   }

 }

在带注释的类和bean之间存在隐式的一对一映射(即每个类一个bean)。这种方法对连接的控制非常有限，因为它是纯声明式的。同样重要的是要注意原型注释是类级注释。

@ bean

@Bean用于显式地声明单个bean，而不是像我们使用@Controller那样让Spring自动完成。它将bean的声明与类定义解耦，并允许您按照自己的选择创建和配置bean。对于@Bean，您没有将这个注释放在类级别。如果你尝试这样做，你会得到一个无效的类型错误。@Bean文档将其定义为:

Indicates that a method produces a bean to be managed by the Spring container.

通常，@Bean方法在@Configuration类中声明。我们有一个需要实例化的用户类，然后使用该实例创建一个bean。这就是我前面说过的对bean的定义有更多控制的地方。

package com.beanvscomponent;

public class User {

private String first;
private String last;

public User(String first, String last) {
    this.first = first;
    this.last = last;
   }
}

正如我前面提到的，@Bean方法应该在@Configuration类中声明。

package com.beanvscomponent;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ApplicationConfig {

@Bean
public User superUser() {
    return new User("Partho","Bappy");
   }

}

方法的名称实际上就是bean的名称。如果我们调出执行器中的/beans端点，就可以看到bean的定义。

{
"beans": "superUser",
"aliases": [],
"scope": "singleton",
"type": "com.beanvscomponent.User",
"resource": "class path resource 
    [com/beanvscomponent/ApplicationConfig.class]",
"dependencies": []
}

@组件vs @Bean

我希望这澄清了什么时候使用@Component和什么时候使用@Bean的一些问题。这可能有点令人困惑，但随着您开始编写更多的应用程序，它将变得非常自然。

Bean和Component的区别: