Spring Bean 生命周期

最新推荐文章于 2024-10-09 17:12:21 发布
最新推荐文章于 2024-10-09 17:12:21 发布
阅读量146 收藏
点赞数 1
分类专栏： Spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45847167/article/details/115585938
版权

新建 maven 项目，引入spring 依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.5</version>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>RELEASE</version>
    <scope>test</scope>
</dependency>

@Bean 初始化和销毁方法

public class Red {

    public Red() {
        System.out.println("red constructor...");
    }

    public void init() {
        System.out.println("red ... init...");
    }

    public void destroy() {
        System.out.println("red ... destroy...");
    }
}

@Configuration
public class LifeCycleConfig {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Red red() {
        return new Red();
    }
}

public class LifeCycleTest {

    @Test
    public void initAndDestroy() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LifeCycleConfig.class);
        System.out.println("IOC 容器 创建完成...");
        context.close();
        System.out.println("IOC 容器 关闭...");
    }
}

red constructor...
red ... init...
IOC 容器 创建完成...
red ... destroy...
IOC 容器 关闭...

上面Red Bean 默认是单例的，所以在IOC 容器 创建完成之前就已经完成构造器和init方法的调用了。

下面再看下多实例的效果：

标注多实例（@Scope(“prototype”)）

@Scope("prototype")
@Bean(initMethod = "init", destroyMethod = "destroy")
public Red red() {
    return new Red();
}

直接执行上面的测试：

IOC 容器 创建完成...
IOC 容器 关闭...

这是发现对象并没有初始化以及destroy。

修改一下测试方法，获取一下red的bean：

@Test
public void initAndDestroy() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LifeCycleConfig.class);
    System.out.println("IOC 容器 创建完成...");
    Red red = context.getBean(Red.class);
    System.out.println(red);
    context.close();
    System.out.println("IOC 容器 关闭...");
}

IOC 容器 创建完成...
red constructor...
red ... init...
top.wushanghui.annotation.entity.Red@fba92d3
IOC 容器 关闭...

如果是多实例的bean 是在获取的时候才初始化bean的。

InitializingBean和DisposableBean

@Component
public class Blue implements InitializingBean, DisposableBean {

    public Blue() {
        System.out.println("blue constructor...");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("blue destroy...");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("blue afterPropertiesSet...");
    }
}

把上面标注Component注解的类扫描的方式加到容器中：

@ComponentScan("top.wushanghui.annotation.entity")
@Configuration
public class LifeCycleConfig {

@Test
public void testInitializingBeanAndDisposableBean() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LifeCycleConfig.class);
    System.out.println("IOC 容器 创建完成...");
    context.close();
    System.out.println("IOC 容器 关闭...");
}

blue constructor...
blue afterPropertiesSet...
IOC 容器 创建完成...
blue destroy...
IOC 容器 关闭...

JSR250 的@PostConstruct和@PreDestroy

  • @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法。
  • @PreDestroy：在容器销毁bean之前通知我们进行清理工作。
@Component
public class Yellow {


    public Yellow() {
        System.out.println("yellow constructor...");
    }

    //对象创建并赋值之后调用
    @PostConstruct
    public void init() {
        System.out.println("yellow....@PostConstruct...");
    }

    //容器移除对象之前
    @PreDestroy
    public void detory() {
        System.out.println("yellow....@PreDestroy...");
    }
}

@Test
public void testPostConstructAndPreDestroy() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LifeCycleConfig.class);
    System.out.println("IOC 容器 创建完成...");
    context.close();
    System.out.println("IOC 容器 关闭...");
}

blue constructor...
blue afterPropertiesSet...
yellow constructor...
yellow....@PostConstruct...
red constructor...
red ... init...
IOC 容器 创建完成...
red ... destroy...
yellow....@PreDestroy...
blue destroy...
IOC 容器 关闭...

BeanPostProcessor

bean的后置处理器：

  • 在bean初始化前后进行一些处理工作；
  • postProcessBeforeInitialization:在初始化之前工作
  • postProcessAfterInitialization:在初始化之后工作
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization beanName: " + beanName + ", bean: " + bean);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization: " + beanName + ", bean: " + bean);
        return bean;
    }
}

postProcessBeforeInitialization beanName: lifeCycleConfig, bean: top.wushanghui.annotation.config.LifeCycleConfig$$EnhancerBySpringCGLIB$$2da7cc30@2a54a73f
postProcessAfterInitialization: lifeCycleConfig, bean: top.wushanghui.annotation.config.LifeCycleConfig$$EnhancerBySpringCGLIB$$2da7cc30@2a54a73f
blue constructor...
postProcessBeforeInitialization beanName: blue, bean: top.wushanghui.annotation.entity.Blue@505fc5a4
blue afterPropertiesSet...
postProcessAfterInitialization: blue, bean: top.wushanghui.annotation.entity.Blue@505fc5a4
yellow constructor...
postProcessBeforeInitialization beanName: yellow, bean: top.wushanghui.annotation.entity.Yellow@156b88f5
yellow....@PostConstruct...
postProcessAfterInitialization: yellow, bean: top.wushanghui.annotation.entity.Yellow@156b88f5
red constructor...
postProcessBeforeInitialization beanName: red, bean: top.wushanghui.annotation.entity.Red@1a18644
red ... init...
postProcessAfterInitialization: red, bean: top.wushanghui.annotation.entity.Red@1a18644
IOC 容器 创建完成...
red ... destroy...
yellow....@PreDestroy...
blue destroy...
IOC 容器 关闭...

