欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

bean生命周期

程序员文章站 2022-06-06 14:25:48
bean生命周期1.指定初始化和销毁方法代码实现1.指定初始化和销毁方法代码实现@ComponentScan("com.ly.springannotation.bean")@Configurationpublic class MainConfigOfLifeCycle { @Bean(initMethod = "init", destroyMethod = "destroy") public Car car() { return new Car(); }...

bean生命周期

bean创建-->初始化-->销毁
容器管理bean的生命周期
1.构造（对象创建）
  单实例：默认在容器启动的时候创建对象
  多实例：在每次获取对象的时候创建对象
BeanPostProcessor.postProcessBeforeInitialization（初始化之前工作）
2.初始化
  对象创建完成，并赋值好，调用初始化方法  
BeanPostProcessor.postProcessAfterInitialization（初始化之后工作）
3.销毁：
  单实例：容器关闭的时候
  多实例：容器不会管理这个bean，容器不会调用销毁方法

初始化和销毁三种方式

1.指定初始化和销毁方法

代码实现（单实例bean）

在配置类当中通过@Bean指定init-method和destroy-method

@ComponentScan("com.ly.springannotation.bean")
@Configuration
public class MainConfigOfLifeCycle {

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

/**
 * @author luoyong
 * @Description: Car
 * @create 2019-12-29 11:39
 * @last modify by [LuoYong 2019-12-29 11:39]
 **/
@Component
public class Car {
    public Car() {
        System.out.println("car...constructor...");
    }

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

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

测试

public class IOCTest_LifeCycle {
    @Test
    public void test01() {
        //1、创建ioc容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
        System.out.println("容器创建完成...");
        //关闭容器的时候销毁对象
        applicationContext.close();
    }
}

测试结果
bean生命周期

多实例的bean

@ComponentScan(value = "com.ly.springannotation.bean",includeFilters = {@ComponentScan.Filter(type =
        FilterType.ASSIGNABLE_TYPE,classes = {Car.class})},useDefaultFilters = false)
@Configuration
public class MainConfigOfLifeCycle {

    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

测试代码

public class IOCTest_LifeCycle {
    @Test
    public void test01() {
        //1、创建ioc容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
        System.out.println("容器创建完成...");
        //多实例bean在获取的时候才会创建对象
        Car car =(Car) applicationContext.getBean("car");
        //关闭容器的时候销毁对象
        applicationContext.close();
    }
}

执行结果
bean生命周期

多 实 例 b e a n 容 器 不 会 管 理 这 个 b e a n ， 不 会 调 用 销 毁 方 法 进 行 销 毁 \color{blue}{多实例bean容器不会管理这个bean，不会调用销毁方法进行销毁} 多实例bean容器不会管理这个bean，不会调用销毁方法进行销毁

2.通过让Bean实现InitializingBean和DisposableBean

I n i t i a l i z i n g B e a n ： 定 义 初 始 化 逻 辑 \color{red}{InitializingBean：定义初始化逻辑} InitializingBean：定义初始化逻辑
D i s p o s a b l e B e a n ： 定 义 销 毁 逻 辑 \color{blue}{DisposableBean：定义销毁逻辑} DisposableBean：定义销毁逻辑

代码实现

@ComponentScan(value = "com.ly.springannotation.bean",includeFilters = {@ComponentScan.Filter(type =
        FilterType.ASSIGNABLE_TYPE,classes = {Cat.class})},useDefaultFilters = false)
@Configuration
public class MainConfigOfLifeCycle {
}

@Component
public class Cat implements InitializingBean, DisposableBean {
    public Cat() {
        System.out.println("Cat...constructor....");
    }

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

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

测试

public class IOCTest_LifeCycle {
    @Test
    public void test01() {
        //1、创建ioc容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
        System.out.println("容器创建完成...");
        //关闭容器的时候销毁对象
        applicationContext.close();
    }
}

测试结果
bean生命周期

3.使用JSR250

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

代码实现

@ComponentScan(value = "com.ly.springannotation.bean",includeFilters = {@ComponentScan.Filter(type =
        FilterType.ASSIGNABLE_TYPE,classes = {Dog.class})},useDefaultFilters = false)
@Configuration
public class MainConfigOfLifeCycle {
}

@Component
public class Dog {

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

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

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

测试

public class IOCTest_LifeCycle {
    @Test
    public void test01() {
        //1、创建ioc容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
        System.out.println("容器创建完成...");
        //关闭容器的时候销毁对象
        applicationContext.close();
    }
}

测试结果
bean生命周期

执行初始化方法前后拦截

BeanPostProcessor

在bean初始化前后进行一些处理工作
postProcessBeforeInitialization:在初始化之前工作
postProcessAfterInitialization:在初始化之后工作

代码实现

@ComponentScan(value = "com.ly.springannotation.bean",includeFilters = {@ComponentScan.Filter(type =
        FilterType.ASSIGNABLE_TYPE,classes = {Dog.class, MyBeanPostProcessor.class})},useDefaultFilters = false)
@Configuration
public class MainConfigOfLifeCycle {
}

@Component
public class Dog{
    public Dog() {
        System.out.println("Dog...constructor...");
    }
    //对象创建并赋值之后调用
    @PostConstruct
    public void init() {
        System.out.println("Dog...init...@PostConstruct...");
    }
    //容器移除对象之前
    @PreDestroy
    public void destroy() {
        System.out.println("Dog ... destroy...@PreDestroy...");
    }
}
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization..." + beanName + "=>" + bean);
        return bean;
    }

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

测试

public class IOCTest_LifeCycle {
    @Test
    public void test01() {
        //1、创建ioc容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
        System.out.println("容器创建完成...");
        //关闭容器的时候销毁对象
        applicationContext.close();
    }
}

测试结果：
bean生命周期

源码

AbstractAutowireCapableBeanFactory 553 populateBean(beanName, mbd, instanceWrapper); 对bean的属性进行赋值
AbstractAutowireCapableBeanFactory 555 exposedObject = initializeBean(beanName, exposedObject, mbd);

AbstractAutowireCapableBeanFactory 1604 初始化实现细节

	protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged(new PrivilegedAction<Object>() {
				@Override
				public Object run() {
					invokeAwareMethods(beanName, bean);
					return null;
				}
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

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

		try {
		    //执行自定义初始化方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}

		if (mbd == null || !mbd.isSynthetic()) {
		    //初始化之后执行
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}

	@Override
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
			result = beanProcessor.postProcessBeforeInitialization(result, beanName);
			if (result == null) {
				return result;
			}
		}
		return result;
	}
		@Override
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
			result = beanProcessor.postProcessAfterInitialization(result, beanName);
			if (result == null) {
				return result;
			}
		}
		return result;
	}

拓展

Spring底层对 BeanPostProcessor 的使用

bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async,xxx 都是实现 BeanPostProcessor来完成的
举例：ApplicationContextAwareProcessor bean当中注入ioc容器

代码实现

@Component
public class Dog implements ApplicationContextAware {

    private ApplicationContext applicationContext;


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

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

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


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

执行链路图
bean生命周期

关键步骤：
AbstractAutowireCapableBeanFactory 1620 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
AbstractAutowireCapableBeanFactory 409 esult = beanProcessor.postProcessBeforeInitialization(result, beanName);
ApplicationContextAwareProcessor 97 invokeAwareInterfaces(bean);
ApplicationContextAwareProcessor 121 
			if (bean instanceof ApplicationContextAware) {
				((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
			}
Dog 42
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

本文地址：https://blog.csdn.net/ly10228/article/details/112062172

相关标签： spring

上一篇： 高兴得说不出话来

下一篇： Win10真的要大改UI了！教你如何体验高颜值UI

推荐阅读