Spring 学习二、Bean生命周期相关注解

<bean id="person" 
  		class="com.meritit.ysjian.spring3learning.beanlife.Person"
		init-method="myInit" destroy-method="myDestory" scope="singleton"
		p:id="1001" p:age="125" p:birthday="2013/03/05" />

/**
     * 指定Bean的初始化方法和销毁方法
     *
     * @return
     */
@Bean(initMethod = "init",destroyMethod = "destroy")
Student windows(){
        return new Student(00001L, "Windows");
}

    public void init(){
        System.out.println("Student Bean 调用初始化方法.");
    }


    public void destroy(){
        System.out.println("Student Bean 调用销毁方法.");
    }

public class JeepCar implements InitializingBean,DisposableBean {


    public void JeepCar(){
        System.out.println("Jeep Car Construct ...");
    }


    /**
     * 在Bean销毁时调用的方法
     * @throws Exception
     */
    public void destroy() throws Exception {

        System.out.println("执行销毁方法....");

    }

    /**
     * 在Bean 执行完构造方法之后执行的方法
     * @throws Exception
     */
    public void afterPropertiesSet() throws Exception {
        System.out.println("执行初始化构造方法");
    }
}

执行初始化构造方法
Spring Contation Initializer Ok ... 
容器构造完成
执行销毁方法....

@Component
public class CachingMovieLister {

    @PostConstruct
    public void populateMovieCache() {
        // populates the movie cache upon initialization...
        System.out.println("populates the movie cache upon initialization...");
    }

    @PreDestroy
    public void clearMovieCache() {
        // clears the movie cache upon destruction...
        System.out.println("clear the movie cache upon destruction...");
    }
}

populates the movie cache upon initialization...
执行初始化构造方法
Spring Contation Initializer Ok ... 
容器构造完成
执行销毁方法....
clear the movie cache upon destruction...

public interface BeanPostProcessor {

	/**
	 * Apply this BeanPostProcessor to the given new bean instance <i>before</i> any bean
	 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
	 * or a custom init-method). 
	  应用这个方法在给出新的bean实例后，在调用任何初始化方法回调函数之前，比如说 实现 Initializing的接口
	 
	 
	 The bean will already be populated with property values.
	 * The returned bean instance may be a wrapper around the original.
	 * <p>The default implementation returns the given {@code bean} as-is.
	 * @param bean the new bean instance
	 * @param beanName the name of the bean
	 * @return the bean instance to use, either the original or a wrapped one;
	 * if {@code null}, no subsequent BeanPostProcessors will be invoked
	 * @throws org.springframework.beans.BeansException in case of errors
	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
	 */
	@Nullable
	default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

	/**
	 * Apply this BeanPostProcessor to the given new bean instance <i>after</i> any bean
	 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
	 * or a custom init-method). The bean will already be populated with property values.
	 * The returned bean instance may be a wrapper around the original.
	 * <p>In case of a FactoryBean, this callback will be invoked for both the FactoryBean
	 * instance and the objects created by the FactoryBean (as of Spring 2.0). The
	 * post-processor can decide whether to apply to either the FactoryBean or created
	 * objects or both through corresponding {@code bean instanceof FactoryBean} checks.
	 * <p>This callback will also be invoked after a short-circuiting triggered by a
	 * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method,
	 * in contrast to all other BeanPostProcessor callbacks.
	 * <p>The default implementation returns the given {@code bean} as-is.
	 * @param bean the new bean instance
	 * @param beanName the name of the bean
	 * @return the bean instance to use, either the original or a wrapped one;
	 * if {@code null}, no subsequent BeanPostProcessors will be invoked
	 * @throws org.springframework.beans.BeansException in case of errors
	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
	 * @see org.springframework.beans.factory.FactoryBean
	 */
	@Nullable
	default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

@Component
public class MyBeanPostProcessor implements BeanPostProcessor{


    /**
     *
     * @param bean 刚实例化的Bean
     * @param beanName  在容器中的名称
     * @return
     * @throws BeansException
     */
    @Nullable
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

        System.out.println("postProcessBeforeInitialization => "+beanName+" => "+bean);

        return bean;
    }

    /**
     *
     * @param bean  刚实例化的Bean
     * @param beanName 在容器中的名称
     * @return
     * @throws BeansException
     */
    @Nullable
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

