【Spring】Spring常用注解（中）

1. public class IOCTest {
2.    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
3. 
4. 
5.    @Test
6.    public void testImport(){
7.       printBeans(applicationContext);
8.       Blue bean = applicationContext.getBean(Blue.class);
9.       System.out.println(bean);
10. 
11. //工厂Bean获取的是调用getObject创建的对象
12. Object bean2 = applicationContext.getBean("colorFactoryBean");   
13.       System.out.println("bean的类型："+bean2.getClass()); //pos_1   输出：bean的类型：class com.atguigu.bean.Color
14. 
15. Object bean4 = applicationContext.getBean("&colorFactoryBean");
16.       System.out.println(bean4.getClass()); //pos_2  输出：class com.atguigu.bean.ColorFactoryBean
17.    }
18. 
19.    private void printBeans(AnnotationConfigApplicationContext applicationContext){
20. String[] definitionNames = applicationContext.getBeanDefinitionNames();
21. for (String name : definitionNames) {
22.          System.out.println(name);
23.       }
24.    }
25. }

1. public class IOCTest_LifeCycle {
2. 
3.    @Test
4.    public void test01(){
5. //1、创建ioc容器
6.       AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
7.       System.out.println("容器创建完成...");
8. 
9. //applicationContext.getBean("car");
10. //关闭容器
11.       applicationContext.close();
12.    }
13. 
14. }

1. package com.atguigu.config;
2. 
3. import org.springframework.context.ApplicationListener;
4. import org.springframework.context.annotation.Bean;
5. import org.springframework.context.annotation.ComponentScan;
6. import org.springframework.context.annotation.Configuration;
7. import org.springframework.context.annotation.Scope;
8. 
9. import com.atguigu.bean.Car;
10. 
11. /**
12.  * bean的生命周期：
13.  *        bean创建---初始化----销毁的过程
14.  * 容器管理bean的生命周期；
15.  * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
16.  * 
17.  * 构造（对象创建）
18.  *        单实例：在容器启动的时候创建对象
19.  *        多实例：在每次获取的时候创建对象\
20.  * 初始化：
21.  *    对象创建完成，并赋值好，调用初始化方法。。。
22.  * BeanPostProcessor.postProcessAfterInitialization
23.  * 销毁：
24.  *    单实例：容器关闭的时候
25.  *    多实例：容器不会管理这个bean；容器不会调用销毁方法；
26.  * 
27.  * 1）、指定初始化和销毁方法；
28.  *        通过@Bean指定init-method和destroy-method；
29.  * @author lfy
30.  *
31.  */
32. @ComponentScan("com.atguigu.bean")
33. @Configuration
34. public class MainConfigOfLifeCycle {
35. 
36. //@Scope("prototype")
37. @Bean(initMethod="init",destroyMethod="detory")
38. public Car car(){
39. return new Car();
40.    }
41. 
42. }
43. @Component
44. public class Car {
45. 
46. public Car(){
47.       System.out.println("car constructor...");
48.    }
49. 
50. public void init(){
51.       System.out.println("car ... init...");
52.    }
53. 
54. public void detory(){
55.       System.out.println("car ... detory...");
56.    }
57. 
58. }

1. /**
2.  * bean的生命周期：
3.  *        bean创建---初始化----销毁的过程
4.  * 容器管理bean的生命周期；
5.  * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
6.  * 
7.  * 构造（对象创建）
8.  *        单实例：在容器启动的时候创建对象
9.  *        多实例：在每次获取的时候创建对象\
10.  * 
11.  * BeanPostProcessor.postProcessBeforeInitialization
12.  * 初始化：
13.  *        对象创建完成，并赋值好，调用初始化方法。。。
14.  * BeanPostProcessor.postProcessAfterInitialization
15.  * 销毁：
16.  *        单实例：容器关闭的时候
17.  *        多实例：容器不会管理这个bean；容器不会调用销毁方法；
18.  * 
19.  * 
20.  * 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
21.  * 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
22.  * 
23.  * BeanPostProcessor原理
24.  * populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
25.  * initializeBean
26.  * {
27.  * applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
28.  * invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
29.  * applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
30.  *}
31.  * 
32.  * 
33.  * 
34.  * 1）、指定初始化和销毁方法；
35.  *        通过@Bean指定init-method和destroy-method；
36.  * 2）、通过让Bean实现InitializingBean（定义初始化逻辑），
37.  *              DisposableBean（定义销毁逻辑）;
38.  * 
39.  * @author lfy
40.  *
41.  */
42. @ComponentScan("com.atguigu.bean")
43. @Configuration
44. public class MainConfigOfLifeCycle {
45. 
46. //@Scope("prototype")
47.    @Bean(initMethod="init",destroyMethod="detory")
48.    public Car car(){
49. return new Car();
50.    }
51. 
52. }

