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");
}
}
PostConstruct用于依赖注入完成之后执行初始化方法;
PreDestroy用于在Bean销毁之前执行清理方法
@PostConstruct
public void init(){
System.out.println("Bean is init");
}
@PreDestroy
public void clean(){
System.out.println("PreDestroy!");
}
通过@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");
}
}
}
用于在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初始化都会调这两个方法;慎重使用
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;
}
}
接口定义如下
public interface FactoryBean {
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 {
@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;
}
}
}
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;
}
}
可以获取到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;
}
}
设置在某个环境时激活某个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 实现
}
}
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");
}
}
}