写点什么

手写 SpringIOC

用户头像
彭阿三
关注
发布于: 2020 年 10 月 10 日

当我们想去了解一个框架的源码的时候,我们只需要先去关注他的核心代码没有必要强迫自己去理解每一行代码,然后我们自己去手写一个简易版本的框架这样能够帮助我们更加的去了解他的设计初衷。



springIOC的特点

  • spring ioc,spring容器,根据xml配置,或者是你的注解,去实例化你的一些bean对象,然后根据xml配置或者注解,去对bean对象之间的引用关系,去进行依赖注入,某个bean依赖了另外一个bean

  • 底层核心技术、反射技术,他会通过反射的技术,直接根据你的类去自己构建对应的对象出来,用的就是反射技术

  • spring ioc,系统的类与类之间彻底的解耦合



我的springIOC的目录结构



其中我们主要使用的只有MyIocConainer、OrderDao、OrderService、UserDao、XmlPath2Bean和配置文件spring-ioc-my.xml



手写springIOC源码

首先是spring-ioc-my.xml 配置文件,配置好容器初始化需要加载的bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 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">

<!-- 创建方式1:空参构造创建 -->
<bean id="orderDao" class="springioc.OrderDao"/>
<bean id="userDao" class="springioc.UserDao"/>
<bean id="orderService" class="springioc.OrderService"/>

</beans>



解析xml的工具类

/**
* @Classname XmlPath2Bean
* @Description TODO
* @Date 2020/10/10 2:27 PM
* @Author by pengasan
*/
public class XmlPath2Bean {
private String xmlPath;
public XmlPath2Bean(String xmlPath) {
this.xmlPath = xmlPath;
}
/**
* 读取xml文件
* @param
* @return java.util.List<org.dom4j.Element>
* @date 2020/10/6 2:00 PM
* @auther lixin
*/
public List<Element> readXML() throws DocumentException {
SAXReader saxReader = new SAXReader();
// 1.解析xml文件
Document document = saxReader.read(getResourceAsStream(xmlPath));
// 读取跟节点
Element rootElement = document.getRootElement();
// 获取下面的子节点
List<Element> elements = rootElement.elements();
return elements;
}
/**
* 获取当前上下文路径
* @param xmlPath
* @return
*/
public InputStream getResourceAsStream(String xmlPath) {
return this.getClass().getClassLoader().getResourceAsStream(xmlPath);
}
}

手写的容器类

public class MyIocContainer {
// 定义一个容器! 存放 bean 的名字到 bean 实例对象的映射
private Map<String, Object> container = new HashMap<>();
/**
* 启动容器
* @param
* @return void
* @date 2020/10/10 2:22 PM
* @auther lixin
*/
public void start(String xmlPath) throws DocumentException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
// bean的初始化
XmlPath2Bean context = new XmlPath2Bean(xmlPath);
//从xml读取配置文件
List<Element> list = context.readXML();
for (Element element :list ) {
String key = element.attributeValue("id");
String classPath = element.attributeValue("class");
//利用反射拿到clazz
Class clazz = Class.forName(classPath);
//创建单利bean对象
Object beanInstance = clazz.getConstructor().newInstance();
//放入ioc容器
container.put(key, beanInstance);
}
//遍历container注入每个bean的依赖
//stream
container.forEach((beanName,beanInstance) -> dePendencyInject(beanInstance));
//传统方式便于理解
container.forEach((beanName,beanInstance) -> dePendencyInject2(beanInstance));
}
/**
* 注入依赖 stream的方式
* @param beanInstance
* @return void
* @date 2020/10/10 2:43 PM
* @auther lixin
*/
private void dePendencyInject(Object beanInstance) {
// 拿到带有 @AutoWired 注解的 fields
List<Field> fieldsToBeAutoWired = Stream.of(beanInstance.getClass().getDeclaredFields())
.filter(field -> field.getAnnotation(Autowired.class) != null)
.collect(Collectors.toList());
// 为当前 bean 对象的需要依赖的字段注入依赖(设置字段值)
fieldsToBeAutoWired.forEach(field -> {
// 加了 @AutoWired 的字段名即是所要依赖的 bean 的名字
String fieldName = field.getName();
Object dependencyBeanInstance = container.get(fieldName); // 所依赖的 bean 实例
try {
// 设置为 true 用来压制针对被反射对象的访问检查
field.setAccessible(true);
// 从而可以在这里设置当前 bean 的私有字段
field.set(beanInstance, dependencyBeanInstance);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
});
}
/**
* 注入依赖 传统方式
* @param beanInstance
* @return void
* @date 2020/10/10 2:43 PM
* @auther lixin
*/
private void dePendencyInject2(Object beanInstance) {
//创建一个list
List<Field> fieldsToBeAutoWired = new ArrayList<>();
//拿到所有属性
Field[] listField = beanInstance.getClass().getDeclaredFields();
for (Field field : listField) {
// 找到带有Autowired注解的属性
if (field.getAnnotation(Autowired.class) != null){
//放入list
fieldsToBeAutoWired.add(field);
}
}
// 为当前 bean 对象的需要依赖的字段注入依赖(设置字段值)
for (Field field : fieldsToBeAutoWired) {
// 加了 @AutoWired 的字段名即是所要依赖的 bean 的名字
String fieldName = field.getName();
// 去容器中找到所需要的bean
Object dependencyBeanInstance = container.get(fieldName);
try {
// 设置为 true 用来压制针对被反射对象的访问检查
field.setAccessible(true);
// 从而可以在这里设置当前 bean 的私有字段
field.set(beanInstance, dependencyBeanInstance);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
/**
* 根据名称获取bean
* @param name
* @return java.lang.Object
* @date 2020/10/10 3:15 PM
* @auther lixin
*/
public Object getBean(String name){
return container.get(name);
}
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, DocumentException, InvocationTargetException, ClassNotFoundException {
MyIocContainer context = new MyIocContainer();
context.start("spring-ioc-my.xml");
}
}

不太重要的orderService



发布于: 2020 年 10 月 10 日阅读数: 42
用户头像

彭阿三

关注

java工程师 2019.06.28 加入

一个慵懒的程序员。

评论

发布
暂无评论
手写SpringIOC