手写简易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