@Bean在@Configuration和在@Component中的区别

这三种注解和xml形式的关系:

@configuration = <beans></beans>

@component =<bean></bean>放在类上

@bean = <bean></bean> 放在方法上 

简要概述：

Configuration和Component都是注解在类上的，

Configuration类中的方法成员变量是@Value注解，方法上的注解是@Bean

，使用cglib 动态代理 标记的是 同一个对象 ;

Component类中的方法和成员变量没有任何限制，由于相当于new所以每次取的不一定是同一个对象。

疑问由来

首先看一下Spring官方文档是怎么说的：

The @Bean methods in a Spring component are processed differently than their counterparts inside a Spring @Configuration class. The difference is that @Component classes are not enhanced with CGLIB to intercept the invocation of methods and fields. CGLIB proxying is the means by which invoking methods or fields within @Bean methods in @Configuration classes creates bean metadata references to collaborating objects; such methods are not invoked with normal Java semantics but rather go through the container in order to provide the usual lifecycle management and proxying of Spring beans even when referring to other beans via programmatic calls to @Bean methods. In contrast, invoking a method or field in an @Bean method within a plain @Component class has standard Java semantics, with no special CGLIB processing or other constraints applying.

我英文不是很好，理解起来比较困难，后来做了个测试才理解的。大致翻译下，括号里内容是我自己补充的：

在Component中(@Component标注的类，包括@Service,@Repository, @Controller)使用@Bean注解和在@Configuration中使用是不同的。在@Component类中使用方法或字段时不会使用CGLIB增强(及不使用代理类：调用任何方法，使用任何变量，拿到的是原始对象，后面会有例子解释)。而在@Configuration类中使用方法或字段时则使用CGLIB创造协作对象（及使用代理：拿到的是代理对象）;当调用@Bean注解的方法时它不是普通的Java语义，而是从容器中拿到由Spring生命周期管理、被Spring代理甚至依赖于其他Bean的对象引用。在@Component中调用@Bean注解的方法和字段则是普通的Java语义，不经过CGLIB处理。

不知道上面写的是不是很拗口，可能还是不好理解，来个示例吧。

概念和示例

首先介绍下Spring中Bean的生命周期，后面好解释运行结果。很熟悉的请跳过，由于我刚读Spring的手册，记录下加深印象。

Spring中Bean生命周期

Bean简单来说就是Spring管理的对象，最常用的应该是Scope=Singleton的Bean。

一个最简单Singleton Bean它在Spring中的创建过程大致是，Singleton Bean完成这些在容器启动时：读取类定义 -> 调用构造函数实例化 -> 填充属性值 -> 初始化

 消亡过程 ，一般是在容器关闭时： 销毁(析构前处理)  -> 后面的事就不太清楚了，应该是Spring断开引用然后交由Java虚拟机自己处理。

不同Scope的Bean生命周期大致一样，完成的时机不同，例如prototype在使用时才做实例化之后的动作。

生命周期接口示例

1.首先写一个Bean的配置类，在singleton的MyService中注入prototype的MyMode类。这里使用接口为了能自由选择JDK动态代理或CGLIB

Mode接口

1. package com.bean;
4. import java.util.concurrent.atomic.AtomicInteger;
7. import javax.annotation.PostConstruct;
8. import javax.annotation.PreDestroy;
11. import org.springframework.beans.factory.DisposableBean;
12. import org.springframework.beans.factory.InitializingBean;
15. public class MyMode implements IMode, InitializingBean, DisposableBean {
18. private static AtomicInteger i = new AtomicInteger(0);
21. private int value;
24. public MyMode() {
25. System.out.println('MyMode constructor call');
26. this.value = i.incrementAndGet();
27. }
30. public void print() {
31. System.out.println('MyMode print called');
32. System.out.println(value);
33. }
36. public void destroy() throws Exception {
37. System.out.println('Mode destroy called');
38. }
41. public void afterPropertiesSet() throws Exception {
42. System.out.println('Mode afterPropertiesSet called');
45. }
48. public void beanInit() {
49. System.out.println('Mode @Bean anno Init called');
50. }
53. public void beanDestory() {
54. System.out.println('Mode @Bean anno destory called');
55. }
58. @PostConstruct
59. public void annotationInit() {
60. System.out.println('Mode @PostConstruct anno init called');
61. }
64. @PreDestroy
65. public void annotationDestory() {
66. System.out.println('Mode @PreDestroy anno destory called');
67. }
68. }

Service接口

1. package com.bean;
3. public interface IService {
5. public IMode getMode();
6. }

Service实现

1. package com.bean;
3. public class MyService implements IService{
5. private IMode mode;
7. public MyService() {
9. }
11. public MyService(IMode mode) {
12. this.mode = mode;
13. }
15. public IMode getMode() {
16. return mode;
17. }
19. public String toString() {
20. if(mode==null){
21. return 'none mode in service';
22. }
23. return 'bingo';
24. }
25. }

Bean配置类

