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");
        }
    }
}