Spring解析xml实现依赖注入

一、环境准备

引入依赖

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

相关类

public interface UserDao {
    public void findName();
}

public class UserDaoImpl implements  UserDao{
    @Override
    public void findName() {
        System.out.println("我是dao实现类1");
    }
}

public interface UserService {
    public void findAge();
}

public class UserServiceImpl implements UserService {

    UserDao dao;

    @Override
    public void findAge() {
        System.out.println("我是service的实现类");
        dao.findName();
    }

    public void setDao(UserDao dao) {
        this.dao = dao;
    }
}

配置文件spring.xml

<?xml version="1.0" encoding="UTF-8" ?>

<beans>
    <bea id="dao" class="com.cjx.spring.dao.UserDaoImpl"></bea>
    <bean id="service" class="com.cjx.spring.service.UserServiceImpl">
        <property name="dao" ref="dao"></property>
    </bean>
</beans>

二、关键代码

public class BeanFactory {

    public  BeanFactory(String xml){
        parseXml(xml);
    }

    Map map=new HashMap<String,Object>();//模拟IOC容器

    public void parseXml(String xml)  {

        File file = new File(this.getClass().getResource("/").getPath()+"//"+xml);//获取xml文件
        SAXReader reader = new SAXReader();
        try {
            Document document = reader.read(file);//获取xml文档
            Element rootElement = document.getRootElement();//获取根元素
            for (Iterator<Element> itFirst = rootElement.elementIterator(); itFirst.hasNext();) {//变量根元素下的元素,也就是第一层子标签
                Element elementFistChild = itFirst.next();
                // do something
                /*
                第一步实例化对象
                 */
                Attribute attributeId = elementFistChild.attribute("id");//获取属性id中的填写的信息
                String beanName = attributeId.getValue();
                Attribute aClass = elementFistChild.attribute("class");//获取属性class属性中的信息
                String clazzName = aClass.getValue();
                Class clazz = Class.forName(clazzName);
                Object instance = clazz.newInstance();//实例化
                /*
                    第二步维护依赖
                    判断这个对象是否有依赖 （判断是否有property，判断类是否有属性）
                    如果有就注入d
                 */

                for (Iterator<Element> itSecon = elementFistChild.elementIterator(); itSecon.hasNext();){//第二层
                    Element elementSecondChild = itSecon.next();
                    System.out.println(elementSecondChild.getName());
                    if (elementSecondChild.getName().equals("property")) {
                        String refValue= elementSecondChild.attribute("ref").getValue();
                        Object injetObject = map.get(refValue);//需要注入的对象
                        String nameValue= elementSecondChild.attribute("name").getValue();
                        Field field = clazz.getDeclaredField(nameValue);
                            field.setAccessible(true);
                            field.set(instance,injetObject);
                    }
                }
                map.put(beanName,instance);//放入IOC容器中
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(map);
    }
    public Object getBean(String beanName){
        return map.get(beanName);
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        BeanFactory beanFactory = new BeanFactory("spring.xml");
        UserService service= (UserService) beanFactory.getBean("service");
        service.findAge();
    }
}

测试通过，得到预料的结果

总结：上面使用的是setter方式注入的，构造注入的方式也是如此。代码中解析代码是最简单版本，spring中在xml中的解析是做了非常多的判断的。ioc容器实际应用也是比较复杂的，并不是仅仅的是一个map就可以搞定的。通过一个简单的案例解析spring通过xml注入依赖的。

本文地址：https://blog.csdn.net/chenjiexong/article/details/107380460