        System.out.println("postProcessAfterInitialization => "+beanName+" => "+bean);
        return bean;
    }
}

postProcessBeforeInitialization => studentBeanConfiguration => com.zuoyan.config.StudentBeanConfiguration@2d127a61
postProcessAfterInitialization => studentBeanConfiguration => com.zuoyan.config.StudentBeanConfiguration@2d127a61
postProcessBeforeInitialization => cachingMovieLister => com.zuoyan.bean.CachingMovieLister@32a068d1
populates the movie cache upon initialization...
postProcessAfterInitialization => cachingMovieLister => com.zuoyan.bean.CachingMovieLister@32a068d1
postProcessBeforeInitialization => jeepCar => com.zuoyan.bean.JeepCar@71a794e5
执行初始化构造方法
postProcessAfterInitialization => jeepCar => com.zuoyan.bean.JeepCar@71a794e5
Spring Contation Initializer Ok ... 
容器构造完成
执行销毁方法....
clear the movie cache upon destruction...

// Initialize the bean instance.
Object exposedObject = bean;
try {
    // 首先设置bean的属性值 
	populateBean(beanName, mbd, instanceWrapper);
    // 然后在调用初始化方法
	exposedObject = initializeBean(beanName, exposedObject, mbd);
}

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);
		}

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

		Object result = existingBean;
      	// 循环遍历执行所有 BeanPostProcessor
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessBeforeInitialization(result, beanName);
             // 如果碰见其中一个为null 就不往下执行了
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

public interface ApplicationContextAware extends Aware {

   /**
    * Set the ApplicationContext that this object runs in.
    * Normally this call will be used to initialize the object.
    * <p>Invoked after population of normal bean properties but before an init callback such
    * as {@link org.springframework.beans.factory.InitializingBean#afterPropertiesSet()}
    * or a custom init-method. Invoked after {@link ResourceLoaderAware#setResourceLoader},
    * {@link ApplicationEventPublisherAware#setApplicationEventPublisher} and
    * {@link MessageSourceAware}, if applicable.
    * @param applicationContext the ApplicationContext object to be used by this object
    * @throws ApplicationContextException in case of context initialization errors
    * @throws BeansException if thrown by application context methods
    * @see org.springframework.beans.factory.BeanInitializationException
    */
   void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

}

@Component
public class Animal implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

        this.applicationContext = applicationContext;
    }
}

@Override
	@Nullable
	public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
		AccessControlContext acc = null;
		
         // 判断Bean 是否有安全管理器 和有没有实现下面的这些接口，如果有实现就给 acc 初始化
		if (System.getSecurityManager() != null &&
				(bean instanceof EnvironmentAware || 
                  bean instanceof EmbeddedValueResolverAware ||
			     bean instanceof ResourceLoaderAware || 
                  bean instanceof ApplicationEventPublisherAware ||
			     bean instanceof MessageSourceAware ||
                  // 可以看到这行判断是否该接口
                  bean instanceof ApplicationContextAware)
           ) 
        {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}
          
      
		if (acc != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
             // 调用这段代码
			invokeAwareInterfaces(bean);
		}

		return bean;
	}

private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof Aware) {
			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 ApplicationContextAware) {
				((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
			}
		}
	}

/**
 * Simple {@link BeanPostProcessor} that checks JSR-303 constraint annotations
 * in Spring-managed beans, throwing an initialization exception in case of
 * constraint violations right before calling the bean's init method (if any).
 *
 * @author Juergen Hoeller
 * @since 3.0
 */
public class BeanValidationPostProcessor implements BeanPostProcessor, InitializingBean {

	@Nullable
	private Validator validator;

	private boolean afterInitialization = false;


	/**
	 * Set the JSR-303 Validator to delegate to for validating beans.
	 * <p>Default is the default ValidatorFactory's default Validator.
	 */
	public void setValidator(Validator validator) {
		this.validator = validator;
	}

	/**
	 * Set the JSR-303 ValidatorFactory to delegate to for validating beans,
	 * using its default Validator.
	 * <p>Default is the default ValidatorFactory's default Validator.
	 * @see javax.validation.ValidatorFactory#getValidator()
	 */
	public void setValidatorFactory(ValidatorFactory validatorFactory) {
		this.validator = validatorFactory.getValidator();
	}

