Spring注解--bean生命周期的相关方法

bean对象的生命周期主要是：实例的创建→实例的初始化→实例的销毁，三个时刻，对应着类中三个方法：

构造器、类的初始化方法（无特殊情况，类实例化后立即执行此方法）、实例销毁时立即执行的方法。

1.通过@Bean指定init-method和destroy-method；

2.通过让Bean实现InitializingBean（定义初始化逻辑）， DisposableBean（定义销毁逻辑）；

3.可以使用JSR250；
@PostConstruct：在bean创建及属性赋值完成之后来执行初始化方法
@PreDestroy：在容器销毁bean之前通知我们进行清理工作

4.BeanPostProcessor【interface】：bean的后置处理器；在bean初始化前后进行一些处理工作；

方式一：注解@Bean(initMethod="init",destroyMethod="destory") 中定义着bean实例生命周期中初始化时对应的方法init()

和bean实例销毁时，需l立即执行的方法destory()

1.@bean注解中定义对应类周期方法

@ComponentScan("com.rsd.bean")
@Configuration
public class MainConfigOfLifeCycle {
//指定Car.java实例化后，执行init方法进行初始化,实例销毁时，将执行destory方法
	@Bean(initMethod="init",destroyMethod="destory")  
	public Car car(){
		return new Car();
	}
}

2.需实例化的类中对应的周期方法 ===》初始化方法：init() 和bean实例销毁前立即执行的方法 destroy()

public class Car {
	public Car(){
		System.out.println("car.... constructor...");
	}
	//除特殊情况外，类实例化后执行此方法，对bean属性进行初始化
	public void init(){
		System.out.println("car...init....");
	}
	
	public void destory(){
		System.out.println("car...destory....");
	}
}

测试案例：

public class IOCTest_LifeCycle {
	@SuppressWarnings("resource")
	@Test
	public void test01(){
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
		System.out.println("容器创建完成.....");
		//非单类模式下，调用bean时，才创建bean
		applicationContext.getBean("car");
		/*
                 在单例模式下构建的bean，关闭容器，也就销毁bean
                 在多实例模式下构建的bean,关闭容器，不会销毁bean
                */   
		applicationContext.close();
	}
}

运行结果：

car.... constructor...
car...init....
容器创建完成.....
car...destory....

方式二：bean类实现InitializingBean,DisposableBean两接口（使用较少）

InitializingBean接口中含有afterPropertiesSet()抽象方法

DisposableBean接口中含有destroy()抽象方法


@Component
public class Cat implements InitializingBean,DisposableBean {
	//实例化时执行构造器
	public Cat(){
		System.out.println("cat constructor...");
	}
	//bean实例销毁时，立即执行此方法
	@Override
	public void destroy() throws Exception {
		System.out.println("cat destroy...");
		
	}
        //初始化时的方法
	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("cat..... afterPropertiesSet");	
	}
}

配置类：通过扫描包，将满足条件的bean（Cat类进行实例化）注册到容器

@ComponentScan("com.rsd.bean")
@Configuration
public class MainConfigOfLifeCycle {}

测试类

public class IOCTest_LifeCycle {
	@SuppressWarnings("resource")
	@Test
	public void test01(){
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
		System.out.println("容器创建完成.....");
		 
		//关闭容器同时，销毁容器创建的实例
		applicationContext.close();
	}
}

运行测试案例，其结果为：

cat constructor...
cat..... afterPropertiesSet
容器创建完成.....

cat destroy...

方式三：可以使用JSR250；
@PostConstruct所修饰的方法：在bean创建及属性赋值完成之后来执行初始化方法
@PreDestroy所修饰的方法：在容器销毁bean之前通知我们进行清理工作

@Component
public class Dog {
	public Dog(){
		System.out.println("Dog constructor...");
	}
	//构造器执行之后执行(就是可以进行初始化操作)
	@PostConstruct
	public void init(){
		System.out.println("Dog...@PostConstruct..");
	}
	//对象销毁之前进行操作
	@PreDestroy
	public void destroy(){
		System.out.println("Dog...@PreDestroy..");
	}
}

@ComponentScan("com.rsd.bean")
@Configuration
@Scope 
public class MainConfigOfLifeCycle {
	
}

public class IOCTest_LifeCycle {
	@SuppressWarnings("resource")
	@Test
	public void test01(){
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
                //容器在单例模式下，一旦启动容器，就会实例化满足条件的bean
		System.out.println("容器创建完成.....");
		 
		applicationContext.close();
	}
}

测试运行结果：

Dog constructor... //bean类实例化
Dog...@PostConstruct.. //初始化方法执行
容器创建完成.....

Dog...@PreDestroy.. //实例销毁时立即执行的destroy（）方法

方式四、后置处理器：创建一个类，实现接口BeanPostProcessor ，此类被注册到容器中后，其方法可处理bean初始化前后一些工作。（此初始化指的@Bean中定义的初始化方法、InitializingBean接口中定义的初始化方法、@PostConstruct修饰的方法及其他初始化方法）

1.创建MyBeanPostProcessor类，实现BeanPostProcessor接口

重写两种方法：

postProcessBeforeInitialization==》容器中bean初始化之前执行此方法

postProcessAfterInitialization==》容器中bean初始化之前执行此方法

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
	//bean初始化前调用
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		 System.out.println("postProcessBeforeInitialization..."+beanName+"==>"+bean);
		return bean;
	}
	//bean初始化后调用
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName)
			throws BeansException {
		System.out.println("postProcessAfterInitialization..."+beanName+"==>"+bean);
		return bean;
	}

}

2.配置类

@ComponentScan("com.rsd.bean")注解将MyBeanPostProcessor类注册到容器

@Bean将Car类注册到容器，并定义周期方法

在Car实例调用init()方法前后，分别调用MyBeanPostProcessor类postProcessBeforeInitialization（）和postProcessAfterInitialization（）两种方法

@ComponentScan("com.rsd.bean")
@Configuration
@Scope 
public class MainConfigOfLifeCycle {
	
	@Scope  
	@Bean(initMethod="init",destroyMethod="destory") 
	public Car car(){
		return new Car();
	}
}

3.测试案例：

public class IOCTest_LifeCycle {
	@SuppressWarnings("resource")
	@Test
	public void test01(){
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
		System.out.println("容器创建完成.....");
		applicationContext.close();
	}
}

运行结果：

car.... constructor...
postProcessBeforeInitialization...car==>com.atguigu.bean.Car@418bc9
car...init....
postProcessAfterInitialization...car==>com.atguigu.bean.Car@418bc9
容器创建完成.....

car...destory....

Spring注解--bean生命周期的相关方法

猜你喜欢