springboot注解@Configuration和@Component区别

Bertha 。 2024-02-24 01:10 81阅读 0赞

#### @Configuration详解 ####

##### 一、@Configuration #####

1.  `@Target({ElementType.TYPE})`
2.  `@Retention(RetentionPolicy.RUNTIME)`
3.  `@Documented`
4.  `@Component`
5.  `public @interface Configuration {`
6.  `@AliasFor(`
7.  `annotation = Component.class`
8.  `)`
9.  `String value() default "";`
10. `}`

可以看到在`@Configuration`注解中是包含`@Component`注解的，被`@Configuration`修饰的类被定义为一个Spring容器（应用上下文）

`@Configuration`就相当于[Spring配置文件][Spring]中的`<beans />`标签，里面可以配置bean

##### 二、@Bean #####

@Bean相当于Spring配置文件中的`<bean />`标签可以在Spring容器中注入一个bean

1.  `@Configuration`
2.  `public class TestConfiguration {`
3.  
4.  `@Bean`
5.  `public TestBean testBean() {`
6.  `return new TestBean();`
7.  `}`
8.  
9.  `}`

上述代码相当于实例化一个TestBean并交给Spring容器管理

ps：

1、@Bean注解在返回实例的方法上，如果未通过@Bean指定bean的名称，则默认与方法名相同

2、@Bean注解默认作用域为`单例singleton作用域`，可通过`@Scope(“prototype”)设置为多例`

##### 三、依赖注入 #####

1.  `@Configuration`
2.  `public class TestConfiguration {`
3.  
4.  `@Bean`
5.  `public TestBean testBean() {`
6.  `return new TestBean();`
7.  `}`
8.  
9.  `@Bean`
10. `public DIBean diBean() {`
11. `return new DIBean(testBean());`
12. `}`
13. 
14. `}`

如上述代码，通过在@Bean方法中调用其他@Bean注解的方法来实现依赖注入

ps：

当需要`强制指定实例化bean的顺序`，可以`通过@Order或@DependsOn注解来实现`

除此之外我们还能使用@Component声明Spring Bean

#### @Configuration和@Component区别 ####

1.  `public class Car {`
2.  
3.  `private int id;`
4.  
5.  `private String name;`
6.  
7.  `public int getId() {`
8.  `return id;`
9.  `}`
10. 
11. `public void setId(int id) {`
12. `this.id = id;`
13. `}`
14. 
15. `public String getName() {`
16. `return name;`
17. `}`
18. 
19. `public void setName(String name) {`
20. `this.name = name;`
21. `}`
22. 
23. `}`
24. 
25. `public class Driver {`
26. 
27. `private int id;`
28. 
29. `private String name;`
30. 
31. `private Car car;`
32. 
33. `public int getId() {`
34. `return id;`
35. `}`
36. 
37. `public void setId(int id) {`
38. `this.id = id;`
39. `}`
40. 
41. `public String getName() {`
42. `return name;`
43. `}`
44. 
45. `public void setName(String name) {`
46. `this.name = name;`
47. `}`
48. 
49. `public Car getCar() {`
50. `return car;`
51. `}`
52. 
53. `public void setCar(Car car) {`
54. `this.car = car;`
55. `}`
56. 
57. `}`

1.  `import org.springframework.context.annotation.Bean;`
2.  `import org.springframework.context.annotation.Configuration;`
3.  
4.  `@Configuration`
5.  `public class MyTestConfig {`
6.  
7.  `@Bean`
8.  `public Driver driver() {`
9.  `Driver driver = new Driver();`
10. `driver.setId(1);`
11. `driver.setName("driver");`
12. `driver.setCar(car());`
13. `return driver;`
14. `}`
15. 
16. `@Bean`
17. `public Car car() {`
18. `Car car = new Car();`
19. `car.setId(1);`
20. `car.setName("car");`
21. `return car;`
22. `}`
23. 
24. `}`

