手写简易springIOC
springIOC的特点
- spring ioc，spring容器，根据xml配置，或者是你的注解，去实例化你的一些bean对象，然后根据xml配置或者注解，去对bean对象之间的引用关系，去进行依赖注入，某个bean依赖了另外一个bean
- 底层核心技术、反射技术，他会通过反射的技术，直接根据你的类去自己构建对应的对象出来，用的就是反射技术
- spring ioc，系统的类与类之间彻底的解耦合
我的springIOC的目录结构
1602314613377.jpg
其中我们主要使用的只有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
1602315055571.jpg