BeanPostProcessor 原理

从 AnnotationConfigApplicationContext 类的有参构造器
-> refresh()
-> finishBeanFactoryInitialization(beanFactory) 实例化所有剩余的（非延迟初始化）单例
-> 调用AbstractApplicationContext类的 finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory)方法
-> 调用 DefaultListableBeanFactory 类的 preInstantiateSingletons() 方法
-> 调用 AbstractBeanFactory 类的 getBean(String name)
-> doGetBean()
-> 调用 DefaultSingletonBeanRegistry 类的 getSingleton()
-> 调用 AbstractAutowireCapableBeanFactory 类的 createBean() -> doCreateBean()

看到此处代码

 // 给bean进行属性赋值
this.populateBean(beanName, mbd, instanceWrapper);
// 初始化
exposedObject = this.initializeBean(beanName, exposedObject, mbd);

-> initializeBean()

if (mbd == null || !mbd.isSynthetic()) {
	// 初始化之前调用 
    wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}

try {
	// 初始化
    this.invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable var6) {
    throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
}

if (mbd == null || !mbd.isSynthetic()) {
	// // 初始化之后调用 
    wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}

源码中可以清楚的看到：遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
        Object result = existingBean;

    Object current;
    for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
        BeanPostProcessor processor = (BeanPostProcessor)var4.next();
        current = processor.postProcessBeforeInitialization(result, beanName);
        if (current == null) {
        	// 为null，跳出循环，后面的BeanPostProcessor.postProcessorsBeforeInitialization 就不会执行了
            return result;
        }
    }

    return result;
}

Spring底层对 BeanPostProcessor 的应用

下图中除了我自己定义的MyBeanPostProcessor ，其他的都是Spring底层对 BeanPostProcessor 的应用
在这里插入图片描述

也附上文字版，方便复制

AdvisorAdapterRegistrationManager (org.springframework.aop.framework.adapter)
MyBeanPostProcessor (top.wushanghui.annotation.entity) // 我自己定义的
BeanPostProcessorChecker in PostProcessorRegistrationDelegate (org.springframework.context.support)
LoadTimeWeaverAwareProcessor (org.springframework.context.weaving)
AbstractAdvisingBeanPostProcessor (org.springframework.aop.framework)
    AbstractBeanFactoryAwareAdvisingPostProcessor (org.springframework.aop.framework.autoproxy)
        MethodValidationPostProcessor (org.springframework.validation.beanvalidation)
        AsyncAnnotationBeanPostProcessor (org.springframework.scheduling.annotation) // 处理Async注解的，异步方法
DestructionAwareBeanPostProcessor (org.springframework.beans.factory.config)
    ScheduledAnnotationBeanPostProcessor (org.springframework.scheduling.annotation)
    InitDestroyAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation) // 用来处理@PostConstruct和@PreDestroy 这两个注解的，
        CommonAnnotationBeanPostProcessor (org.springframework.context.annotation)
    ApplicationListenerDetector (org.springframework.context.support)
ApplicationContextAwareProcessor (org.springframework.context.support) // 用来给组件注入IOC 容器
MergedBeanDefinitionPostProcessor (org.springframework.beans.factory.support)
    ScheduledAnnotationBeanPostProcessor (org.springframework.scheduling.annotation)
    InitDestroyAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
        CommonAnnotationBeanPostProcessor (org.springframework.context.annotation)
    RequiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
    AutowiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
    ApplicationListenerDetector (org.springframework.context.support)
BeanValidationPostProcessor (org.springframework.validation.beanvalidation) // 对属性的校验
InstantiationAwareBeanPostProcessor (org.springframework.beans.factory.config)
    SmartInstantiationAwareBeanPostProcessor (org.springframework.beans.factory.config)
        ScriptFactoryPostProcessor (org.springframework.scripting.support)
        RequiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
        AutowiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation) // 处理Autowired 注解，我们为什么标了@Autowired 就能自动装配好呢，都是AutowiredAnnotationBeanPostProcessor 帮我们处理的
        InstantiationAwareBeanPostProcessorAdapter (org.springframework.beans.factory.config)
        AbstractAutoProxyCreator (org.springframework.aop.framework.autoproxy)
            BeanNameAutoProxyCreator (org.springframework.aop.framework.autoproxy)
            AbstractAdvisorAutoProxyCreator (org.springframework.aop.framework.autoproxy)
                DefaultAdvisorAutoProxyCreator (org.springframework.aop.framework.autoproxy)
                AspectJAwareAdvisorAutoProxyCreator (org.springframework.aop.aspectj.autoproxy)
                    AnnotationAwareAspectJAutoProxyCreator (org.springframework.aop.aspectj.annotation)
                InfrastructureAdvisorAutoProxyCreator (org.springframework.aop.framework.autoproxy)
    ImportAwareBeanPostProcessor in ConfigurationClassPostProcessor (org.springframework.context.annotation)
    CommonAnnotationBeanPostProcessor (org.springframework.context.annotation)

