Laoshiren

中文

中文

Appearance

Return to top
On this page

手写一个spring项目

手写spring 是一个解读源码的项目。和别的解读源码不同，主要让同学们一点一点开始写spring 的代码(可能和spring 有所出入)。spring 在市面上如此广泛地使用，里面的设计模式，类型设计值得说的有太多太多了，这篇文章就是把我觉得精华的不分提炼出来，写成一篇文章。当然这个文章的素材主要还是参考了spring 的源码，mini-spring，和我平时对spring 的理解。

BeanFactory

容器

容器是用来存储和组织其他对象的对象。

映射(map)由{键，值}对组成的集合，以某种作用于键对上的谓词排列，我们在高中阶段其实已经学习过映射了，映射指两个元素的之间相互“对应”的关系，也就是说，我们的元素之间是两两对应的，是以键值对的形式存在。

其实在工作开发中我们会经常使用map，所以这里不再阐述map。我们现在将的容器是值得spring 里的容器。

import java.util.HashMap;
import java.util.Map;

public class BeanFactory {
	private Map<String, Object> beanMap = new HashMap<>();

	public void registerBean(String name, Object bean) {
		beanMap.put(name, bean);
	}

	public Object getBean(String name) {
		return beanMap.get(name);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

我们对外提供一个注册Bean 的方法和一个获取Bean 的方法。通过简单的put()和get()方法来注册获取Bean。

BeanDefinition

顾名思义，用于定义bean 信息的类，包含bean 的class 类型、构造参数、属性值等信息，每个bean 对应一个BeanDefinition 的实例。简化BeanDefinition 仅包含bean 的class 类型。

/**
 * 保存bean的信息，包括class类型、方法构造参数、是否为单例等，此处简化只包含class类型
 */
public class BeanDefinition {

	private Class beanClass;

	public BeanDefinition(Class beanClass) {
		this.beanClass = beanClass;
	}

	public Class getBeanClass() {
		return beanClass;
	}

	public void setBeanClass(Class beanClass) {
		this.beanClass = beanClass;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

https://img-blog.csdnimg.cn/ec931cf4862640eb84915d165a0f4a0e.png

  1. BeanDefinitionRegistry，BeanDefinition 注册表接口，定义注册BeanDefinition 的方法。
  2. SingletonBeanRegistry 及其实现类DefaultSingletonBeanRegistry，定义添加和获取单例bean 的方法。

bean 容器作为BeanDefinitionRegistry和SingletonBeanRegistry 的实现类，具备两者的能力。向bean 容器中注册BeanDefintion 后，使用bean 时才会实例化。

java
// 获取单例Bean 接口
public interface SingletonBeanRegistry {

	Object getSingleton(String beanName);
}

public interface BeanDefinitionRegistry {

	/**
	 * 向容器中注BeanDefinition
	 */
	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);
}

public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {

	private Map<String, Object> singletonObjects = new HashMap<>();
	
    // 一定从单例池里获取
	@Override
	public Object getSingleton(String beanName) {
		return singletonObjects.get(beanName);
	}

	protected void addSingleton(String beanName, Object singletonObject) {
		singletonObjects.put(beanName, singletonObject);
	}
}

public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory {

	@Override
	public Object getBean(String name) throws BeansException {
		Object bean = getSingleton(name);
		if (bean != null) {
			return bean;
		}
		BeanDefinition beanDefinition = getBeanDefinition(name);
		return createBean(name, beanDefinition);
	}

	protected abstract Object createBean(String beanName, BeanDefinition beanDefinition) throws BeansException;

	protected abstract BeanDefinition getBeanDefinition(String beanName) throws BeansException;
}

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory {

	@Override
	protected Object createBean(String beanName, BeanDefinition beanDefinition) throws BeansException {
		return doCreateBean(beanName, beanDefinition);
	}

	protected Object doCreateBean(String beanName, BeanDefinition beanDefinition) {
		Class beanClass = beanDefinition.getBeanClass();
		Object bean = null;
		try {
			bean = beanClass.newInstance();
		} catch (Exception e) {
			throw new BeansException("Instantiation of bean failed", e);
		}

		addSingleton(beanName, bean);
		return bean;
	}
}

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements BeanDefinitionRegistry {

	private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();

	@Override
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
		beanDefinitionMap.put(beanName, beanDefinition);
	}

	@Override
	protected BeanDefinition getBeanDefinition(String beanName) throws BeansException {
        // 先从BeanDefinitionMap 里获取BeanDefinition
		BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
		if (beanDefinition == null) {
			throw new BeansException("No bean named '" + beanName + "' is defined");
		}

		return beanDefinition;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

我们在使用DefaultListableBeanFactory获取bean 的时候直接从singletonObjects属性里获取，如果没有，说明可能没有实例化，或者没有注册过，那我们再从beanDefinitionMap里获取，然后在进行实例化。

实例化策略

现在bean 是在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean方法中用beanClass.newInstance()来实例化，仅适用于bean有无参构造函数的情况。

java
public interface InstantiationStrategy {

	Object instantiate(BeanDefinition beanDefinition) throws BeansException;
}

public class SimpleInstantiationStrategy implements InstantiationStrategy {

	/**
	 * 简单的bean实例化策略，根据bean的无参构造函数实例化对象
	 *
	 * @param beanDefinition
	 * @return
	 * @throws BeansException
	 */
	@Override
	public Object instantiate(BeanDefinition beanDefinition) throws BeansException {
		Class beanClass = beanDefinition.getBeanClass();
		try {
			Constructor constructor = beanClass.getDeclaredConstructor();
			return constructor.newInstance();
		} catch (Exception e) {
			throw new BeansException("Failed to instantiate [" + beanClass.getName() + "]", e);
		}
	}
}


public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory {

	private InstantiationStrategy instantiationStrategy = new SimpleInstantiationStrategy();

	@Override
	protected Object createBean(String beanName, BeanDefinition beanDefinition) throws BeansException {
		return doCreateBean(beanName, beanDefinition);
	}

	protected Object doCreateBean(String beanName, BeanDefinition beanDefinition) {
		Object bean = null;
		try {
			bean = createBeanInstance(beanDefinition);
		} catch (Exception e) {
			throw new BeansException("Instantiation of bean failed", e);
		}

		addSingleton(beanName, bean);
		return bean;
	}
	// 根据实例化策略实例化Bean
	protected Object createBeanInstance(BeanDefinition beanDefinition) {
		return getInstantiationStrategy().instantiate(beanDefinition);
	}

	public InstantiationStrategy getInstantiationStrategy() {
		return instantiationStrategy;
	}

	public void setInstantiationStrategy(InstantiationStrategy instantiationStrategy) {
		this.instantiationStrategy = instantiationStrategy;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

bean填充属性

在BeanDefinition 中增加和bean 属性对应的PropertyVales ，实例化bean 之后，为bean 填充属性(AbstractAutowireCapableBeanFactory#applyPropertyValues)。

java
/**
 * 为bean填充属性
 *
 */
protected void applyPropertyValues(String beanName, Object bean, BeanDefinition beanDefinition) {
	try {
		for (PropertyValue propertyValue : beanDefinition.getPropertyValues().getPropertyValues()) {
			String name = propertyValue.getName();
			Object value = propertyValue.getValue();
			if (value instanceof BeanReference) {
				// beanA依赖beanB，先实例化beanB
				BeanReference beanReference = (BeanReference) value;
				value = getBean(beanReference.getBeanName());
			}
			//通过反射设置属性
			BeanUtil.setFieldValue(bean, name, value);
		}
	} catch (Exception ex) {
		throw new BeansException("Error setting property values for bean: " + beanName, ex);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

BeanFactoryPostProcessor和BeanPostProcessor

BeanFactoryPostProcessor

java
public interface BeanFactoryPostProcessor {

	/**
	 * 在所有BeanDefintion加载完成后，但在bean实例化之前，提供修改BeanDefinition属性值的机制
	 *
	 * @param beanFactory
	 * @throws BeansException
	 */
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}
1
2
3
4
5
6
7
8
9
10
11

像BeanFactory 后置处理器，我在spring 第三讲已经提过了。处理一些特定注解比如@CompomentScan、@Configuration ，然后解析一些Bean 注册到BeanFactory 里。

BeanPostProcessor

java
public interface BeanPostProcessor {

	/**
	 * 在bean执行初始化方法之前执行此方法
	 *
	 * @param bean
	 * @param beanName
	 * @return
	 * @throws BeansException
	 */
	Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

	/**
	 * 在bean执行初始化方法之后执行此方法
	 *
	 * @param bean
	 * @param beanName
	 * @return
	 * @throws BeansException
	 */
	Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Bean 后置处理器，翻看spring 第四讲， 调用@PostConstruct，销毁前会掉@PreDestroy所修饰的方法。解析@Autowired 和@Value。

ApplicationContext

​ 在这里插入图片描述

Released under the MIT License.

Copyright © 2018-present Laoshiren