Spring源码分析

二价亚铁.

于 2024-07-14 21:44:27 发布

阅读量646

点赞数 7

文章标签： spring java 后端

本文链接：https://blog.csdn.net/2201_75506216/article/details/140423808

版权

01、Spring源码分析：initPropertySources方法扩展点

Spring的强大之处不仅仅在于它为Java开发者提供了极大便利，更在于它的开放式架构，使得用户可以拥有最大扩展Spring的能力。

protected void initPropertySources() {
		// For subclasses: do nothing by default.
	}

在AbstractApplicationContext类中有一个initPropertySources方法是留给子类扩展，它是在refresh()的第一个方法prepareRefresh();方法中调用。

protected void prepareRefresh() {


		// Switch to active.
		// 设置容器启动的时间
		this.startupDate = System.currentTimeMillis();
		// 容器的关闭标志位
		this.closed.set(false);
		// 容器的激活标志位
		this.active.set(true);

		// 记录日志
		if (logger.isDebugEnabled()) {


			if (logger.isTraceEnabled()) {


				logger.trace("Refreshing " + this);
			}
			else {


				logger.debug("Refreshing " + getDisplayName());
			}
		}

		// Initialize any placeholder property sources in the context environment.
		// 留给子类覆盖，初始化属性资源
		initPropertySources();

		// Validate that all properties marked as required are resolvable:
		// see ConfigurablePropertyResolver#setRequiredProperties
		// 创建并获取环境对象，验证需要的属性文件是否都已经放入环境中
		getEnvironment().validateRequiredProperties();

		// Store pre-refresh ApplicationListeners...
		// 判断刷新前的应用程序监听器集合是否为空，如果为空，则将监听器添加到此集合中
		if (this.earlyApplicationListeners == null) {


			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {


			// Reset local application listeners to pre-refresh state.
			// 如果不等于空，则清空集合元素对象
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}

		// Allow for the collection of early ApplicationEvents,
		// to be published once the multicaster is available...
		// 创建刷新前的监听事件集合
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

所以我们可以继承此类或其子类来重写initPropertySources方法，实现一些扩展。

public class MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext {
	public MyClassPathXmlApplicationContext(String... configLocations){
		super(configLocations);
	}

	@Override
	protected void initPropertySources() {
		System.out.println("扩展initPropertySource");
		//这里添加了一个name属性到Environment里面，以方便我们在后面用到
		getEnvironment().getSystemProperties().put("name","bobo");
		//这里要求Environment中必须包含username属性，如果不包含，则抛出异常
		getEnvironment().setRequiredProperties("username");
	}
}

此处我们做了两个扩展：
第一，向Environment中添加了一个属性值。
第二：我们设置了一个必要的系统属性username，当Environment中不包含username属性时系统会抛出异常。

测试类：

public class Test {

	public static void main(String[] args) {
		MyClassPathXmlApplicationContext ac = new MyClassPathXmlApplicationContext("applicationContext.xml");

//        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-${username}.xml");
	}
}

当然你也可以做其它扩展，这里只是列举了一个例子。

02、Spring源码分析：customizeBeanFactory方法扩展点

Spring的强大之处不仅仅在于它为Java开发者提供了极大便利，更在于它的开放式架构，使得用户可以拥有最大扩展Spring的能力。

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {


		// 如果属性allowBeanDefinitionOverriding不为空，设置给beanFactory对象相应属性，是否允许覆盖同名称的不同定义的对象
		if (this.allowBeanDefinitionOverriding != null) {


			beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
		// 如果属性allowCircularReferences不为空，设置给beanFactory对象相应属性，是否允许bean之间存在循环依赖
		if (this.allowCircularReferences != null) {


			beanFactory.setAllowCircularReferences(this.allowCircularReferences);
		}
	}

在AbstractRefreshableApplicationContext类中有一个customizeBeanFactory方法是留给子类扩展，它是在refresh()的第二个方法obtainFreshBeanFactory()–>refreshBeanFactory()方法中调用。

protected final void refreshBeanFactory() throws BeansException {


		// 如果存在beanFactory，则销毁beanFactory
		if (hasBeanFactory()) {


			destroyBeans();
			closeBeanFactory();
		}
		try {


			// 创建DefaultListableBeanFactory对象
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			// 为了序列化指定id，可以从id反序列化到beanFactory对象
			beanFactory.setSerializationId(getId());
			// 定制beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖
			customizeBeanFactory(beanFactory);
			// 初始化documentReader,并进行XML文件读取及解析,默认命名空间的解析，自定义标签的解析
			loadBeanDefinitions(beanFactory);
			this.beanFactory = beanFactory;
		}
		catch (IOException ex) {


			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

此方法是用来实现BeanFactory的属性设置，主要是设置两个属性：

allowBeanDefinitionOverriding：是否允许覆盖同名称的不同定义的对象。
allowCircularReferences：是否允许bean之间的循环依赖。

如下例子：

public class MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext {


	public MyClassPathXmlApplicationContext(String... configLocations){


		super(configLocations);
	}

	@Override
	protected void initPropertySources() {


		System.out.println("扩展initPropertySource");
		//这里添加了一个name属性到Environment里面，以方便我们在后面用到
		getEnvironment().getSystemProperties().put("name","bobo");
		//这里要求Environment中必须包含username属性，如果不包含，则抛出异常
		getEnvironment().setRequiredProperties("username");
	}

	@Override
	protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {


		super.setAllowBeanDefinitionOverriding(false);
		super.setAllowCircularReferences(false);
		super.customizeBeanFactory(beanFactory);
	}

public class Test {



	public static void main(String[] args) {


		MyClassPathXmlApplicationContext ac = new MyClassPathXmlApplicationContext("applicationContext.xml");

//        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-${username}.xml");
	}
}


}

03、Spring源码分析：自定义配置文件标签

Spring的强大之处不仅仅在于它为Java开发者提供了极大便利，更在于它的开放式架构，使得用户可以拥有最大扩展Spring的能力。

我们在用xml定义spring信息时，默认的element只包含beans，bean，import，alias这四个，其它任何标签都属于自定义标签，均需要引入相应的命名空间，如：context，aop标签等。

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {


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

对应的源码处理在DefaultBeanDefinitionDocumentReader类的parseBeanDefinitions方法里面。

自定义标签元素

1，定义People.java

public class People {


	private String id;
	private int age;
	private String name;
	private String address;

	public People(String id, int age, String name, String address) {


		this.id = id;
		this.age = age;
		this.name = name;
		this.address = address;
	}

	public People() {


	}

	public String getId() {


		return id;
	}

	public void setId(String id) {


		this.id = id;
	}

	public int getAge() {


		return age;
	}

	public void setAge(int age) {


		this.age = age;
	}

	public String getName() {


		return name;
	}

	public void setName(String name) {


		this.name = name;
	}

	public String getAddress() {


		return address;
	}

	public void setAddress(String address) {


		this.address = address;
	}

	@Override
	public String toString() {


		return "People{" +
				"id='" + id + '\'' +
				", age=" + age +
				", name='" + name + '\'' +
				", address='" + address + '\'' +
				'}';
	}
}

2，在resources/META-INF目录下定义people.xsd，spring.handlers，spring.schemas文件

people.xsd

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
		targetNamespace="http://www.bobo.com/schema/people"
		xmlns:tns="http://www.bobo.com/schema/people"
		elementFormDefault="qualified">
	<element name="people">
		<complexType>
			<attribute name ="id" type = "string"/>
			<attribute name ="age" type = "int"/>
			<attribute name ="name" type = "string"/>
			<attribute name ="address" type = "string"/>
		</complexType>
	</element>
</schema>

spring.handlers

http\://www.bobo.com/schema/people=com.bobo.custom.PeopleNamespaceHandler

spring.schemas

http\://www.bobo.com/schema/people.xsd=META-INF/people.xsd

3，创建对应的namespaceHandler类PeopleNamespaceHandler.java

package com.wsj.custom;

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

/**
 * @author wsj
 * @date 2024-04-20
 */

public class PeopleNamespaceHandler extends NamespaceHandlerSupport {


	@Override
	public void init() {


		super.registerBeanDefinitionParser("people",new PeopleBeanDefinitionParser());
	}
}

4，创建对应的BeanDefinitionParser类PeopleBeanDefinitionParser.java

package com.wsj.custom;

import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
import org.springframework.util.StringUtils;
import org.w3c.dom.Element;

/**
 * @author wsj
 * @date 2024-04-20
 */

public class PeopleBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {


	@Override
	protected Class<?> getBeanClass(Element element) {


		return People.class;
	}

	@Override
	protected void doParse(Element element, BeanDefinitionBuilder builder) {


		String id = element.getAttribute("id");
		String age = element.getAttribute("age");
		String name = element.getAttribute("name");
		String address = element.getAttribute("address");
		if (StringUtils.hasLength(id)){


			builder.addPropertyValue("id",id);
		}
		if (StringUtils.hasLength(age)){


			builder.addPropertyValue("age",age);
		}
		if (StringUtils.hasLength(name)){


			builder.addPropertyValue("name",name);
		}
		if (StringUtils.hasLength(address)){


			builder.addPropertyValue("address",address);
		}
	}
}

5，创建application-context.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:bo="http://www.bobo.com/schema/people"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
			http://www.bobo.com/schema/people http://www.bobo.com/schema/people.xsd">

	<bo:people id="wsj" age="20" name="wsjxtt" address="广东省深圳市"></bo:people>

</beans>

6，创建测试类

package com.wsj;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {



	public static void main(String[] args) {


		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml");
		System.out.println(context.getBean("wsj"));
	}
}

运行输出

People{

	 id='wsj', age=20, name='wsjxtt', address='广东省深圳市'}

二价亚铁.

关注

7
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring源码分析

Spring的强大之处不仅仅在于它为Java开发者提供了极大便利，更在于它的开放式架构，使得用户可以拥有最大扩展Spring的能力。我们在用xml定义spring信息时，默认的element只包含beans，bean，import，alias这四个，其它任何标签都属于自定义标签，均需要引入相应的命名空间，如：context，aop标签等。i++) {//处理默认的标签元素else {//处理自定义的标签元素else {
复制链接

扫一扫