上面有很多spring 对 BeanPostProcessor 的应用，我们看其中一个来具体分析下，ApplicationContextAwareProcessor ，怎么样才能给我们自己定义bean 注入 IOC容器呢？

/**
 * {@link BeanPostProcessor} implementation that supplies the {@code ApplicationContext},
 * {@link org.springframework.core.env.Environment Environment}, or
 * {@link StringValueResolver} for the {@code ApplicationContext} to beans that
 * implement the {@link EnvironmentAware}, {@link EmbeddedValueResolverAware},
 * {@link ResourceLoaderAware}, {@link ApplicationEventPublisherAware},
 * {@link MessageSourceAware}, and/or {@link ApplicationContextAware} interfaces.
 *
 * <p>Implemented interfaces are satisfied in the order in which they are
 * mentioned above.
 *
 * <p>Application contexts will automatically register this with their underlying bean factory. Applications do not use this directly.
 *
 * @author Juergen Hoeller
 * @author Costin Leau
 * @author Chris Beams
 * @since 10.10.2003
 * @see org.springframework.context.EnvironmentAware
 * @see org.springframework.context.EmbeddedValueResolverAware
 * @see org.springframework.context.ResourceLoaderAware
 * @see org.springframework.context.ApplicationEventPublisherAware
 * @see org.springframework.context.MessageSourceAware
 * @see org.springframework.context.ApplicationContextAware
 * @see org.springframework.context.support.AbstractApplicationContext#refresh()
 */
class ApplicationContextAwareProcessor implements BeanPostProcessor {

	private final ConfigurableApplicationContext applicationContext;

	private final StringValueResolver embeddedValueResolver;


	/**
	 * 为给定上下文创建一个新的ApplicationContextAwareProcessor。
	 */
	public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
		this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
	}


	@Override
	@Nullable
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// 如果bean不是以下 XxxxAware 的实例的话，直接返回当前bean
		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
				bean instanceof ApplicationStartupAware)) {
			return bean;
		}

		AccessControlContext acc = null;

		if (System.getSecurityManager() != null) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
			invokeAwareInterfaces(bean);
		}

		return bean;
	}

	// 给当前bean set applicationContext
	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationStartupAware) {
			((ApplicationStartupAware) bean).setApplicationStartup(this.applicationContext.getApplicationStartup());
		}
		// 如果是实现了ApplicationContextAware 接口的bean，给这个bean 注入applicationContext
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}

}

看了上面源码就知道怎么给自己定义bean 注入 IOC容器了。

定义一个ApplicationContextAware 接口的实现类

@Component
public class Green implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    public ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

测试一下是否注入了ApplicationContext ：

@Test
public void testApplicationContextAware() {
    ApplicationContext context = new AnnotationConfigApplicationContext(LifeCycleConfig.class);
    Green bean = context.getBean(Green.class);
    System.out.println(context);
    System.out.println(bean.getApplicationContext());
    System.out.println(context == bean.getApplicationContext());
}

org.springframework.context.annotation.AnnotationConfigApplicationContext@1e4a7dd4, started on Sun Apr 11 10:04:39 CST 2021
org.springframework.context.annotation.AnnotationConfigApplicationContext@1e4a7dd4, started on Sun Apr 11 10:04:39 CST 2021
true

Spring定义了很多XxxxAware以及XxxxAware相关功能的实现类：

在这里插入图片描述

文字全列出来，方便复制：

ApplicationEventPublisherAware (org.springframework.context)
    EventPublicationInterceptor (org.springframework.context.event)
MessageSourceAware (org.springframework.context)
ResourceLoaderAware (org.springframework.context)
    ReloadableResourceBundleMessageSource (org.springframework.context.support)
    ConfigurationClassPostProcessor (org.springframework.context.annotation)
    ScriptFactoryPostProcessor (org.springframework.scripting.support)
    ClassPathScanningCandidateComponentProvider (org.springframework.context.annotation)
        ClassPathBeanDefinitionScanner (org.springframework.context.annotation)
ApplicationStartupAware (org.springframework.context)
    ConfigurationClassPostProcessor (org.springframework.context.annotation)
