Spring - bean 초기 화 순서

Spring - bean 초기 화 순 서 를 검증 하기 전에 몇 개의 관건 적 인 인 인 터 페 이 스 를 먼저 봅 니 다.
InitializingBean     Spirng 의 InitializingBean 은 bean 에 게 초기 화 방법 을 정의 하 는 방식 을 제공 합 니 다.InitializingBean 은 하나의 인터페이스 로 하나의 방법 만 포함 합 니 다: after PropertiesSet ().   spring 초기 화 후 모든 속성 설정 방법 (즉 setXxx) 을 실행 하면 after PropertiesSet () 을 자동 으로 호출 합 니 다. 설정 파일 에 특별한 설정 이 필요 없 지만 이 방식 은 bean 이 spring 에 대한 의존 도 를 증가 시 킵 니 다. init - method (비 인터페이스) 를 사용 하 는 것 을 피해 야 합 니 다.  Spring 은 InitializingBean 을 통 해 bean 을 초기 화한 후 이 bean 에 대한 리 셋 을 완성 할 수 있 지만, 이러한 방식 은 bean 에 게 InitializingBean 인 터 페 이 스 를 실현 하도록 요구한다.그러나 bean 이 InitialingBean 인 터 페 이 스 를 실현 하면 이 bean 의 코드 는 Spring 과 결합 된다.일반적으로 저 는 bean 이 InitialingBean 을 직접 실현 하도록 격려 하지 않 습 니 다. Spring 이 제공 하 는 init - method 기능 을 사용 하여 bean 서브 정의 초기 화 방법 을 실행 할 수 있 습 니 다.BeanFactory PostProcessor 인터페이스
spring 의 bean 이 만 들 기 전에 bean 의 정의 속성 을 수정 할 수 있 습 니 다.즉, Spring 은 BeanFactory PostProcessor 가 용기 에서 다른 bean 을 예화 하기 전에 설정 메타 데 이 터 를 읽 을 수 있 도록 허용 하고 필요 에 따라 수정 할 수 있 습 니 다. 예 를 들 어 bean 의 scope 를 singleton 에서 prototype 으로 바 꿀 수도 있 고 property 의 값 을 수정 할 수도 있 습 니 다.여러 개의 BeanFactory PostProcessor 를 동시에 설정 하고 'order' 속성 을 설정 하여 각 BeanFactory PostProcessor 의 실행 순 서 를 제어 할 수 있 습 니 다.메모: BeanFactory PostProcessor 는 spring 용기 에 bean 의 정의 파일 을 불 러 온 후 bean 이 예화 되 기 전에 실 행 됩 니 다.인터페이스 방법의 입 참 은 ConfigurableListableBeanFactory 입 니 다. 이 매개 변 수 를 사용 하면 관련 bean 의 정의 정 보 를 얻 을 수 있 습 니 다. BeanPostProcessor 인터페이스 BeanPostProcessor 는 spring 용기 에서 bean 을 예화 한 후에 bean 의 초기 화 방법 을 실행 한 후에 자신의 처리 논 리 를 추가 할 수 있 습 니 다.여기 서 말 하 는 초기 화 방법 은 다음 과 같은 두 가 지 를 말한다. 1) bean 은 InitialingBean 인 터 페 이 스 를 실현 하고 해당 하 는 방법 은 after PropertiesSet 2) bean 이 정의 할 때 init - method 설정 방법 을 통 해 알 수 있다. BeanPostProcessor 는 spring 용기 에 bean 의 정의 파일 을 불 러 오고 bean 을 예화 한 후에 실 행 된 것 이다.BeanPostProcessor 의 집행 순 서 는 BeanFactory PostProcessor 다음 이다.코드:

package cn.com.init;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

public class HelloWorld implements InitializingBean, BeanPostProcessor, BeanFactoryPostProcessor, BeanFactoryAware,
		BeanNameAware, DisposableBean {

	public HelloWorld() {
		System.out.println("  HelloWorld   ...");
	}

	private String hello;

	public String getHello() {
		return hello;
	}

	public void setHello(String hello) {
		this.hello = hello;
		System.out.println("  setHello()...");
	}

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

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

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

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory paramConfigurableListableBeanFactory)
			throws BeansException {
		System.out.println("  BeanFactoryPostProcessor postProcessBeanFactory()...");

	}

	@Override
	public String toString() {
		return "HelloWorld [hello=" + hello + "]";
	}

	@Override
	public void setBeanName(String paramString) {
		System.out.println("  BeanNameAware.setBeanName");

	}

	@Override
	public void setBeanFactory(BeanFactory paramBeanFactory) throws BeansException {
		System.out.println("  BeanFactoryAware.setBeanFactory");

	}

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

	}

	public void init() throws Exception {
		System.out.println("HelloWorld init   ");

	}
}

프로필:

테스트 방법:

package mybatis;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.com.init.HelloWorld;
import junit.framework.TestCase;

public class BeanPostPorcessorTest extends TestCase {
	private ClassPathXmlApplicationContext context;  
    protected void setUp() throws Exception {  
        super.setUp();  
        String[] paths = {"classpath*:spring-text.xml"};  
  
        context = new ClassPathXmlApplicationContext(paths);  
          
    }  
	    public void testBeanFactoryPostProcessor()  
	    {  
	    	 HelloWorld bean = (HelloWorld) context.getBean("hello");  
	    	 System.out.println(bean);
	    	 context.getBeanFactory().destroySingletons();

	    }  
}

실행 결과:
Hello World 구조 기 호출... setHello () 호출... BeanNameAware. setBeanName 호출 BeanFactory Aware. setBeanFactory 호출 InitialingBean 의 after PropertiesSet () 호출... Hello World 클래스 init 방법 호출 BeanFactory PostProcessor 의 post ProcessBeanFactory ()... Hello World [hello = hello]
DisposableBean 인터페이스 destroy 방법
결과 에서 bean 순 서 를 초기 화 합 니 다.
1. 구조 함수 2. 속성 초기 화 3. BeanFactory Aware 인터페이스 실행 setBeanFactory 방법 4. InitializingBean 인터페이스 실행 after PropertiesSet 방법 5. 설정 파일 에 init - method 를 지정 하면 이 방법 6. BeanFactory PostProcessor 인터페이스 가 "new" 에 있 음다른 클래스 전에 post ProcessBeanFactory 방법 을 실행 합 니 다 (이 방법 을 통 해 설정 파일 의 속성 값 설정 을 변경 할 수 있 습 니 다) 7. BeanPost Processor 인터페이스 가 구현 되면 다른 bean 초기 화 방법 전에 post ProcessBeforeInitialization 방법 을 실행 합 니 다.이후 post Process After Initialization 방법 을 실행 하 는 것 이 이상 한 점 은 destroy 방법 을 실행 하지 않 았 다 는 것 입 니 다. 이 방법 에서 인터페이스 BeanPostProcessor 를 실행 하 는 방법 이 없습니다. 어떤 이유 인지 모 르 겠 습 니 다.