1. @Component
2. public class Cat implements InitializingBean,DisposableBean {
3. 
4. public Cat(){
5.       System.out.println("cat constructor...");
6.    }
7. 
8.    @Override
9. public void destroy() throws Exception {
10. // TODO Auto-generated method stub
11.       System.out.println("cat...destroy...");
12.    }
13. 
14.    @Override
15. public void afterPropertiesSet() throws Exception {
16. // TODO Auto-generated method stub
17.       System.out.println("cat...afterPropertiesSet...");
18.    }
19. 
20. }

1. /**
2.  * bean的生命周期：
3.  *        bean创建---初始化----销毁的过程
4.  * 容器管理bean的生命周期；
5.  * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
6.  * 
7.  * 构造（对象创建）
8.  *        单实例：在容器启动的时候创建对象
9.  *        多实例：在每次获取的时候创建对象\
10.  * 
11.  * BeanPostProcessor.postProcessBeforeInitialization
12.  * 初始化：
13.  *        对象创建完成，并赋值好，调用初始化方法。。。
14.  * BeanPostProcessor.postProcessAfterInitialization
15.  * 销毁：
16.  *        单实例：容器关闭的时候
17.  *        多实例：容器不会管理这个bean；容器不会调用销毁方法；
18.  * 
19.  * 
20.  * 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
21.  * 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
22.  * 
23.  * BeanPostProcessor原理
24.  * populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
25.  * initializeBean
26.  * {
27.  * applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
28.  * invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
29.  * applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
30.  *}
31.  * 
32.  * 
33.  * 
34.  * 1）、指定初始化和销毁方法；
35.  *        通过@Bean指定init-method和destroy-method；
36.  * 2）、通过让Bean实现InitializingBean（定义初始化逻辑），
37.  *              DisposableBean（定义销毁逻辑）;
38.  * 3）、可以使用JSR250；
39.  *        @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
40.  *        @PreDestroy：在容器销毁bean之前通知我们进行清理工作
41.  * 
42.  * @author lfy
43.  *
44.  */
45. @ComponentScan("com.atguigu.bean")
46. @Configuration
47. public class MainConfigOfLifeCycle {
48. 
49. //@Scope("prototype")
50.    @Bean(initMethod="init",destroyMethod="detory")
51.    public Car car(){
52. return new Car();
53.    }
54. 
55. }

1. @Component
2. public class Dog implements ApplicationContextAware {
3. 
4. //@Autowired
5. private ApplicationContext applicationContext;
6. 
7. public Dog(){
8.       System.out.println("dog constructor...");
9.    }
10. 
11. //对象创建并赋值之后调用
12.    @PostConstruct
13. public void init(){
14.       System.out.println("Dog....@PostConstruct...");
15.    }
16. 
17. //容器移除对象之前
18.    @PreDestroy
19. public void detory(){
20.       System.out.println("Dog....@PreDestroy...");
21.    }
22. 
23.    @Override
24. public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
25. // TODO Auto-generated method stub
26. this.applicationContext = applicationContext;
27.    }
28. }