1.  `import org.springframework.context.annotation.Bean;`
2.  `import org.springframework.context.annotation.Configuration;`
3.  
4.  `@Component`
5.  `public class MyTestConfig {`
6.  
7.  `@Bean`
8.  `public Driver driver() {`
9.  `Driver driver = new Driver();`
10. `driver.setId(1);`
11. `driver.setName("driver");`
12. `driver.setCar(car());`
13. `return driver;`
14. `}`
15. 
16. `@Bean`
17. `public Car car() {`
18. `Car car = new Car();`
19. `car.setId(1);`
20. `car.setName("car");`
21. `return car;`
22. `}`
23. 
24. `}`

上面两段代码除MyTestConfig类上的`注解不同之外其他都相同`，但Spring对两者的处理方式是完全不一样的。

*  第一段代码会像我们期望的一样正常运行，因为driver()这段代码中driver.setCar(car())方法**会由Spring代理执行**，
    
    **Spring发现方法所请求的Bean已经在容器中，那么就直接返回容器中的Bean。所以全局只有一个Car对象的实例。**
 *  第二段代码在执行driver() 时driver.setCar(car())不会被Spring代理，会直接调用car()方法**获取一个全新的Car对象实例**，所以全局会有多个Car对象的实例

造成这种差异的原因如下:

**概括就是 @Configuration 中所有带 @Bean 注解的方法都会被动态代理，因此调用该方法返回的都是同一个实例。**

其工作原理是：如果方式是首次被调用那么原始的方法体会被执行并且结果对象会被注册到Spring上下文中，之后所有的对该方法的调用仅仅只是从Spring上下文中取回该对象返回给调用者。

在上面的第二段代码中，driver.setCar(car())只是纯JAVA方式的调用，多次调用该方法返回的是不同的对象实例。

**要修正第二段代码中的问题，可以使用@Autowired如下所示:**

1.  `import org.springframework.beans.factory.annotation.Autowired;`
2.  `import org.springframework.context.annotation.Bean;`
3.  `import org.springframework.context.annotation.Configuration;`
4.  `import org.springframework.stereotype.Component;`
5.  
6.  `//@Configuration`
7.  `@Component`
8.  `public class MyTestConfig2 {`
9.  
10. `@Autowired`
11. `Car car;`
12. 
13. `@Bean`
14. `public Driver driver() {`
15. `Driver driver = new Driver();`
16. `driver.setId(1);`
17. `driver.setName("driver");`
18. `driver.setCar(car);`
19. `return driver;`
20. `}`
21. 
22. `@Bean`
23. `public Car car() {`
24. `Car car = new Car();`
25. `car.setId(1);`
26. `car.setName("car");`
27. `return car;`
28. `}`
29. 
30. `}`

#### 验证 ####

1.  `import org.springframework.context.ApplicationContext;`
2.  `import org.springframework.context.annotation.AnnotationConfigApplicationContext;`
3.  
4.  `public class TestMain {`
5.  
6.  `public static void main(String[] args) {`
7.  `// TODO Auto-generated method stub`
8.  `// @Configuration注解的spring容器加载方式，用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext`
9.  `ApplicationContext context = new AnnotationConfigApplicationContext(MyTestConfig.class);`
10. 
11. `// 获取bean`
12. `Driver driver = (Driver) context.getBean("driver");`
13. 
14. `// 获取bean`
15. `Car car = (Car) context.getBean("car");`
16. 
17. `boolean result = driver.getCar() == car;`
18. `System.out.println(result ? "同一个car" : "不同的car");`
19. 
20. `}`
21. 
22. `}`

更详细的探究，请参阅另一篇博客：[@Component和@Configuration作为配置类的差别\_一号搬砖手的博客-CSDN博客\_component和configuration的区别][Component_Configuration_-CSDN_component_configuration]

[Spring]: https://so.csdn.net/so/search?q=Spring%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6&spm=1001.2101.3001.7020
[Component_Configuration_-CSDN_component_configuration]: https://blog.csdn.net/long476964/article/details/80626930