NotificationPublisherAware (org.springframework.jmx.export.notification)
BeanFactoryAware (org.springframework.beans.factory)
    AnnotationJmxAttributeSource (org.springframework.jmx.export.annotation)
    AbstractBeanFactoryAwareAdvisingPostProcessor (org.springframework.aop.framework.autoproxy)
        MethodValidationPostProcessor (org.springframework.validation.beanvalidation)
        AsyncAnnotationBeanPostProcessor (org.springframework.scheduling.annotation)
    AbstractBeanFactoryBasedTargetSourceCreator (org.springframework.aop.framework.autoproxy.target)
        QuickTargetSourceCreator (org.springframework.aop.framework.autoproxy.target)
        LazyInitTargetSourceCreator (org.springframework.aop.framework.autoproxy.target)
    ScriptFactoryPostProcessor (org.springframework.scripting.support)
    PropertyPathFactoryBean (org.springframework.beans.factory.config)
    SimpleBeanFactoryAwareAspectInstanceFactory (org.springframework.aop.config)
    AbstractApplicationEventMulticaster (org.springframework.context.event)
        SimpleApplicationEventMulticaster (org.springframework.context.event)
    AbstractFactoryBean (org.springframework.beans.factory.config)
        MapFactoryBean (org.springframework.beans.factory.config)
        ListFactoryBean (org.springframework.beans.factory.config)
        SetFactoryBean (org.springframework.beans.factory.config)
        ObjectFactoryCreatingFactoryBean (org.springframework.beans.factory.config)
        ProviderCreatingFactoryBean (org.springframework.beans.factory.config)
        AbstractServiceLoaderBasedFactoryBean (org.springframework.beans.factory.serviceloader)
            ServiceListFactoryBean (org.springframework.beans.factory.serviceloader)
            ServiceLoaderFactoryBean (org.springframework.beans.factory.serviceloader)
            ServiceFactoryBean (org.springframework.beans.factory.serviceloader)
    EnhancedConfiguration in ConfigurationClassEnhancer (org.springframework.context.annotation)
    ScheduledAnnotationBeanPostProcessor (org.springframework.scheduling.annotation)
    CommonAnnotationBeanPostProcessor (org.springframework.context.annotation)
    GroovyScriptFactory (org.springframework.scripting.groovy)
    AbstractBeanFactoryPointcutAdvisor (org.springframework.aop.support)
        DefaultBeanFactoryPointcutAdvisor (org.springframework.aop.support)
        BeanFactoryCacheOperationSourceAdvisor (org.springframework.cache.interceptor)
    ServiceLocatorFactoryBean (org.springframework.beans.factory.config)
    AsyncExecutionAspectSupport (org.springframework.aop.interceptor)
        AsyncExecutionInterceptor (org.springframework.aop.interceptor)
            AnnotationAsyncExecutionInterceptor (org.springframework.scheduling.annotation)
    CacheAspectSupport (org.springframework.cache.interceptor)
        CacheInterceptor (org.springframework.cache.interceptor)
    MethodLocatingFactoryBean (org.springframework.aop.config)
    AbstractBeanFactoryBasedTargetSource (org.springframework.aop.target)
        SimpleBeanTargetSource (org.springframework.aop.target)
        LazyInitTargetSource (org.springframework.aop.target)
            NotificationPublisherAwareLazyTargetSource in MBeanExporter (org.springframework.jmx.export)
        AbstractPrototypeBasedTargetSource (org.springframework.aop.target)
            AbstractPoolingTargetSource (org.springframework.aop.target)
                CommonsPool2TargetSource (org.springframework.aop.target)
            ThreadLocalTargetSource (org.springframework.aop.target)
            PrototypeTargetSource (org.springframework.aop.target)
    MBeanExporter (org.springframework.jmx.export)
        AnnotationMBeanExporter (org.springframework.jmx.export.annotation)
    MethodInvokingBean (org.springframework.beans.factory.config)
        MethodInvokingFactoryBean (org.springframework.beans.factory.config)
    ProxyFactoryBean (org.springframework.aop.framework)
    JndiObjectFactoryBean (org.springframework.jndi)
    AsyncAnnotationAdvisor (org.springframework.scheduling.annotation)
    GenericTypeAwareAutowireCandidateResolver (org.springframework.beans.factory.support)
        QualifierAnnotationAutowireCandidateResolver (org.springframework.beans.factory.annotation)
            ContextAnnotationAutowireCandidateResolver (org.springframework.context.annotation)
    PlaceholderConfigurerSupport (org.springframework.beans.factory.config)
        PropertySourcesPlaceholderConfigurer (org.springframework.context.support)
        PropertyPlaceholderConfigurer (org.springframework.beans.factory.config)
            PreferencesPlaceholderConfigurer (org.springframework.beans.factory.config)
    AbstractAutoProxyCreator (org.springframework.aop.framework.autoproxy)
        BeanNameAutoProxyCreator (org.springframework.aop.framework.autoproxy)
        AbstractAdvisorAutoProxyCreator (org.springframework.aop.framework.autoproxy)
            DefaultAdvisorAutoProxyCreator (org.springframework.aop.framework.autoproxy)
            AspectJAwareAdvisorAutoProxyCreator (org.springframework.aop.aspectj.autoproxy)
                AnnotationAwareAspectJAutoProxyCreator (org.springframework.aop.aspectj.annotation)
            InfrastructureAdvisorAutoProxyCreator (org.springframework.aop.framework.autoproxy)
    DefaultLifecycleProcessor (org.springframework.context.support)
    AspectJExpressionPointcutAdvisor (org.springframework.aop.aspectj)
    RequiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
    AutowiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
    ScopedProxyFactoryBean (org.springframework.aop.scope)
    MBeanExportConfiguration (org.springframework.context.annotation)
    LoadTimeWeaverAwareProcessor (org.springframework.context.weaving)
    CacheProxyFactoryBean (org.springframework.cache.interceptor)
    AspectJExpressionPointcut (org.springframework.aop.aspectj)
    BeanConfigurerSupport (org.springframework.beans.factory.wiring)