1. cat constructor...
2. cat...afterPropertiesSet...
3. dog constructor...
4. Dog....@PostConstruct...
5. car constructor...
6. car ... init...
7. 容器创建完成
8. car ... detory...
9. Dog....@PreDestroy...
10. cat...destroy...
11. BeanPostProcessor
12. /**
13.  * bean的生命周期：
14.  *        bean创建---初始化----销毁的过程
15.  * 容器管理bean的生命周期；
16.  * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
17.  * 
18.  * 构造（对象创建）
19.  *        单实例：在容器启动的时候创建对象
20.  *        多实例：在每次获取的时候创建对象\
21.  * 
22.  * BeanPostProcessor.postProcessBeforeInitialization
23.  * 初始化：
24.  *        对象创建完成，并赋值好，调用初始化方法。。。
25.  * BeanPostProcessor.postProcessAfterInitialization
26.  * 销毁：
27.  *        单实例：容器关闭的时候
28.  *        多实例：容器不会管理这个bean；容器不会调用销毁方法；
29.  * 
30.  * 
31.  * 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
32.  * 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
33.  * 
34.  * BeanPostProcessor原理
35.  * populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
36.  * initializeBean
37.  * {
38.  * applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
39.  * invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
40.  * applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
41.  *}
42.  * 
43.  * 
44.  * 
45.  * 1）、指定初始化和销毁方法；
46.  *        通过@Bean指定init-method和destroy-method；
47.  * 2）、通过让Bean实现InitializingBean（定义初始化逻辑），
48.  *              DisposableBean（定义销毁逻辑）;
49.  * 3）、可以使用JSR250；
50.  *        @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
51.  *        @PreDestroy：在容器销毁bean之前通知我们进行清理工作
52.  * 4）、BeanPostProcessor【interface】：bean的后置处理器；
53.  *        在bean初始化前后进行一些处理工作；
54.  *        postProcessBeforeInitialization:在初始化之前工作
55.  *        postProcessAfterInitialization:在初始化之后工作
56.  * 
57.  * Spring底层对 BeanPostProcessor 的使用；
58.  *        bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async,xxx BeanPostProcessor;
59.  * 
60.  * @author lfy
61.  *
62.  */
63. @ComponentScan("com.atguigu.bean")
64. @Configuration
65. public class MainConfigOfLifeCycle {
66. 
67. //@Scope("prototype")
68.    @Bean(initMethod="init",destroyMethod="detory")
69.    public Car car(){
70. return new Car();
71.    }
72. 
73. }

1. /**
2.  * 后置处理器：初始化前后进行处理工作
3.  * 将后置处理器加入到容器中
4.  * @author lfy
5.  */
6. @Component
7. public class MyBeanPostProcessor implements BeanPostProcessor {
8. 
9.    @Override
10.    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
11. // TODO Auto-generated method stub
12.       System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean);
13. return bean;
14.    }
15. 
16.    @Override
17.    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
18. // TODO Auto-generated method stub
19.       System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean);
20. return bean;
21.    }
22. 
23. }

1. public class Person {
2. 
3. //使用@Value赋值；
4. //1、基本数值
5. //2、可以写SpEL； #{}
6. //3、可以写${}；取出配置文件【properties】中的值（在运行环境变量里面的值）
7. 
8. @Value("张三")
9. private String name;
10. @Value("#{20-2}")
11. private Integer age;
12. 
13. @Value("${person.nickName}")
14. private String nickName;
15. 
16. 
17. 
18. public String getNickName() {
19. return nickName;
20.    }
21. public void setNickName(String nickName) {
22. this.nickName = nickName;
23.    }
24. public String getName() {
25. return name;
26.    }
27. public void setName(String name) {
28. this.name = name;
29.    }
30. public Integer getAge() {
31. return age;
32.    }
33. public void setAge(Integer age) {
34. this.age = age;
35.    }
36. 
37. public Person(String name, Integer age) {
38. super();
39. this.name = name;
40. this.age = age;
41.    }
42. public Person() {
43. super();
44. // TODO Auto-generated constructor stub
45.    }
46. @Override
47. public String toString() {
48. return "Person [name=" + name + ", age=" + age + ", nickName=" + nickName + "]";
49.    }
50. }