手写简单版spring ioc之constructor注入

源码： https://github.com/kangwenzhuang/springiocconstructor
个人理解，观点可能片面，欢迎在评论区喷我，这样我才能成长
适合新手，高手请绕开

Spring IOC为什么是必要的

这篇博客写的很清楚
https://blog.csdn.net/qq_41805859/article/details/102691899

手把手教你spring ioc，通过constructor实现

目录结构

既然是手写，那就不需要引入spring jar包，创建maven项目，我们只需要解析xml的jar包就可以，我们选用dom4j

        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>

第一步创建UserDao，接口UserService和UserServiceImpl

package com.kang.dao;

public class UserDao {
    public void addUser(){
        System.out.println("use userDao add user");
    }
}

package com.kang.service;

public interface UserService {
    void addUser();
}

package com.kang.service.impl;

import com.kang.dao.UserDao;
import com.kang.service.UserService;

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public UserServiceImpl() {
    }

    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    public void addUser() {
        userDao.addUser();
    }
}

第二步是不是就要创建ApplicationContext.xml了，定义bean和bean之间的依赖关系

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean id="userService" class="com.kang.service.impl.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>
    <bean id="userDao" class="com.kang.dao.UserDao"></bean>
</beans>

第三步就是创建一个类，用来解析ApplicationContext.xml，装载bean并且完成注入

根据自己的理解，实现了其实一种写法，不规范的地方可以指出

package com.kang;

import com.kang.service.UserService;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SimpleBeanFactory {
    //定义beanFactory保存bean,key-value
    private Map<String, Object> beanFactory = new HashMap<String, Object>();
    private String path;

    public SimpleBeanFactory(String path) {
        this.path = path;
        BeansAndI();
    }

    void BeansAndI() {
        //使用dom4j解析xml文件读取bean标签，将对象创建出来用id为键，对象为值保存到容器中
        SAXReader reader = new SAXReader();
        try {
            //通过反射机制获取资源文件的路径
            URL url = SimpleBeanFactory.class.getClassLoader().getResource(this.path);
            //读取xml文件
            Document document = reader.read(url);
            //获取根便签
            Element rootElement = document.getRootElement();
            //读取bean标签，得到对应对象集合
            List<Element> beans = rootElement.elements("bean");

            //获取bean标签中的id作为键，class对象值，并保存到容器中
            for (Element b : beans) {
                //获取id键
                String key = b.attributeValue("id");
                //获取class值
                String value = b.attributeValue("class");
                //存入容器中
                beanFactory.put(key, Class.forName(value).newInstance());
            }
            //根据constructor-arg标签定义的依赖关系完成依赖注入
            for (Element b : beans) {
                //获取bean下的constructor-arg标签
                List<Element> properties = b.elements("constructor-arg");
                for (Element p : properties) {
                    //需要被赋值的属性名称
                    String pName = p.attributeValue("name");
                    //该属性需要赋值的对象在容器里的id
                    String pRef = p.attributeValue("ref");
                    //从容器中拿到被依赖的对象
                    Object refObject = beanFactory.get(pRef);

                    //根据bean标签拿到正在循环的这个bean标签的id
                    String key = b.attributeValue("id");
                    //从容器中取出依赖方对象
                    Object object = beanFactory.get(key);
                    //获取依赖方的字节码信息
                    Class c = object.getClass();
                    //通过反射，构造函数
                    Constructor constructor=c.getConstructor(refObject.getClass());
                    //将修改后的bean重新装配到beanFactory!!!!!!!!!!!!!!
                    object=constructor.newInstance(refObject);
                    beanFactory.put(key,object);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public Object getBean(String id) {
        return beanFactory.get(id);
    }

    //测试一下能否运行
    public static void main(String[] args) {
        SimpleBeanFactory beans = new SimpleBeanFactory("ApplicationContext.xml");
        UserService userService = (UserService) beans.getBean("userService");
        userService.addUser();
    }
}

直接在SimpleBeanFactory类中创建main函数进行测试
输出结果：use userDao add user

第四步就是替换

main函数我可以这样写吗？

public static void main(String[] args) {
		ClassPathXmlApplicationContext beans = new ClassPathXmlApplicationContext("ApplicationContext.xml");
		UserService service = (UserService) beans.getBean("userService");
		userService.addUser();
	}

肯定可以啊，只是你要添加官方的spring jar包，自己动手试试