EnvironmentAware (org.springframework.context)
    ConfigurationClassPostProcessor (org.springframework.context.annotation)
    PropertySourcesPlaceholderConfigurer (org.springframework.context.support)
    MBeanExportConfiguration (org.springframework.context.annotation)
EmbeddedValueResolverAware (org.springframework.context)
    ScheduledAnnotationBeanPostProcessor (org.springframework.scheduling.annotation)
    FormattingConversionServiceFactoryBean (org.springframework.format.support)
    FormattingConversionService (org.springframework.format.support)
        DefaultFormattingConversionService (org.springframework.format.support)
    EmbeddedValueResolutionSupport (org.springframework.context.support)
        NumberFormatAnnotationFormatterFactory (org.springframework.format.number)
        Jsr354NumberFormatAnnotationFormatterFactory (org.springframework.format.number.money)
        JodaDateTimeFormatAnnotationFormatterFactory (org.springframework.format.datetime.joda)
        DateTimeFormatAnnotationFormatterFactory (org.springframework.format.datetime)
        Jsr310DateTimeFormatAnnotationFormatterFactory (org.springframework.format.datetime.standard)
ImportAware (org.springframework.context.annotation)
    AbstractAsyncConfiguration (org.springframework.scheduling.annotation)
        ProxyAsyncConfiguration (org.springframework.scheduling.annotation)
    AbstractCachingConfiguration (org.springframework.cache.annotation)
        ProxyCachingConfiguration (org.springframework.cache.annotation)
    LoadTimeWeavingConfiguration (org.springframework.context.annotation)
    MBeanExportConfiguration (org.springframework.context.annotation)
LoadTimeWeaverAware (org.springframework.context.weaving)
    AspectJWeavingEnabler (org.springframework.context.weaving)
BeanNameAware (org.springframework.beans.factory)
    ScheduledAnnotationBeanPostProcessor (org.springframework.scheduling.annotation)
    ExecutorConfigurationSupport (org.springframework.scheduling.concurrent)
        ThreadPoolTaskExecutor (org.springframework.scheduling.concurrent)
        ScheduledExecutorFactoryBean (org.springframework.scheduling.concurrent)
        ThreadPoolExecutorFactoryBean (org.springframework.scheduling.concurrent)
        ThreadPoolTaskScheduler (org.springframework.scheduling.concurrent)
    ConcurrentMapCacheFactoryBean (org.springframework.cache.concurrent)
    PropertyPathFactoryBean (org.springframework.beans.factory.config)
    DefaultAdvisorAutoProxyCreator (org.springframework.aop.framework.autoproxy)
    TaskExecutorFactoryBean (org.springframework.scheduling.config)
    PlaceholderConfigurerSupport (org.springframework.beans.factory.config)
        PropertySourcesPlaceholderConfigurer (org.springframework.context.support)
        PropertyPlaceholderConfigurer (org.springframework.beans.factory.config)
            PreferencesPlaceholderConfigurer (org.springframework.beans.factory.config)
    FieldRetrievingFactoryBean (org.springframework.beans.factory.config)
    AbstractRefreshableConfigApplicationContext (org.springframework.context.support)
        AbstractXmlApplicationContext (org.springframework.context.support)
            FileSystemXmlApplicationContext (org.springframework.context.support)
            ClassPathXmlApplicationContext (org.springframework.context.support)
