Java 反射和内省实现spring的IOC和DI

1.构造两个JavaBean　

package com.spring.model;

public class People {

    private Car car;

    public Car getCar() {
        return car;

    }

    public void setCar(Car car) {
        this.car = car;
    }

}

package com.spring.model;

public class Car {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void show() {
        System.out.println("我是"+name+"车");
    }

}

2.构建一个类似于spring配置的xml文件 spring-bean.xml

　　按照spring一样的格式配置好节点和属性

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean id="car" class="com.spring.model.Car">
    </bean>

    <bean id="people" class="com.spring.model.People">
        <property name="car" ref="car"></property>
    </bean>
</beans>

3.构建一个类似spring加载配置文件的类 里面运用了反射和内省的机制

package com.spring.core;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

/**
 *
 * 模仿spring IOC、DI 底层实现
 * @author GET_CHEN
 *
 */
public class ClassPathXmlApplicationContext {
    private String configXml;
    private Map<String,Object> map = new HashMap<String,Object>();//保存配置文件中的id和class所实例化出来的对象
    public ClassPathXmlApplicationContext(String configXml) {
        this.configXml = configXml;
        this.doImplement();
    }

    /**
     * 实现文档的解析
     * 通过反射实现IOC
     * 通过内省实现DI
     */
    private void doImplement() {
        SAXReader saxReader = new SAXReader();
        try {
            //通过dom4j解析文档
            Document doucment = saxReader.read(this.getClass().getClassLoader().getResourceAsStream(configXml));

            //获取beans下面的所有bean节点
            List<Node> beanNodes = doucment.selectNodes("beans/bean");

            if(beanNodes == null || beanNodes.size() <= 0) return;
            //遍历所有的bean节点，将id和class添加到map中
            for (Node bean : beanNodes) {
                //将节点转为元素
                Element element = (Element)bean;
                //获取元素的相关属性内容
                String beanId = element.attributeValue("id");
                String beanClass = element.attributeValue("class");
                //——————————————IOC的实现————————————————
                //通过反射将class所对应的对象，实例化出来，保存到map中  --------------> 这一步实现了IOC
                map.put(beanId, Class.forName(beanClass).newInstance());
            }

            //——————————————————DI的实现——————————————————
            //获取所有的属性标签
            List<Node> propertyNodes = doucment.selectNodes("beans/bean/property");

            if(propertyNodes != null && propertyNodes.size() > 0) {
                //遍历获取name属性和ref属性

                for (Node property : propertyNodes) {
                    //将节点转为元素
                    Element element = (Element) property;
                    //获取name属性和ref属性
                    String proName = element.attributeValue("name");
                    String proRef = element.attributeValue("ref");

                    //获取当前元素的直接父元素
                    Element parent = element.getParent();
                    //获取父元素所对应的id属性
                    String parentId = parent.attributeValue("id");

                    //—————————————————— 内省实现依赖注入 ———————————
                    //获取父元素的字节码对象
                    Class parentClass = map.get(parentId).getClass();
                    //通过内省类，获取父元素所指向的类的所有信息(内省对象)
                    //第二个参数为不需要内省的类，除去Object，为了防止遍历到Object类中的set方法中的参数
                    BeanInfo beanInfo = Introspector.getBeanInfo(parentClass,Object.class);
                    //通过内省对象，获取父元素所指向的类的所有属性描述
                    PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
                    //遍历属性元素
                    for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
                        //获取set方法所对应的属性名
                        String name = propertyDescriptor.getName();
                        System.out.println(name+"-------");
                        //如果 父元素所指向的类中的setter方法的名称 存在 与 配置中其子标签property中name属性相同的值就进行注入
                        //即：<property name="car"/> 中的 car 与 People类中的 public void setCar;中的car全小写相同时候
                        if(proName.equals(name)) {
                            //注入
                            //将ref对应的对象，注入给父级元素指向对象（内省对象）的set方法参数所对应的对象
                            //即：完成 new People().setCar(car) 的工作
                            propertyDescriptor.getWriteMethod().invoke(map.get(parentId), new Object[] {map.get(proRef)});
                        }
                    }

                }

            }

        } catch (Exception e) {

            e.printStackTrace();
        }

    }

    /**
     *
     * 获取保存在map中的实例对象，并返回
     * @param beanName
     * @return
     */
    public  Object getBean(String beanName) {
        return map.get(beanName);
    }

}

4.测试代码

package com.spring.test;

import org.junit.Test;

import com.spring.core.ClassPathXmlApplicationContext;
import com.spring.model.Car;
import com.spring.model.People;

public class TestDemo {

    @Test
    public void h() {
        ClassPathXmlApplicationContext bean = new ClassPathXmlApplicationContext("com/spring/config/spring-bean.xml");

        People people = (People) bean.getBean("people");

        Car car = people.getCar();
        car.setName("奔驰");
        car.show();
    }

}

5.运行结果

car-------
我是奔驰车

总结：高大上的spring就是利用反射和内省的机制完成对于一个类的管理，和相关类的注入的。控制反转主要使用的是反射机制，通过Class.fromName，获取类的字节码对象并实例化。依赖注入就是通过内省获取一个类并类中的set方法所set的一个对象，通过这个对象所对应的名称，获取在map中与之对应的实例化对象之后。通过内省的对象调用 真实的set方法，将已实例好的对象赋值给内省对象中所对应的成员变量