Spring Bean作用域、生命周期与自动装配深入解析

/**
 * 实体类
 */
public class Dog {
}
/**
 * 配置类
 */
@Configuration
public class DogConfig {
    //单例
    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
    public Dog singleDog(){
        return new Dog();
    }
    //原型
    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public Dog prototypeDog(){
        return new Dog();
    }
    //请求
    @Bean
    @RequestScope
    public Dog requestDog(){
        return new Dog();
    }
    //会话
    @Bean
    @SessionScope
    public Dog sessionDog(){
        return new Dog();
    }
    //应用
    @Bean
    @ApplicationScope
    public Dog applicationDog(){
        return new Dog();
    }
}
/**
 * 启动类
 */
@SpringBootApplication
public class SpringPrincipleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringPrincipleApplication.class, args);
    }
}
/**
 * 视图层
 */
@RequestMapping("/test")
@RestController
public class TestController {
    private final Dog single;
    private final Dog prototype;
    private final Dog request;
    private final Dog session;
    private final Dog application;
    private final ApplicationContext context;
    public TestController(@Qualifier("singleDog") Dog single, @Qualifier("prototypeDog") Dog prototype,
                          @Qualifier("requestDog") Dog request, @Qualifier("sessionDog") Dog session,
                          @Qualifier("applicationDog") Dog application, ApplicationContext context) {
        this.single = single;
        this.prototype = prototype;
        this.request = request;
        this.session = session;
        this.application = application;
        this.context = context;
    }
    @RequestMapping("/single")
    public String single(){
        Dog singleDog = (Dog)context.getBean("singleDog");
        return "dog: " + this.single.toString() + "
" + "contextDog: " + singleDog;
    }
    @RequestMapping("/prototype")
    public String prototype(){
        Dog prototypeDog = (Dog)context.getBean("prototypeDog");
        return "dog: " + this.prototype.toString() + "
" + "contextDog: " + prototypeDog;
    }
    @RequestMapping("/request")
    public String request(){
        Dog requestDog = (Dog)context.getBean("requestDog");
        return "dog: " + this.request.toString() + "
" + "contextDog: " + requestDog;
    }
    @RequestMapping("/session")
    public String session(){
        Dog sessionDog = (Dog)context.getBean("sessionDog");
        return "dog: " + this.session.toString() + "
" + "contextDog: " + sessionDog;
    }
    @RequestMapping("/application")
    public String application(){
        Dog applicationDog = (Dog)context.getBean("applicationDog");
        return "dog: " + this.application.toString() + "
" + "contextDog: " + applicationDog;
    }
}

/**
 * 实体类
 */
public class Cat {
}
/**
 * 配置类
 */
@Configuration
public class CatConfig {
    @Bean
    public Cat cat(){
        return new Cat();
    }
}
/**
 * 实现类
 */
@Component
@Slf4j
public class BeanLifeComponent implements BeanNameAware, BeanPostProcessor, InitializingBean {
    private Cat cat;
    //1.实例化:执行构造方法
    public BeanLifeComponent() {
        log.info("1.实例化:执行构造方法");
    }
    //2.属性赋值:执行setter方法
    @Autowired
    public void setCat(Cat cat) {
        log.info("2.属性赋值:执行setter方法");
        this.cat = cat;
    }
    //3.1 通知方法调用
    @Override
    public void setBeanName(String name) {
        log.info("3.1 通知方法调用,bean name is {}", name);
    }
    //3.2 前置处理
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        log.info("3.3 前置处理,bean:{},beanName:{}", bean, beanName);
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }
    //3.3初始化回调
    @Override
    public void afterPropertiesSet() {
        log.info("3.2初始化回调");
    }
    //3.4后置处理
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        log.info("3.4后置处理,bean:{},beanName:{}", bean, beanName);
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
    //4.使用Bean
    public void use(){
        log.info("4.使用Bean");
    }
    //5.销毁Bean
    @PreDestroy
    public void preDestroy(){
        log.info("5.销毁Bean");
    }
}
/**
 * 测试类
 */
