SpringBoot中操作Bean的生命周期

1.InitializingBean和DisposableBean

InitializingBean接口提供了afterPropertiesSet方法，用于在bean的属性设置好之后调用；

DisposableBean接口提供了destroy方法，用于在bean销毁之后调用；

public class TestComponent implements InitializingBean, DisposableBean { @Override public void destroy() throws Exception { // 清理代码 System.out.println("Bean is destroyed"); } @Override public void afterPropertiesSet() throws Exception { // 初始化代码 System.out.println("Bean is initialized"); } } 2.PostConstruct和PreDestroy

PostConstruct用于依赖注入完成之后执行初始化方法；

PreDestroy用于在Bean销毁之前执行清理方法

@PostConstruct public void init(){ System.out.println("Bean is init"); } @PreDestroy public void clean(){ System.out.println("PreDestroy!"); } 3.Bean 定义的 initMethod 和 destroyMethod

通过@Bean注解的两个属性，指定在Bean初始化和销毁的时候执行指定的方法；

@Configuration public class TestConfig { @Bean(initMethod = "init", destroyMethod = "cleanup") public MyBean myBean() { return new MyBean(); } public static class MyBean { public void init() { System.out.println("myBean init"); } public void cleanup() { System.out.println("myBean cleanup"); } } } 4.BeanPostProcessor接口

用于在bean初始化之前和初始化之后进行某种操作；主要有两个接口

postProcessBeforeInitialization：bean初始化之前执行某种操作

postProcessAfterInitialization：bean初始化之后执行某种操作

@Component public class MyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) { System.out.println("postProcessBeforeInitialization:"+beanName); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) { System.out.println("postProcessAfterInitialization:"+beanName); return bean; } }

注意：系统中的所有bean初始化都会调这两个方法；慎重使用

5.ApplicationContextAware和BeanNameAware ApplicationContextAware提供setApplicationContext，可以获取spring的上下文 BeanNameAware提供setBeanName，可以获取当前bean的名称； @Component public class MyAwareBean implements ApplicationContextAware, BeanNameAware { private String beanName; private static ApplicationContext mApplicationContext; @Override public void setBeanName(String name) { this.beanName = name; // 记录 Bean 名称 log.info("Bean name set to {}", name); } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { mApplicationContext = applicationContext; } } 6.FactoryBean

接口定义如下

public interface FactoryBean<T> { String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType"; @Nullable T getObject() throws Exception; @Nullable Class<?> getObjectType(); default boolean isSingleton() { return true; } }

作用是生成其他bean,示例：

@Component public class MyFactoryBean implements FactoryBean<MyFactoryBean.MyCustomBean> { @Override public MyCustomBean getObject() throws Exception { return new MyCustomBean(); } @Override public Class<?> getObjectType() { return MyCustomBean.class; } public class MyCustomBean { // 自定义 Bean 的逻辑 private String a1 = "test"; public String getA1() { return a1; } } } 7.EnvironmentAware, ResourceLoaderAware

EnvironmentAware提供了setEnvironment，实现了对Environment的操作；

ResourceLoaderAware提供了setResourceLoader，实现了对资源的操作；

@Component public class MyEnvironmentAwareBean implements EnvironmentAware, ResourceLoaderAware { private Environment environment; private ResourceLoader resourceLoader; @Override public void setEnvironment(Environment environment) { this.environment = environment; } @Override public void setResourceLoader(ResourceLoader resourceLoader) { this.resourceLoader = resourceLoader; } } 8.BeanFactoryAware

可以获取到BeanFactory，然后操作spring中的bean

import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.BeanFactoryAware; import org.springframework.stereotype.Component; @Component public class MyBeanFactoryAware implements BeanFactoryAware { private BeanFactory beanFactory; @Override public void setBeanFactory(BeanFactory beanFactory) { this.beanFactory = beanFactory; } } 9.profile

设置在某个环境时激活某个bean

@Configuration public class MyConfiguration { @Bean @Profile("dev") public MyBean devMyBean() { System.out.println("MyBean dev"); return new MyBean(); } @Bean @Profile("prod") public MyBean prodMyBean() { System.out.println("MyBean prod"); return new MyBean(); } public static class MyBean { // Bean 实现 } } 10.@Lazy、@DependsOn、@Order、@Conditional

Lazy用于延迟加载，当bean被注入的时候才进行加载；

DependsOn声明bean之间的依赖顺序，一个bean的加载依赖另外一个bean，确保一个bean先初始化之后，再加载另外一个bean；通常用来管理bean之间初始化顺序和依赖管理；

order用于bean初始化的顺序；

Conditional基于特定的条件才会创建bean；

import org.springframework.context.annotation.*; import org.springframework.core.env.Environment; import org.springframework.core.type.AnnotatedTypeMetadata; @Configuration public class MyConfiguration { @Bean @Conditional({MyCondition.class}) public MyBean myConditionalBean() { return new MyBean(); } public static class MyBean { // Bean 实现 } public static class MyCondition implements Condition { @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { Environment env = context.getEnvironment(); // 定义条件逻辑 return env.containsProperty("my.custom.condition"); } } }