Spring中常用重要的接口
Spring (ApplicationContext 初始化Bean的方法 refresh())
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.//创建Bean并post等方法
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
}
}
Spring 框架中想自己在bean的初始化阶段自定义一些逻辑，或者想获取一些资源，非常有用的接口有
BeanPostProcessor,// properties 设置完成，InitializingBean的 afterPropertiesSet()， init-method完成后对bean进行一些逻辑处理
InitializingBean,// 提供afterPropertiesSet()，位于init-method之前调用（这两方法都可用于实现bean init方法）；
DestructionAwareBeanPostProcessor,//postProcessBeforeDestruction(Object bean, String beanName) 方法于 destory方法之前调用；
BeanFactoryAware // setBeanFactory(BeanFactory beanFactory) 接口使Bean初始化完成后获取BeanFactory资源，以便操作。类似的还有ApplicationContextAware....
public interface BeanPostProcessor { /**property values已经设置完成， * Apply this BeanPostProcessor to the given new bean instance <i>before</i> any bean * initialization callbacks (like InitializingBean's <code>afterPropertiesSet</code> * 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. * @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</code>, no subsequent BeanPostProcessors will be invoked * @throws org.springframework.beans.BeansException in case of errors * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet */ Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException; /** * Apply this BeanPostProcessor to the given new bean instance <i>after</i> any bean * initialization callbacks (like InitializingBean's <code>afterPropertiesSet</code> * 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</code> 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. * @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</code>, 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 */ Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException; }
/**已经完成了property 填充（完成InitializingBean 接口的afterPropertiesSet（）调用，如果指定init-method 方法，也已经完成的调用（after..()之后））
* Initialize the given bean instance, applying factory callbacks * as well as init methods and bean post processors. * <p>Called from {@link #createBean} for traditionally defined beans, * and from {@link #initializeBean} for existing bean instances. * @param beanName the bean name in the factory (for debugging purposes) * @param bean the new bean instance we may need to initialize * @param mbd the bean definition that the bean was created with * (can also be <code>null</code>, if given an existing bean instance) * @return the initialized bean instance (potentially wrapped) * @see BeanNameAware * @see BeanClassLoaderAware * @see BeanFactoryAware * @see #applyBeanPostProcessorsBeforeInitialization * @see #invokeInitMethods * @see #applyBeanPostProcessorsAfterInitialization */ protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { AccessController.doPrivileged(new PrivilegedAction<Object>() { 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);//调用BeanPostProcessor的before方法 } 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);//调用
BeanPostProcessor的after方法
} return wrappedBean; }
BeanFactory bf = new XmlBeanFactory(new ClassPathResource("spring.xml"));
bf 只是保存一些BeanDeinationMap， 并不会马上实例化，需要后续调用getBean才初始化：
ApplicationContext ac2 = new ClassPathXmlApplicationContext("spring.xml");
ac2 会马上将spring.xml中定义的bean实例化加到factory的缓存中。
例子用ApplicationContext ：
spring.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
">
<alias name="user" alias="testxx"/>
<bean id="father" abstract="true">
<property name="local" value="Us"/>
</bean>
<bean id="user" class="com.donghua.bean.User" parent="father">
<property name="name" value="Allen"/>
<property name="age" value="6"/>
</bean>
<bean id="user3" class="com.donghua.bean.User3" init-method="myInit" destroy-method="destroy">
<property name="name" value="Allen3"/>
<property name="age" value="61"/>
</bean>
<bean id="factory" class="com.donghua.bean.MyBeanFactory"/>
</beans>
User3:
package com.donghua.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor;
public class User3 implements BeanPostProcessor, InitializingBean, DestructionAwareBeanPostProcessor,BeanFactoryAware
{
BeanFactory beanFactory;
private String name;
private int age;
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
public void myInit()
{
System.out.println("this is my init....."+this.getAge());
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
// TODO Auto-generated method stub
System.out.println("This is the post before..............");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
// TODO Auto-generated method stub
System.out.println("This is the post after..............");
return bean;
}
@Override
public void afterPropertiesSet() throws Exception {
// TODO Auto-generated method stub
System.out.println("this is InitializingBean method..."
+ "(called by before init method, after set property values)."+this.getAge());
}
@Override
public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
// TODO Auto-generated method stub
System.out.println("this is DestructionAwareBeanPostProcessor, called when destroy bean...");
}
public void destroy()
{
System.out.println("this is destroy method....");
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
// TODO Auto-generated method stub
this.beanFactory = beanFactory;
}
public void getUser2()
{
User u =(User) beanFactory.getBean("user");
System.out.println(u.toString()+" this is user2...");
}
}
package com.donghua.test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import com.donghua.anotation.User2;
import com.donghua.bean.MyBeanFactory;
import com.donghua.bean.User;
import com.donghua.bean.User3;
public class Test {
public static void main(String[] args)
{
ApplicationContext ac2 = new ClassPathXmlApplicationContext("spring.xml");
User3 u3 = (User3) ac2.getBean("user3");
System.out.println(u3);
u3.getUser2();
((ClassPathXmlApplicationContext) ac2).close();
}
}
输出顺序：
this is InitializingBean method...(called by before init method, after set property values).61 //InitializingBean
this is my init.....61 //init-method
This is the post before.............. //BeanPostProcesser
This is the post after..............
This is the post before..............
This is the post after..............
User [name=Allen3, age=61]
User [name=Allen, age=6] this is user2...
this is DestructionAwareBeanPostProcessor, called when destroy bean... // DestructionAwareBeanPostProcessor
this is DestructionAwareBeanPostProcessor, called when destroy bean...
this is destroy method.... //destory method
浙公网安备 33010602011771号