BeanClassLoaderAware (org.springframework.beans.factory)
    MBeanProxyFactoryBean (org.springframework.jmx.access)
    JndiRmiProxyFactoryBean (org.springframework.remoting.rmi)
    DefaultContextLoadTimeWeaver (org.springframework.context.weaving)
    ScriptFactoryPostProcessor (org.springframework.scripting.support)
    BshScriptFactory (org.springframework.scripting.bsh)
    LocalStatelessSessionProxyFactoryBean (org.springframework.ejb.access)
    AbstractApplicationEventMulticaster (org.springframework.context.event)
        SimpleApplicationEventMulticaster (org.springframework.context.event)
    StandardScriptFactory (org.springframework.scripting.support)
    ConcurrentMapCacheManager (org.springframework.cache.concurrent)
    AbstractFactoryBean (org.springframework.beans.factory.config)
        MapFactoryBean (org.springframework.beans.factory.config)
        ListFactoryBean (org.springframework.beans.factory.config)
        SetFactoryBean (org.springframework.beans.factory.config)
        ObjectFactoryCreatingFactoryBean (org.springframework.beans.factory.config)
        ProviderCreatingFactoryBean (org.springframework.beans.factory.config)
        AbstractServiceLoaderBasedFactoryBean (org.springframework.beans.factory.serviceloader)
            ServiceListFactoryBean (org.springframework.beans.factory.serviceloader)
            ServiceLoaderFactoryBean (org.springframework.beans.factory.serviceloader)
            ServiceFactoryBean (org.springframework.beans.factory.serviceloader)
    ResourceBundleMessageSource (org.springframework.context.support)
    ResourceBundleThemeSource (org.springframework.ui.context.support)
    SimpleRemoteStatelessSessionProxyFactoryBean (org.springframework.ejb.access)
    GroovyScriptFactory (org.springframework.scripting.groovy)
    MBeanServerConnectionFactoryBean (org.springframework.jmx.support)
    ProxyProcessorSupport (org.springframework.aop.framework)
        AbstractAdvisingBeanPostProcessor (org.springframework.aop.framework)
            AbstractBeanFactoryAwareAdvisingPostProcessor (org.springframework.aop.framework.autoproxy)
                MethodValidationPostProcessor (org.springframework.validation.beanvalidation)
                AsyncAnnotationBeanPostProcessor (org.springframework.scheduling.annotation)
        AbstractAutoProxyCreator (org.springframework.aop.framework.autoproxy)
            BeanNameAutoProxyCreator (org.springframework.aop.framework.autoproxy)
            AbstractAdvisorAutoProxyCreator (org.springframework.aop.framework.autoproxy)
                DefaultAdvisorAutoProxyCreator (org.springframework.aop.framework.autoproxy)
                AspectJAwareAdvisorAutoProxyCreator (org.springframework.aop.aspectj.autoproxy)
                    AnnotationAwareAspectJAutoProxyCreator (org.springframework.aop.aspectj.annotation)
                InfrastructureAdvisorAutoProxyCreator (org.springframework.aop.framework.autoproxy)
    InterfaceBasedMBeanInfoAssembler (org.springframework.jmx.export.assembler)
    MBeanExporter (org.springframework.jmx.export)
        AnnotationMBeanExporter (org.springframework.jmx.export.annotation)
    FieldRetrievingFactoryBean (org.springframework.beans.factory.config)
    MethodInvokingBean (org.springframework.beans.factory.config)
        MethodInvokingFactoryBean (org.springframework.beans.factory.config)
    ProxyFactoryBean (org.springframework.aop.framework)
    ServiceLoaderFactoryBean (org.springframework.beans.factory.serviceloader)
    BshScriptEvaluator (org.springframework.scripting.bsh)
    JndiObjectFactoryBean (org.springframework.jndi)
    LoadTimeWeavingConfiguration (org.springframework.context.annotation)
    MethodInvokingRunnable (org.springframework.scheduling.support)
    AspectJWeavingEnabler (org.springframework.context.weaving)
    RmiProxyFactoryBean (org.springframework.remoting.rmi)
    ServiceFactoryBean (org.springframework.beans.factory.serviceloader)
    CustomScopeConfigurer (org.springframework.beans.factory.config)
    AbstractSingletonProxyFactoryBean (org.springframework.aop.framework)
        CacheProxyFactoryBean (org.springframework.cache.interceptor)
    RemotingSupport (org.springframework.remoting.support)
        RemoteExporter (org.springframework.remoting.support)
            RemoteInvocationBasedExporter (org.springframework.remoting.support)
                RemoteInvocationSerializingExporter (org.springframework.remoting.rmi)
                RmiBasedExporter (org.springframework.remoting.rmi)
                    JndiRmiServiceExporter (org.springframework.remoting.rmi)
                    RmiServiceExporter (org.springframework.remoting.rmi)
        RemoteAccessor (org.springframework.remoting.support)
            UrlBasedRemoteAccessor (org.springframework.remoting.support)
                RemoteInvocationBasedAccessor (org.springframework.remoting.support)
                    RmiClientInterceptor (org.springframework.remoting.rmi)
                        RmiProxyFactoryBean (org.springframework.remoting.rmi)
    ServiceListFactoryBean (org.springframework.beans.factory.serviceloader)
    ConfigurationClassPostProcessor (org.springframework.context.annotation)
    CustomAutowireConfigurer (org.springframework.beans.factory.annotation)
    GroovyScriptEvaluator (org.springframework.scripting.groovy)
    MBeanClientInterceptor (org.springframework.jmx.access)
        MBeanProxyFactoryBean (org.springframework.jmx.access)
    StandardScriptEvaluator (org.springframework.scripting.support)
    AbstractServiceLoaderBasedFactoryBean (org.springframework.beans.factory.serviceloader)
        ServiceListFactoryBean (org.springframework.beans.factory.serviceloader)
        ServiceLoaderFactoryBean (org.springframework.beans.factory.serviceloader)
        ServiceFactoryBean (org.springframework.beans.factory.serviceloader)