1. package com;
4. import org.springframework.beans.factory.config.BeanDefinition;
5. import org.springframework.context.annotation.Bean;
6. import org.springframework.context.annotation.Configuration;
7. import org.springframework.context.annotation.Scope;
8. import org.springframework.context.annotation.ScopedProxyMode;
11. import com.bean.IMode;
12. import com.bean.IService;
13. import com.bean.MyMode;
14. import com.bean.MyService;
17. @Configuration
18. public class TestBeanConfigration {
21. @Bean
22. public IService myService() {
23. return new MyService(myMode());
24. }
26. @Bean(initMethod = 'beanInit', destroyMethod = 'beanDestory')
27. @Scope(value = BeanDefinition.SCOPE_PROTOTYPE, proxyMode = ScopedProxyMode.TARGET_CLASS)
28. public IMode myMode() {
29. return new MyMode();
30. }
31. }

上面的MyMode Bean使用了三个接口：

①注解@Bean的属性initMethod, destroyMethod 

②接口InitializingBean, DisposableBean

③注解@PostConstruct,@PreDestroy
都作用于同样的两个过程——初始化阶段和销毁阶段

2、BeanPostProcessor

1. package com.processor;
3. import org.springframework.beans.BeansException;
4. import org.springframework.beans.factory.config.BeanPostProcessor;
5. import org.springframework.stereotype.Component;
7. import com.bean.MyMode;
9. @Component
10. public class TestBeanPostProcessor implements BeanPostProcessor {
12. public Object postProcessBeforeInitialization(Object bean, String beanName)
13. throws BeansException {
14. if (bean instanceof MyMode) {
15. System.out
16. .println('BeanPostProcessor postProcessBeforeInitialization called');
17. }
18. return bean;
19. }
21. public Object postProcessAfterInitialization(Object bean, String beanName)
22. throws BeansException {
23. if (bean instanceof MyMode) {
24. System.out
25. .println('BeanPostProcessor postProcessAfterInitialization called');
26. }
27. return bean;
28. }
29. }

实现了BeanPostProcessor接口，该接口作用于Bean初始化前后

3、InstantiationAwareBeanPostProcessor

1. package com.processor;
3. import java.beans.PropertyDescriptor;
5. import org.springframework.beans.BeansException;
6. import org.springframework.beans.PropertyValues;
7. import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
8. import org.springframework.stereotype.Component;
10. import com.bean.MyMode;
12. @Component
13. public class TestInstantiationBeanPostProcessor extends
14. InstantiationAwareBeanPostProcessorAdapter {
16. public Object postProcessBeforeInstantiation(Class<?> beanClass,
17. String beanName) throws BeansException {
18. if (beanClass.isAssignableFrom(MyMode.class)) {
19. System.out
20. .println('InstantiationBeanPostProcessor postProcessBeforeInstantiation called');
21. }
22. return null;
23. }
25. public boolean postProcessAfterInstantiation(Object bean, String beanName)
26. throws BeansException {
27. if (bean instanceof MyMode) {
28. System.out
29. .println('InstantiationBeanPostProcessor postProcessAfterInstantiation called');
30. }
31. return true;
32. }
34. public PropertyValues postProcessPropertyValues(PropertyValues pvs,
35. PropertyDescriptor[] pds, Object bean, String beanName)
36. throws BeansException {
37. if (bean instanceof MyMode) {
38. System.out
39. .println('InstantiationBeanPostProcessor postProcessPropertyValues called');
40. }
41. return pvs;
42. }
44. }

继承自一个抽象类，主要实现的还是InstantiationAwareBeanPostProcessor接口的方法，该接口作用于实例化阶段，完成实例化，属性描述修改以及实例化后处理逻辑

4、以下是Spring Boot的启动类，以及一个简单的Web Controller

1. package com;
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.SpringBootApplication;
5. import org.springframework.context.annotation.EnableAspectJAutoProxy;
7. @SpringBootApplication
8. @EnableAspectJAutoProxy
9. public class Application {
11. public static void main(String[] args) {
12. SpringApplication.run(Application.class, args);
13. }
14. }

1. package com;
3. import java.util.concurrent.atomic.AtomicLong;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.web.bind.annotation.RequestMapping;
7. import org.springframework.web.bind.annotation.RequestParam;
8. import org.springframework.web.bind.annotation.RestController;
10. import com.bean.IMode;
11. import com.bean.IService;
13. @RestController
14. public class GreetingController {
16. private static final String template = 'Hello, %s!';
17. private final AtomicLong counter = new AtomicLong();
19. @Autowired
20. private IService myService;
22. @Autowired
23. private IMode mode;
25. @RequestMapping('/greeting')
26. public Greeting greeting(
27. @RequestParam(value = 'name', defaultValue = 'World') String name) {
28. if (mode == myService.getMode()) {
29. System.out
30. .println('The Mode Bean injected in different Bean is the same object, class type is '
31. mode.getClass().getName());
32. } else {
33. System.out
34. .println('The Mode Bean injected in different Bean is different object.');
35. if (mode.getClass() == myService.getMode().getClass()) {
36. System.out.println(' but they are the same type: '
37. mode.getClass().getName());
38. } else {
39. System.out.println(' and they are different type : '
40. mode.getClass().getName() ','
41. myService.getMode().getClass().getName());
42. }
43. }
44. mode.print();
47. myService.getMode().print();
49. mode.print();

1. return new Greeting(counter.incrementAndGet(), String.format(template,
2. name));
3. }
5. private static class Greeting {
7. private final long id;
8. private final String content;
10. public Greeting(long id, String content) {
11. this.id = id;
12. this.content = content;
13. }
15. public long getId() {
16. return id;
17. }
19. public String getContent() {
20. return content;
21. }
22. }
23. }

