5. Spring - IOC - 组件的生命周期

骑猪看日落 2023-07-01 12:00 36阅读 0赞

## 系列篇幅 ##

*  [1. Spring - IOC - 注册组件][1. Spring - IOC -]
 *  [2. spring - IOC - 依赖注入][2. spring - IOC -]
 *  [3. Spring - IOC - 组件扫描规则][3. Spring - IOC -]
 *  [4. Spring - IOC - 组件的作用域、懒加载、条件判断][4. Spring - IOC -]
 *  [5. Spring - IOC - 组件的生命周期][5. Spring - IOC -]
 *  [6. Spring - AOP - 基本使用][6. Spring - AOP -]

## 前言 ##

整理一下Spring使用过程中的一些笔记

提示: JSR是由JDK提供的一组规范

## 介绍 ##

1.  指定初始化和消费方法
2.  通过让Bean实现接口
    
     *  InitializingBean（定义初始化逻辑）
     *  DisposableBean（定义销毁逻辑）
3.  使用JSR250注解
    
     *  @PostConstruct（在Bean创建完成,且属于赋值完成后进行初始化,属于JDK规范的注解）
     *  @PreDestroy（ 在bean将被移除之前进行通知, 在容器销毁之前进行清理工作 ）
4.  BeanPostProcessor相关接口，Bean的后置处理器
    
     *  postProcessBeforeInitialization（在初始化之前工作）
     *  postProcessAfterInitialization（在初始化之后工作）

## 注意事项 ##

1.  只有**单例**情况下，才会调用destory方法
2.  在**prototype(原型)**模式下，只有获取bean的时候才初始化，而且**不会**调用destroy

## 1. 指定初始化和消费方法 ##

public class Cat { 
        public Cat() { 
            System.out.println("Cat -> 构造中");
        }
    
        public void init() { 
            System.out.println("Cat -> 初始化");
        }
    
        public void destroy() { 
            System.out.println("Cat -> 销毁");
        }
    
    }

@Configuration
    public class MainConfig { 
    
        @Bean(initMethod = "init", destroyMethod = "destroy")
        public Cat cat() { 
            return new Cat();
        }
    
    }

使用

//1、创建ioc容器
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    System.out.println("容器创建完成");
    // 2. 获取
    Cat cat = applicationContext.getBean("cat", Cat.class);
    System.out.println("Cat -> " + cat);
    //关闭容器
    applicationContext.close();

输出

cat -> 构造中
    cat -> 初始化
    容器创建完成
    cat -> org.example.demo.bean.Cat@11c20519
    cat -> 销毁

也可以通过xml

## 2. 通过让Bean实现InitializingBean、DisposableBean ##

@Component
    public class Dog implements InitializingBean, DisposableBean { 
    
        public Dog() { 
            System.out.println("dog constructor...");
        }
    
    
        @Override
        public void afterPropertiesSet() throws Exception { 
            System.out.println("dog afterPropertiesSet...");
        }
    
        @Override
        public void destroy() throws Exception { 
            System.out.println("dog destroy...");
        }
    
    }

@Configuration
    @ComponentScan("org.example.demo")
    public class MainConfig { 
        @Bean
        public Dog dog() { 
            return new Dog();
        }
    }

//1、创建ioc容器
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    System.out.println("容器创建完成");
    // 2. 获取
    Dog dog = applicationContext.getBean("dog", Dog.class);
    System.out.println("dog -> " + dog);
    //关闭容器
    applicationContext.close();

输出

dog constructor...
    dog afterPropertiesSet...
    容器创建完成
    dog -> org.example.demo.bean.Dog@4148db48
    dog destroy...

## 3. 使用JSR250注解 ##

@Component
    public class Mouse { 
    
        public Mouse() { 
            System.out.println("Mouse -> Construct");
        }
    
        @PostConstruct
        public void init() { 
            System.out.println("Mouse -> @PostConstruct");
        }
    
        @PreDestroy
        public void destroy() { 
            System.out.println("Mouse -> @PreDestroy");
        }
    }

@Configuration
    @ComponentScan("org.example.demo")
    public class MainConfig { }

使用

//1、创建ioc容器
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    System.out.println("容器创建完成");
    // 2. 获取
    Mouse mouse = applicationContext.getBean("mouse", Mouse.class);
    System.out.println("mouse -> " + mouse);
    //关闭容器
    applicationContext.close();

Mouse -> Construct
    Mouse -> @PostConstruct
    容器创建完成
    mouse -> org.example.demo.bean.Mouse@7f416310
    Mouse -> @PreDestroy

## 4. BeanPostProcessor相关接口，Bean的后置处理器 ##

@Configuration
    @ComponentScan("org.example.demo.bean")
    public class MainConfig { }

@Component
    public class MyBeanPostProcessor implements BeanPostProcessor { 
        @Override
        public Object postProcessBeforeInitialization(
          Object bean, String beanName) throws BeansException { 
            System.out.printf("postProcessBeforeInitialization -> name:%s \r\n", beanName);
            return bean;
        }
      
        @Override
        public Object postProcessAfterInitialization(
          Object bean, String beanName) throws BeansException { 
            System.out.printf("postProcessAfterInitialization -> name:%s \r\n", beanName);
            return bean;
        }
    }

输出

...一些其他的
    postProcessBeforeInitialization -> name:mainConfig 
    postProcessAfterInitialization -> name:mainConfig 
    cat -> 构造中
    postProcessBeforeInitialization -> name:cat 
    postProcessAfterInitialization -> name:cat 
    容器创建完成
    Cat -> org.example.demo.bean.Cat@73d4cc9e

[1. Spring - IOC -]: https://xiamen.blog.csdn.net/article/details/74248286
[2. spring - IOC -]: https://xiamen.blog.csdn.net/article/details/74248548
[3. Spring - IOC -]: https://xiamen.blog.csdn.net/article/details/74244578
[4. Spring - IOC -]: https://xiamen.blog.csdn.net/article/details/74289487
[5. Spring - IOC -]: https://xiamen.blog.csdn.net/article/details/104066345
[6. Spring - AOP -]: https://xiamen.blog.csdn.net/article/details/104086169