ApplicationContextAware (org.springframework.context)
    ScheduledAnnotationBeanPostProcessor (org.springframework.scheduling.annotation)
    Green (top.wushanghui.annotation.entity)
    LiveBeansView (org.springframework.context.support)
    EventListenerMethodProcessor (org.springframework.context.event)
    LocalValidatorFactoryBean (org.springframework.validation.beanvalidation)
        OptionalValidatorFactoryBean (org.springframework.validation.beanvalidation)
    ApplicationObjectSupport (org.springframework.context.support)

总结

文章
https://snailclimb.gitee.io/javaguide/#/docs/system-design/framework/spring/Spring%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98%E6%80%BB%E7%BB%93?id=_5-spring-bean

中总结到：

  1. Bean 容器找到配置文件中 Spring Bean 的定义。
  2. Bean 容器利用 Java Reflection API 创建一个Bean的实例。
  3. 如果涉及到一些属性值 利用 set()方法设置一些属性值。
  4. 如果 Bean 实现了 BeanNameAware 接口，调用 setBeanName()方法，传入Bean的名字。
  5. 如果 Bean 实现了 BeanClassLoaderAware 接口，调用 setBeanClassLoader()方法，传入 ClassLoader对象的实例。
  6. 与上面的类似，如果实现了其他 *.Aware接口，就调用相应的方法。
  7. 如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象，执行postProcessBeforeInitialization() 方法
  8. 如果Bean实现了InitializingBean接口，执行afterPropertiesSet()方法。
  9. 如果 Bean 在配置文件中的定义包含 init-method 属性，执行指定的方法。
  10. 如果有和加载这个 Bean的 Spring 容器相关的 BeanPostProcessor 对象，执行postProcessAfterInitialization() 方法
  11. 当要销毁 Bean 的时候，如果 Bean 实现了 DisposableBean 接口，执行 destroy() 方法。
  12. 当要销毁 Bean 的时候，如果 Bean 在配置文件中的定义包含 destroy-method 属性，执行指定的方法。

在这里插入图片描述