5、启动应用，调用Controller打印结果：

The Mode Bean injected in different Bean is the same object, class type is com.sun.proxy.$Proxy47
InstantiationBeanPostProcessor postProcessBeforeInstantiation called
MyMode constructor call
InstantiationBeanPostProcessor postProcessAfterInstantiation called
InstantiationBeanPostProcessor postProcessPropertyValues called
BeanPostProcessor postProcessBeforeInitialization called
Mode @PostConstruct anno init called
Mode afterPropertiesSet called
Mode @Bean anno Init called
BeanPostProcessor postProcessAfterInitialization called
MyMode print called
1
MyMode constructor call
InstantiationBeanPostProcessor postProcessAfterInstantiation called
InstantiationBeanPostProcessor postProcessPropertyValues called
BeanPostProcessor postProcessBeforeInitialization called
Mode @PostConstruct anno init called
Mode afterPropertiesSet called
Mode @Bean anno Init called
BeanPostProcessor postProcessAfterInitialization called
MyMode print called
2
MyMode constructor call
InstantiationBeanPostProcessor postProcessAfterInstantiation called
InstantiationBeanPostProcessor postProcessPropertyValues called
BeanPostProcessor postProcessBeforeInitialization called
Mode @PostConstruct anno init called
Mode afterPropertiesSet called
Mode @Bean anno Init called
BeanPostProcessor postProcessAfterInitialization called
MyMode print called
3

由于MyMode是prototype的，每次调用不同实例，生命周期接口调用顺序应该是：

postProcessBeforeInstantiation->constructor->postProcessAfterInstantiation->postProcessPropertyValues 

->postProcessBeforeInitialization->( @PostConstruct->afterPropertiesSet->@Bean init)->postProcessAfterInitialization

->( @PostDestroy>destroy->@Bean destroy)

postProcessBeforeInstantiation只调用一次，说明某个类不管在Spring中有几个相应的对象，其原始实例只有一个。

但是为什么销毁阶段的函数没调用，因为Spring文档就这样写的，prototype资源当做普通对象自己代码中释放就好。暂时将MyMode的Scope改为WebApplicationContext.SCOPE_REQUEST。输出如下：

The Mode Bean injected in different Bean is the same object, class type is com.sun.proxy.$Proxy47
InstantiationBeanPostProcessor postProcessBeforeInstantiation called
MyMode constructor call
InstantiationBeanPostProcessor postProcessAfterInstantiation called
InstantiationBeanPostProcessor postProcessPropertyValues called
BeanPostProcessor postProcessBeforeInitialization called
Mode @PostConstruct anno init called
Mode afterPropertiesSet called
Mode @Bean anno Init called
BeanPostProcessor postProcessAfterInitialization called
MyMode print called
1
MyMode print called
1
MyMode print called
1
Mode @PreDestroy anno destory called
Mode destroy called
Mode @Bean anno destory called

@Configuration与@Component

上面例子不仅描述了Spring生命周期，注意TestBeanConfigration中那句new MyService(myMode())

它是调用本类中的方法myMode()，当Scope=prototype时，根据上面第二次print的结果，实际上得到的却是拥有Spring生命周期Bean。

Spring官方文档所要表达的就是这个。

接下来试试TestBeanConfigration的@Configuration改为@Component,MyMode的Scope仍然是prototype。看看结果：

在启动时打印了一次：MyMode constructor call

调用Controller时：

The Mode Bean injected in different Bean is different object.
 and they are different type : com.sun.proxy.$Proxy46,com.bean.MyMode
InstantiationBeanPostProcessor postProcessBeforeInstantiation called
MyMode constructor call
InstantiationBeanPostProcessor postProcessAfterInstantiation called
InstantiationBeanPostProcessor postProcessPropertyValues called
BeanPostProcessor postProcessBeforeInitialization called
Mode @PostConstruct anno init called
Mode afterPropertiesSet called
Mode @Bean anno Init called
BeanPostProcessor postProcessAfterInitialization called
MyMode print called
2
MyMode print called
1
MyMode constructor call
InstantiationBeanPostProcessor postProcessAfterInstantiation called
InstantiationBeanPostProcessor postProcessPropertyValues called
BeanPostProcessor postProcessBeforeInitialization called
Mode @PostConstruct anno init called
Mode afterPropertiesSet called
Mode @Bean anno Init called
BeanPostProcessor postProcessAfterInitialization called
MyMode print called
3

由以上结果可以看出使用@Component时，TestBeanConfigration调用本类中的方法myMode()，立马返回一个原始的MyMode对象，该对象就是简单的Java对象。