@SpringBootTest
class SpringPrincipleApplicationTests {
    private final ApplicationContext context;
    @Autowired
    public SpringPrincipleApplicationTests(ApplicationContext context) {
        this.context = context;
    }
    @Test
    public void test(){
        BeanLifeComponent beanLifeComponent = context.getBean(BeanLifeComponent.class);
        beanLifeComponent.use();
    }
}

/**
 * 配置类
 */
@Slf4j
@Component
public class TestConfig {
    public void demo(){
        log.info("demo");
    }
}
/**
 * 测试类
 */
@SpringBootTest
public class SpringPrincipleApplicationTests {
    private final ApplicationContext context;
    @Autowired
    public SpringPrincipleApplicationTests(ApplicationContext context) {
        this.context = context;
    }
    @Test
    public void demo(){
        TestConfig testConfig = context.getBean(TestConfig.class);
        testConfig.demo();
    }
}

@SpringBootApplication
@ComponentScan("com.example.springprincicle.component")
public class SpringPrincipleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringPrincipleApplication.class, args);
    }
}

@SpringBootApplication
@Import(TestConfig.class)
public class SpringPrincipleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringPrincipleApplication.class, args);
    }
}

@Slf4j
@Component
public class DemoConfig {
    public void demo(){
        log.info("demo");
    }
}
public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.example.springprincicle.component.TestConfig",
                "com.example.springprincicle.component.DemoConfig"};
    }
}
@SpringBootTest
public class SpringPrincipleApplicationTests {
    private final ApplicationContext context;
    @Autowired
    public SpringPrincipleApplicationTests(ApplicationContext context) {
        this.context = context;
    }
    @Test
    public void demo(){
        TestConfig testConfig = context.getBean(TestConfig.class);
        testConfig.demo();
        DemoConfig demoConfig = context.getBean(DemoConfig.class);
        demoConfig.demo();
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(MyImportSelector.class)
public @interface EnableTestConfig {
}
@SpringBootApplication
@EnableTestConfig
public class SpringPrincipleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringPrincipleApplication.class, args);
    }
}

    //JDK源码,AutoConfigurationImportSelector类
    @Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
	}
	protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		configurations = removeDuplicates(configurations);
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
		configurations = getConfigurationClassFilter().filter(configurations);
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}

	//JDK源码,AutoConfigurationImportSelector类
    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		ImportCandidates importCandidates = ImportCandidates.load(this.autoConfigurationAnnotation,
				getBeanClassLoader());//扫描类路径下的 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件
		List<String> configurations = importCandidates.getCandidates();//从 ImportCandidates 对象中获取所有找到的自动配置类名，这些类名是从 .imports 文件中读取的
		Assert.state(!CollectionUtils.isEmpty(configurations),
				"No auto configuration classes found in " + "META-INF/spring/"
						+ this.autoConfigurationAnnotation.getName() + ".imports. If you "
						+ "are using a custom packaging, make sure that file is correct.");
		return configurations;
	}

    //JDK源码,AutoConfigurationImportSelector类
    private void fireAutoConfigurationImportEvents(List<String> configurations, Set<String> exclusions) {
		List<AutoConfigurationImportListener> listeners = getAutoConfigurationImportListeners();
		if (!listeners.isEmpty()) {
			AutoConfigurationImportEvent event = new AutoConfigurationImportEvent(this, configurations, exclusions);
			for (AutoConfigurationImportListener listener : listeners) {
				invokeAwareMethods(listener);
				listener.onAutoConfigurationImportEvent(event);
			}
		}
	}
	protected List<AutoConfigurationImportListener> getAutoConfigurationImportListeners() {
		return SpringFactoriesLoader.loadFactories(AutoConfigurationImportListener.class, this.beanClassLoader);
	}
	public static <T> List<T> loadFactories(Class<T> factoryType, @Nullable ClassLoader classLoader) {
		return forDefaultResourceLocation(classLoader).load(factoryType);
	}
	public static SpringFactoriesLoader forDefaultResourceLocation(@Nullable ClassLoader classLoader) {
		return forResourceLocation(FACTORIES_RESOURCE_LOCATION, classLoader);
	}
	public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";