逆流者blog
关注
专栏目录
SpringBean生命周期详解
weixin_43244698的博客
10-28 9575
SpringBean生命周期详解 一、简述： Spring是我们每天都在使用的框架，Bean是被Spring管理的Java对象，是Spring框架最重要的部分之一，那么让我们一起了解一下Spring中Bean的生命周期是怎样的吧 二、流程图 我们先从宏观的角度看一下Spring的生命周期： ![在这里插入图片描述](https://img-blog.csdnimg.cn/20201028174058916.png?x-oss-process=image/watermark,t ype_ZmFuZ3poZW5
Spring Bean生命周期详解
热门推荐
weixin_45723046的博客
04-10 1万+
站在设计者的角度考虑设计IOC容器 加载Bean的配置（比如xml配置） 比如不同类型资源的加载，解析成生成统一Bean的定义 根据Bean的定义加载生成Bean的实例，并放置在Bean容器中 比如Bean的依赖注入，Bean的嵌套，Bean存放（缓存）等 除了基础Bean外，还有常规针对企业级业务的特别Bean 比如国际化Message，事件Event等生成特殊的类结构去支撑 对容器中的Bean提供统一的管理和调用 比如用工厂模式管理，提供方法根据名字/类的类型等从容器中获取Bea
spring数据校验
南城余coding的博客
12-12 246
spring数据校验
spring的启动过程04-bean后置处理器
stone3gao的博客
12-30 1689
概述： spring在初始化bean实例的过程中，需要做个性化的处理如解析注解，每个注解的解析逻辑千变万化有spring自带的有用户自定义的。这里spring就想到了采用注册bean处理器的方式处理个性化需求，该种方式类似于intercept功能，又类似于AOP横向切面的概念，因为它同样提供前置处理逻辑及后置处理逻辑，下面具体分析下这种方式的实现过程。 原理： 找到注册bean处理器的触发点
源码通透-sprin-IOC-Bean的完整生命周期
arthur.dy.lee的专栏
04-27 1625
Bean的完整生命周期 一、生命周期顺序 bean的生命周期 1、在IOC容器中，一个spring bean是通过类的构造器(class constractor)生成的 2、使用setter方法执行依赖注入 3、一旦依赖注入完成， BeanNameAware.setBeanName()被调用。在创建它的bean factory中，该bean的名字被设置 4、调用BeanClassLoaderA...
Spring源码-AOP(六)-自动代理与DefaultAdvisorAutoProxyCreator
weixin_34138139的博客
08-21 371
2019独角兽企业重金招聘Python工程师标准>>> ...
【小家Spring】Spring AOP的核心类：AbstractAdvisorAutoProxy自动代理创建器深度剖析（AnnotationAwareAspectJAutoProxyCreator）
架构师：通透，才能写出好代码！
04-16 6458
前言 上篇博文：【小家Spring】面向切面编程之—Spring AOP的原理讲解以及源码分析（Cannot find current proxy: Set ‘exposeProxy’ property on ） 已经刚刚结合实例，介绍了Spring AOP的过程原理以及对源码进行了逐步分析~ 但是这中间当时事忽略了整个Spring AOP最为核心的一个类：自动代理创建器。 因此本文将以Annot...
谈谈我对Spring Bean 生命周期的理解
08-27
Spring Bean 生命周期是 Spring 框架中的一个核心概念，了解 Spring Bean 的生命周期对我们了解整个 Spring 框架会有很大的帮助。本文将详细介绍 Spring Bean 生命周期的概念、生命周期图、生命周期阶段、生命周期...
spring bean的生命周期
01-16
- **XML配置**：在传统的Spring应用中，Bean的定义通常写在XML配置文件中，如`springbean-xml`中的配置。 - **注解配置**：使用`@Component`，`@Service`，`@Repository`和`@Controller`注解标记类，配合`@...
Spring扩展点
许诗宇的博客
03-06 559
目录 BeanDefinition与BeanFactory扩展 BeanDefinitionRegistryPostProcessor接口 BeanFactoryPostProcessor接口 Bean实例化中的扩展 InstantiationAwareBeanPostProcessor接口 SmartInstantiationAwareBeanPostProcessor接口 BeanPostProcessor接口 MergedBeanDefinitionPostProcessor Des
Spring源码解析之-- 事务InfrastructureAdvisorAutoProxyCreator 分析
一直打铁
03-12 2099
目录一、介绍二、InfrastructureAdvisorAutoProxyCreator 分析2.1 结构2.1 解析2.1.1 postProcessBeforeInstantiation2.1.2 postProcessAfterInitialization2.1.3 wrapIfNecessary2.1.4 getAdvicesAndAdvisorsForBean2.1.4 findEligibleAdvisors2.1.4 findAdvisorBeans2.1.5 AopUtils#findAd
Gradle自动化构建(三) Groovy 闭包
huanghuangjin的博客
05-17 145
闭包与字符串 String str = '2 + 3 = 5,abc' println str.each { // 2 + 3 = 5,abc2 + 3 = 5,abc ， 字符串的遍历，返回值为变量 str 本身 String tmp -&amp;amp;amp;gt; print tmp } println str.find { // 2 ， find的闭包是 由一个String形参，返回值为boolea...
源码通透-IOC-Bean的完整生命周期
arthur.dy.lee的专栏
04-27 396
Bean的完整生命周期 文章目录Bean的完整生命周期一、生命周期顺序二、Bean的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类三、AbstractAutowireCapableBeanFactory#createBean3.1 AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation3.1.1 AbstractAut...
RabbitTemplate与AmqpTemplate：Spring AMQP中的消息传递模板
qq_51321722的博客
10-05 596
是Spring AMQP框架的核心接口，它定义了一套标准的AMQP操作，如发送和接收消息、声明队列和交换机等。这个接口是对AMQP协议的抽象，提供了一种面向对象的方式来操作AMQP协议。它基于RabbitMQ的Java客户端库实现，使得开发者可以通过Spring框架的依赖注入和配置机制来简化与AMQP消息队列系统的交互。而则是Spring AMQP为RabbitMQ提供的一个高级消息操作模板。它实现了接口，并添加了一些针对RabbitMQ的特性和优化。不仅提供了与。
【Spring Security】基于SpringBoot3.3.4版本②如何配置免鉴权Path
Java技术栈，分享不断学习、不断超越、不断积累的历程！
10-03 1287
[【Spring Security】基于SpringBoot3.3.4版本①整合JWT的使用教程](https://blog.csdn.net/friendlytkyj/article/details/142679120) 在这篇文章中，详细演示了使用最新版`Spring Boot`，完成一个微服务开发，并使用`Spring Security`组件完成登录认证，同时整合了`JWT`，使用的`RSA`公私钥签名、验签。 接下来继续讲解下一个业务场景：一个真实场景的微服务，难免会有一些请求`Path`不需要任
springboot实战学习（12）(优化更新用户基本信息接口)(Validation实体参数校验)
岁岁岁平安的博客
10-09 649
本篇博客主要是对用户模块的更新用户基本信息接口的代码的一个小优化（实体参数校验）。其中用到了Spring Validation参数校验框架提供的一些注解（如@NotNull、@NotEmpty、@Email、@Validated）去完成实体类对象的参数校验以及完成了功能的测试...
springboot 整合 rabbitMQ（2）
最新发布
WYH1233211234567的博客
10-09 760
解决重复消费问题，实现订阅者模式
Spring Bean生命周期详解与示例
在Spring框架中，Bean的生命周期管理是至关重要的，它涉及到从Bean的创建、初始化到销毁的整个过程。...对于学习Spring框架或进行Spring项目开发的人员来说，深入理解Bean生命周期是必不可少的知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值