spring源码学习
- 记录spring的学习过程如有遗漏和错误忘见谅
- IOC容器
BeanFactory
接口是最原始的ioc容器相关方法,只是在其中对ioc容器定义了最基本的行为,要想看工厂产生对象的过程就需要查看其实现类。在spring中有很多该接口的实现类其中一个就是xmlBeanFactory。
Object getBean(String name) throws BeansException;
boolean containsBean(String name);
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
XmlBeanFactory
继承自DefaultListableBeanFactory
并在改类的基础之上增加了外部资源读取如spring.xml
看下构造方法
public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, null);
}
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
super(parentBeanFactory);
this.reader.loadBeanDefinitions(resource);
}
- spring中常用的外部xml文件转换Resource方式,前两种职能加载classpath下的文件,第三种可以根据绝对路径加载xml文件
Resource resource=new ClassPathResource("applicationContext.xml"); BeanFactory beanFactory=new XmlBeanFactory(resource); Resource resource=new ClassPathResource("applicationContext.xml",this.getClass()); BeanFactory beanFactory=new XmlBeanFactory(resource); Resource resource=new FileSystemResource("E:/spring/applicationContext.xml"); BeanFactory beanFactory=new XmlBeanFactory(resource);
XmlBeanFactory
会对传入的resource对象进行解析loadBeanDefinitions(resource)
;我们看下这个方法的实现。
//定义解析编码
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
return loadBeanDefinitions(new EncodedResource(resource));
}
//
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
Assert.notNull(encodedResource, "EncodedResource must not be null");
if (logger.isInfoEnabled()) {
logger.info("Loading XML bean definitions from " + encodedResource.getResource());
}
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
if (currentResources == null) {
currentResources = new HashSet<EncodedResource>(4);
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
}
try {
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
//画重点,上面的都是根据编码转换成流的形式这个方法才是ioc真正的实现
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
....省略若干行
}
- 那就继续往下追吧
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)throws BeanDefinitionStoreException {
try {
//加载xml文档输出dom docment格式
Document doc = doLoadDocument(inputSource, resource);
//把输入的dom注入到bean definitions
return registerBeanDefinitions(doc, resource);
}
....省略若干行
}
}
- 刨根问低继续往下看
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
//创建一个reader去读取dom
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
//记录注入前beanDefinition的数量
int countBefore = getRegistry().getBeanDefinitionCount();
//注入---展开
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
//返回当前注入的总数
return getRegistry().getBeanDefinitionCount() - countBefore;
}
- 继续看
@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
//拿到doc的根结点猜测应该是个链表
Element root = doc.getDocumentElement();
//遍历他完成注入---展开
doRegisterBeanDefinitions(root);
}
- 继续
protected void doRegisterBeanDefinitions(Element root) {
//...省略若干行
//看到这里有没有一种豁然开朗的感觉终于要干正事了
//spring提供的拓展点,在进行处理beandefinitions可以自定义去操作
//spring并没有提供默认的实现,想要实现可以继承DefaultBeanDefinitionDocumentReader这个类
preProcessXml(root);
//正经方法,展开来看
parseBeanDefinitions(root, this.delegate);
//大概同preProcessXml
postProcessXml(root);
this.delegate = parent;
}
- 继续
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//主要判断标签是自定义的还是默认的,spring提供两套实现方式,本次只看默认实现
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
//咋整,到这又看不了,继续展开
parseDefaultElement(ele, delegate);
}
else {
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}
- 继续,到底还有多少,哈哈我也不知道,一起刨根问底
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
//放眼一看很熟悉呀,这不是要解析xml里面咱们定义的标签吗
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
//import标签处理
importBeanDefinitionResource(ele);
}
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
//alias标签处理
processAliasRegistration(ele);
}
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
//bean标签处理,重点展开看
processBeanDefinition(ele, delegate);
}
//beans标签处理
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
- 继续
//本方法是将给的bean element转换成bean definition
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//这个是关键,将el转换成beanDefinition 展开
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
//修饰实力,就当作注入前的一些必要处理吧
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 把修饰好的实例,注入容器,继续展开
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
- 继续
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
///拿到beanName
String id = ele.getAttribute(ID_ATTRIBUTE);
....省略若干行
String beanName = id;
....省略若干行
if (containingBean == null) {
checkNameUniqueness(beanName, aliases, ele);
}
//构造beanDefinition对象--可以展开
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
....省略若干行
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}
- 继续
public AbstractBeanDefinition parseBeanDefinitionElement( Element ele, String beanName, BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
try {
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
//这个方法就不展开了有兴趣的可以看下,主要是构造一个GenericBeanDefinition处理bean
//如果有父类也要处理,如果制定了类加载器则直接加载bean
/**if (classLoader != null) {
bd.setBeanClass(ClassUtils.forName(className, classLoader));
}
else {
bd.setBeanClassName(className);
}**/
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
//解析bean标签的属性应用于beandefinition比如是否懒加载等等
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
parseMetaElements(ele, bd);
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
parseConstructorArgElements(ele, bd);
parsePropertyElements(ele, bd);
parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
///这时候返回的BeanDefinition一个bean实例,它具有属性值,构造函数参数值,以及具体实现
return bd;
}
...省略若干行
}
- 继续
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
//激动不,要注入了
String beanName = definitionHolder.getBeanName();
//注入--展开
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
//看看有没有别名,有的话别名也住进去
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
- 继续
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException {
...省略若干行
//把构造的beanDefinition与beanName关联放入beanDefinitionMap完成注入
this.beanDefinitionMap.put(beanName, beanDefinition);
}
...省略若干行
}
结束
这里需要注意的一点是这个过程并没有完成依赖注入,依赖注册是发生在应用第一次调用 getBean() 向容器索要 Bean 时。当然我们可以通过设置预处理,即对某个 Bean 设置 lazyinit 属性,那么这个 Bean 的依赖注入就会在容器初始化的时候完成。