自己参考spring,模拟实现Spring的IOC功能,加深理解.
项目结构如下:
下图是个人对IOC理解画的关系图
接口:
BeanFactory ,IOC的容器,需要有注册Bean和获取Bean的方法
package com.szt.myioc.factory;
import com.szt.myioc.BeanDefinition;
/**
* @author: sunzhitao
* @date: 2018/7/22 16:26
* @description: IOC容器的接口 需要两个基本方法 注册bean 获取bean
*/
public interface BeanFactory {
/**
* 根据bean的名字获取ioc容器中的bean
* @return bean实例
* @throws Exception
*/
Object getBean(String name) throws Exception;
/**
* 将bean注册到ioc容器中
* @param name
* @param beanDefinition
* @throws Exception
*/
void registerBeanDefinition(String name, BeanDefinition beanDefinition) throws Exception;
}IOC容器的初始化，分为三步 BeanDefinition的Resource定位、载入以及注册。Spring ioc容器有了,需要BeanDefinition.BeanDefinition需要一些方法,需要一个 Bean 对象，一个Class对象，一个ClassName字符串，还需要一个元素集合 PropertyValues。这些组成一个最基本的 BeanDefinition 类。
/**
* @author: sunzhitao
* @date: 2018/7/22 16:28
* @description: BeanDefinition bean定义
*/
public class BeanDefinition {
/**
* bean
*/
private Object bean;
/**
* bean 的 CLass 对象
*/
private Class beanClass;
/**
* bean 的类全称,包含包地址
*/
private String ClassName;
/**
* 类的属性集合
*/
private PropertyValues propertyValues = new PropertyValues();
/**
* 获取bean对象
*/
public Object getBean() {
return this.bean;
}
/**
* 设置bean的对象
*/
public void setBean(Object bean) {
this.bean = bean;
}
/**
* 获取bean的Class对象
*/
public Class getBeanclass() {
return this.beanClass;
}
/**
* 通过设置类名称反射生成Class对象
*/
public void setClassname(String name) {
this.ClassName = name;
try {
this.beanClass = Class.forName(name);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 获取bean的属性集合
*/
public PropertyValues getPropertyValues() {
return this.propertyValues;
}
/**
* 设置bean的属性
*/
public void setPropertyValues(PropertyValues pv) {
this.propertyValues = pv;
}
}有了BeanDefinition 那么 容器初始化过程的中,Resource的定位,载入注册,需要一个从XML中读取并解析为 BeanDefinition 的操作类,定义一个 BeanDefinitionReader 接口,然后实现这个接口的类用来完成Resource的定位操作.还需要一个资源加载器ResourceLoader,用于加载xml文件.
/**
* @author: sunzhitao
* @date: 2018/7/22 16:36
* @description: 抽象的bean定义读取类
*/
public abstract class AbstractBeanDefinitionReader implements BeanDefinitionReader {
/**
* 注册bean容器
*/
private Map<String, BeanDefinition> registry;
/**
* 资源加载器
*/
private ResourceLoader resourceLoader;
/**
* 构造器器必须有一个资源加载器， 默认插件创建一个map容器
*
* @param resourceLoader 资源加载器
*/
protected AbstractBeanDefinitionReader(ResourceLoader resourceLoader) {
this.registry = new HashMap<>();
this.resourceLoader = resourceLoader;
}
/**
* 获取容器
*/
public Map<String, BeanDefinition> getRegistry() {
return registry;
}
/**
* 获取资源加载器
*/
public ResourceLoader getResourceLoader() {
return resourceLoader;
}
}这时候,基本的流程就ok了.BeanDefinitionReader 从xml中读取bean的配置信息,生成BeanDefinition,放到BeanFactory容器中,初始化之后,使用getBean()方法获取bean.
实现:
1.读取xml文件中对bean的定义信息,解析成BeanDefinition
从xml中读取bean信息过程中,需要用到类资源加载器 ResourceLoader.类资源加载器,需要根据给定的资源路径加载资源,所以需要一个ResourceUrl.
public interface Resource {
/**
* 获取输入流
*/
InputStream getInputstream() throws Exception;
}public class ResourceLoader {
/**
* 给定一个位置， 使用累加器的资源加载URL，并创建一个“资源URL”对象，便于获取输入流
*/
public ResourceUrl getResource(String location) {
URL url = this.getClass().getClassLoader().getResource(location);
return new ResourceUrl(url);
}
}ResourceLoader需要用到ResourceUrl.
/**
* 资源URL
*/
public class ResourceUrl implements Resource {
/**
* 类库URL
*/
private final URL url;
/**
* 需要一个类库URL
*/
public ResourceUrl(URL url) {
this.url = url;
}
/**
* 从URL中获取输入流
*/
@Override
public InputStream getInputstream() throws Exception {
URLConnection urlConnection = url.openConnection();
urlConnection.connect();
return urlConnection.getInputStream();
}
}以上所做全都是为了满足AbstractBeanDefinitionReader 的需要,现在需要一个类继承AbstractBeanDefinitionReader,去实现具体的功能.现在定义一个XmlBeanDefinitionReader 继承他,然后读取xml,获取bean信息,然后再将获取到的转化成一个对象,注册到我们的容器中.
public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
/**
* 构造器器必须有一个资源加载器， 默认插件创建一个map容器
*
* @param resourceLoader 资源加载器
*/
protected XmlBeanDefinitionReader(ResourceLoader resourceLoader) {
super(resourceLoader);
}
/**
* 解析xml的方法
* @param Location
* @throws Exception
*/
public void readerXML(String Location) throws Exception{
//创建一个资源加载器
ResourceLoader resourceLoader = new ResourceLoader();
//从资源加载器获取流
InputStream inputstream = resourceLoader.getResource(Location).getInputstream();
//获取文档建造者工厂实例
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
//工厂创建文档建造者
DocumentBuilder documentBuilder = factory.newDocumentBuilder();
//文档建造者解析流,返回文档对象
Document doc = documentBuilder.parse(inputstream);
//根据给定的文档解析,注册到bean容器中
registerBeanDefinitions(doc);
//关闭流
inputstream.close();
}
/**
* 根据给定的文档对象进行解析，并注册到bean容器中
*
* @param doc 文档对象
*/
private void registerBeanDefinitions(Document doc) {
// 读取文档的根元素
Element root = doc.getDocumentElement();
// 解析元素的根节点及根节点下的所有子节点并添加进注册容器
parseBeanDefinitions(root);
}
/**
* 解析元素的根节点及根节点下的所有子节点并添加进注册容器
*
* @param root XML 文件根节点
*/
private void parseBeanDefinitions(Element 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;
// 解析给给定的节点，包括name，class，property， name， value，ref
processBeanDefinition(ele);
}
}
}
/**
* 解析给给定的节点，包括name，class，property， name， value，ref
*
* @param ele XML 解析元素
*/
private void processBeanDefinition(Element ele) {
// 获取给定元素的 name 属性
String name = ele.getAttribute("name");
// 获取给定元素的 class 属性
String className = ele.getAttribute("class");
// 创建一个bean定义对象
BeanDefinition beanDefinition = new BeanDefinition();
// 设置bean 定义对象的 全限定类名
beanDefinition.setClassname(className);
// 向 bean 注入配置文件中的成员变量
addPropertyValues(ele, beanDefinition);
// 向注册容器 添加bean名称和bean定义
getRegistry().put(name, beanDefinition);
}
/**
* 添加配置文件中的属性元素到bean定义实例中
*
* @param ele 元素
* @param beandefinition bean定义 对象
*/
private void addPropertyValues(Element ele, BeanDefinition beandefinition) {
// 获取给定元素的 property 属性集合
NodeList propertyNode = ele.getElementsByTagName("property");
// 循环集合
for (int i = 0; i < propertyNode.getLength(); i++) {
// 获取集合中某个给定位置的节点
Node node = propertyNode.item(i);
// 类型判断
if (node instanceof Element) {
// 将节点向下强转为子元素
Element propertyEle = (Element) node;
// 元素对象获取 name 属性
String name = propertyEle.getAttribute("name");
// 元素对象获取 value 属性值
String value = propertyEle.getAttribute("value");
// 判断value不为空
if (value != null && value.length() > 0) {
// 向给定的 “bean定义” 实例中添加该成员变量
beandefinition.getPropertyValues().addPropertyValue(new PropertyValue(name, value));
} else {
// 如果为空，则获取属性ref
String ref = propertyEle.getAttribute("ref");
if (ref == null || ref.length() == 0) {
// 如果属性ref为空，则抛出异常
throw new IllegalArgumentException(
"Configuration problem: <property> element for property '"
+ name + "' must specify a ref or value");
}
// 如果不为空，测创建一个 “bean的引用” 实例，构造参数为名称，实例暂时为空
BeanReference beanRef = new BeanReference(name);
// 向给定的 “bean定义” 中添加成员变量
beandefinition.getPropertyValues().addPropertyValue(new PropertyValue(name, beanRef));
}
}
}
}
}上面成功解析xml,并且将bean放入到了容器中,但是注意的是,这时候放入的是BeanDefinitionReader 的 Map 中。还没有给ioc容器.
已经有了BeanFactory,但是没有实现,现在根据BeanFactory定义一个抽象类AbstractBeanFactory.
/**
* @author: sunzhitao
* @date: 2018/7/22 18:14
* @description: beanfactory的实现类 实现了 bean 的方法，
* 包含一个map，用于存储bean 的名字和bean的定义
*/
public abstract class AbstractBeanFactory implements BeanFactory {
/**
* 容器
*/
private HashMap<String, BeanDefinition> map =new HashMap<>();
/**
* 根据bean的名称获取bean,没有则抛异常,有,从bean定义对象获取bean实例
* @return bean的实例对象
* @throws Exception
*/
@Override
public Object getBean(String name) throws Exception {
BeanDefinition beanDefinition = map.get(name);
if(beanDefinition == null){
throw new IllegalArgumentException("No bean Name "+name+" is defined");
}
Object bean = beanDefinition.getBean();
if(bean==null){
bean = doCreate(beanDefinition);
}
return bean;
}
/**
* 注册 bean定义的抽象方法实现
* @param name
* @param beanDefinition
* @throws Exception
*/
@Override
public void registerBeanDefinition(String name, BeanDefinition beanDefinition) throws Exception {
Object bean = doCreate(beanDefinition);
beanDefinition.setBean(bean);
map.put(name,beanDefinition);
}
/**
* 创建一个bean
*/
abstract Object doCreate(BeanDefinition beandefinition) throws Exception;
}上面的抽象类,里面用一个Map用来作为管理bean的容器,给到一个获取bean的getBean()方法,一个bean的注册方法.现在新建一个类实现这个抽象方法,完成最终的bean注册.
/**
* @author: sunzhitao
* @date: 2018/7/22 20:08
* @description: 实现自动注入和递归注入(spring的标准实现类 DefaultListableBeanFactory)
*/
public class AutowireBeanFactory extends AbstractBeanFactory {
/**
* 根据bean定义创建实例,并且将实例作为key,bean定义作为value存放,并且调用addPropertyValue方法
* 为给定的bean的属性进行注入
* @param beandefinition bean定义
* @return
* @throws Exception
*/
@Override
Object doCreate(BeanDefinition beandefinition) throws Exception {
Object bean = beandefinition.getBeanclass().newInstance();
addPropertyValue(bean,beandefinition);
return null;
}
/**
* 给定一个bean定义和一个bean实例，为给定的bean中的属性注入实例。
*/
protected void addPropertyValue(Object bean, BeanDefinition beandefinition) throws Exception {
// 循环给定 bean 的属性集合
for (PropertyValue pv : beandefinition.getPropertyValues().getPropertyValues()) {
// 根据给定属性名称获取 给定的bean中的属性对象
Field declaredField = bean.getClass().getDeclaredField(pv.getname());
// 设置属性的访问权限
declaredField.setAccessible(true);
// 获取定义的属性中的对象
Object value = pv.getvalue();
// 判断这个对象是否是 BeanReference 对象
if (value instanceof BeanReference) {
// 将属性对象转为 BeanReference 对象
BeanReference beanReference = (BeanReference) value;
// 调用父类的 AbstractBeanFactory 的 getBean 方法，根据bean引用的名称获取实例，此处即是递归
value = getBean(beanReference.getName());
}
// 反射注入bean的属性
declaredField.set(bean, value);
}
}
}doCreate 方法使用了反射创建了一个对象，并且还需要对该对象进行属性注入，如果属性是 ref 类型，那么既是依赖关系，则需要调用 getBean 方法递归的去寻找那个Bean（因为最后一个Bean 的属性肯定是基本类型）。这样就完成了一次获取实例化Bean操作，并且也实现类依赖注入。
整个过程的总结如下图:
代码地址：https://github.com/sunzhitao/springboot/tree/master/myioc