	/**
	 * Choose whether to perform validation after bean initialization
	 * (i.e. after init methods) instead of before (which is the default).
	 * <p>Default is "false" (before initialization). Switch this to "true"
	 * (after initialization) if you would like to give init methods a chance
	 * to populate constrained fields before they get validated.
	 */
	public void setAfterInitialization(boolean afterInitialization) {
		this.afterInitialization = afterInitialization;
	}

	@Override
	public void afterPropertiesSet() {
		if (this.validator == null) {
			this.validator = Validation.buildDefaultValidatorFactory().getValidator();
		}
	}


	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if (!this.afterInitialization) {
			doValidate(bean);
		}
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if (this.afterInitialization) {
			doValidate(bean);
		}
		return bean;
	}


	/**
	 * Perform validation of the given bean.
	 * @param bean the bean instance to validate
	 * @see javax.validation.Validator#validate
	 */
	protected void doValidate(Object bean) {
		Assert.state(this.validator != null, "No Validator set");
		Object objectToValidate = AopProxyUtils.getSingletonTarget(bean);
		if (objectToValidate == null) {
			objectToValidate = bean;
		}
		Set<ConstraintViolation<Object>> result = this.validator.validate(objectToValidate);

		if (!result.isEmpty()) {
			StringBuilder sb = new StringBuilder("Bean state is invalid: ");
			for (Iterator<ConstraintViolation<Object>> it = result.iterator(); it.hasNext();) {
				ConstraintViolation<Object> violation = it.next();
				sb.append(violation.getPropertyPath()).append(" - ").append(violation.getMessage());
				if (it.hasNext()) {
					sb.append("; ");
				}
			}
			throw new BeanInitializationException(sb.toString());
		}
	}

}

private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
		if (this.lifecycleMetadataCache == null) {
			// Happens after deserialization, during destruction...
			return buildLifecycleMetadata(clazz);
		}
		// Quick check on the concurrent map first, with minimal locking.
		LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
		if (metadata == null) {
			synchronized (this.lifecycleMetadataCache) {
              	
				metadata = this.lifecycleMetadataCache.get(clazz);
				if (metadata == null) {
					metadata = buildLifecycleMetadata(clazz);
					this.lifecycleMetadataCache.put(clazz, metadata);
				}
				return metadata;
			}
		}
		return metadata;
	}

private final transient Map<Class<?>, LifecycleMetadata> lifecycleMetadataCache = new ConcurrentHashMap<>(256);

private static class LifecycleElement {
		// 具体的方法
		private final Method method;
		// 方法的名称标识符
		private final String identifier;
}

private class LifecycleMetadata {
         // 目标类
		private final Class<?> targetClass;
         // 初始化方法集合
		private final Collection<LifecycleElement> initMethods;
         
        //  Bean 销毁方法集合
		private final Collection<LifecycleElement> destroyMethods;
		
  		// 检查初始化方法集合
		@Nullable
		private volatile Set<LifecycleElement> checkedInitMethods;
		
  		// 检查销毁方法集合
		@Nullable
		private volatile Set<LifecycleElement> checkedDestroyMethods;

  		
		public LifecycleMetadata(Class<?> targetClass, Collection<LifecycleElement> initMethods,
				Collection<LifecycleElement> destroyMethods) {

			this.targetClass = targetClass;
			this.initMethods = initMethods;
			this.destroyMethods = destroyMethods;
		}
         // .....
}

public void invokeInitMethods(Object target, String beanName) throws Throwable {
			Collection<LifecycleElement> checkedInitMethods = this.checkedInitMethods;
			Collection<LifecycleElement> initMethodsToIterate =
					(checkedInitMethods != null ? checkedInitMethods : this.initMethods);
  			//如果初始化方法不为空，就迭代执行初始化方法
			if (!initMethodsToIterate.isEmpty()) {
				for (LifecycleElement element : initMethodsToIterate) {
					if (logger.isTraceEnabled()) {
						logger.trace("Invoking init method on bean '" + beanName + "': " + element.getMethod());
					}
                  
					element.invoke(target);
				}
			}
	}

public void invoke(Object target) throws Throwable {
			ReflectionUtils.makeAccessible(this.method);
  			// this 就是LifecycleElement 
			this.method.invoke(target, (Object[]) null);
}