我知道在spring 2.5中引入@Component注释是为了通过使用类路径扫描来摆脱xml bean定义。
@Bean是在spring 3.0中引入的,可以和@Configuration一起使用,以便完全摆脱xml文件,而使用java配置。
是否有可能重用@Component注释而不是引入@Bean注释?我的理解是,最终目标是在这两种情况下都创建bean。
我知道在spring 2.5中引入@Component注释是为了通过使用类路径扫描来摆脱xml bean定义。
@Bean是在spring 3.0中引入的,可以和@Configuration一起使用,以便完全摆脱xml文件,而使用java配置。
是否有可能重用@Component注释而不是引入@Bean注释?我的理解是,最终目标是在这两种情况下都创建bean。
当前回答
@component and its specializations(@Controller, @service, @repository) allow for auto-detection using classpath scanning. If we see component class like @Controller, @service, @repository will be scan automatically by the spring framework using the component scan. @Bean on the other hand can only be used to explicitly declare a single bean in a configuration class. @Bean used to explicitly declare a single bean, rather than letting spring do it automatically. Its make septate declaration of bean from the class definition. In short @Controller, @service, @repository are for auto-detection and @Bean to create seprate bean from class
- @Controller public class LoginController { --code-- } - @Configuration public class AppConfig { @Bean public SessionFactory sessionFactory() {--code-- }
其他回答
@Component和@Bean做两件完全不同的事情,不应该混淆。
@Component(以及@Service和@Repository)用于使用类路径扫描自动检测和自动配置bean。在带注释的类和bean之间存在隐式的一对一映射(即每个类一个bean)。这种方法对连接的控制非常有限,因为它是纯声明性的。
@Bean用于显式地声明单个bean,而不是像上面那样让Spring自动执行。它将bean的声明与类定义解耦,并允许您按照自己的选择创建和配置bean。
回答你的问题…
是否有可能重用@Component注释而不是引入@Bean注释?
当然,可能;但他们选择不这样做,因为这两者是完全不同的。春天已经够让人迷惑了,不要再把水弄脏了。
假设我想要特定的实现依赖于某种动态状态。 @Bean非常适合这种情况。
@Bean
@Scope("prototype")
public SomeService someService() {
switch (state) {
case 1:
return new Impl1();
case 2:
return new Impl2();
case 3:
return new Impl3();
default:
return new Impl();
}
}
然而,@Component没有办法做到这一点。
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的一些问题。这可能有点令人困惑,但随着您开始编写更多的应用程序,它将变得非常自然。
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.
当您使用@Component标记时,这与使用带有香草bean声明方法(用@Bean注释)的POJO(普通旧Java对象)是一样的。例如,下面的方法1和2将给出相同的结果。
方法1
@Component
public class SomeClass {
private int number;
public SomeClass(Integer theNumber){
this.number = theNumber.intValue();
}
public int getNumber(){
return this.number;
}
}
用豆子表示“数字”:
@Bean
Integer theNumber(){
return new Integer(3456);
}
方法2
//Note: no @Component tag
public class SomeClass {
private int number;
public SomeClass(Integer theNumber){
this.number = theNumber.intValue();
}
public int getNumber(){
return this.number;
}
}
两者都有豆子:
@Bean
Integer theNumber(){
return new Integer(3456);
}
@Bean
SomeClass someClass(Integer theNumber){
return new SomeClass(theNumber);
}
方法2允许您将bean声明放在一起,它更加灵活。您甚至可能想要添加另一个非香草SomeClass bean,如下所示:
@Bean
SomeClass strawberryClass(){
return new SomeClass(new Integer(1));
}