Spring学习笔记——Spring依赖注入原理分析

我们知道Spring的依赖注入有四种方式，分别是get/set方法注入、构造器注入、静态工厂方法注入、实例工厂方法注入
下面我们先分析下这几种注入方式
1、get/set方法注入

public class SpringAction {
        //注入对象springDao
    private SpringDao springDao;
        //一定要写被注入对象的set方法
        public void setSpringDao(SpringDao springDao) {
        this.springDao = springDao;
    }
        public void ok(){
        springDao.ok();
    }
}

配置文件如下：

    <bean name="springAction" class="com.bless.springdemo.action.SpringAction">
        
        <property name="springDao" ref="springDao">property>
    bean>
<bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl">bean>

2、构造器注入

public class SpringAction {
    //注入对象springDao
    private SpringDao springDao;
    private User user;

    public SpringAction(SpringDao springDao,User user){
        this.springDao = springDao;
        this.user = user;
        System.out.println("构造方法调用springDao和user");
    }

        public void save(){
        springDao.save(user);
    }
}

在XML文件中同样不用的形式，而是使用标签，ref属性同样指向其它标签的name属性：

    <bean name="springAction" class="com.bless.springdemo.action.SpringAction">
        
        <constructor-arg ref="springDao">constructor-arg>
        <constructor-arg ref="user">constructor-arg>
    bean>
        <bean name="springDao" class="com.bless.springdemo.dao.impl.SpringDaoImpl">bean>
        <bean name="user" class="com.bless.springdemo.vo.User">bean>

在XML文件中同样不用的形式，而是使用标签，ref属性同样指向其它标签的name属性：
解决构造方法参数的不确定性，你可能会遇到构造方法传入的两参数都是同类型的，为了分清哪个该赋对应值，则需要进行一些小处理：

<bean name="springAction" class="com.bless.springdemo.action.SpringAction">  
        <constructor-arg index="0" ref="springDao">constructor-arg>  
        <constructor-arg index="1" ref="user">constructor-arg>  
bean>  

另一种是设置参数类型：

<constructor-arg type="java.lang.String" ref=""/>  

3、静态工厂方法注入
通过调用静态工厂方法来获取自己需要的对象，为了让Spring管理所有对象，我们不能直接通过类名加方法来获取对象，那样就脱离了Spring的管理，而是通过Spring注入的形式来获取

package com.bless.springdemo.factory;
import com.bless.springdemo.dao.FactoryDao;
import com.bless.springdemo.dao.impl.FactoryDaoImpl;
import com.bless.springdemo.dao.impl.StaticFacotryDaoImpl;
public class DaoFactory {
    //静态工厂
    public static final FactoryDao getStaticFactoryDaoImpl(){
        return new StaticFacotryDaoImpl();
    }
}

同样看关键类，这里我需要注入一个FactoryDao对象，这里看起来跟第一种注入一模一样，但是看随后的xml会发现有很大差别:

 public class SpringAction {
        //注入对象
    private FactoryDao staticFactoryDao;

    public void staticFactoryOk(){
        staticFactoryDao.saveFactory();
    }
    //注入对象的set方法
    public void setStaticFactoryDao(FactoryDao staticFactoryDao) {
        this.staticFactoryDao = staticFactoryDao;
    }
}

配置文件如下：

    <bean name="springAction" class="com.bless.springdemo.action.SpringAction" >
        
        <property name="staticFactoryDao" ref="staticFactoryDao">property>
                property>
    bean>
    
    <bean name="staticFactoryDao" class="com.bless.springdemo.factory.DaoFactory" factory-method="getStaticFactoryDaoImpl">bean>

4、实例工厂方法注入
实例工厂的意思是获取对象实例的方法不是静态的，所以你需要首先new工厂类，再调用普通的实例方法：

public class DaoFactory {
    //实例工厂
    public FactoryDao getFactoryDaoImpl(){
        return new FactoryDaoImpl();
    }
}

public class SpringAction {
    //注入对象
    private FactoryDao factoryDao;

    public void factoryOk(){
        factoryDao.saveFactory();
    }
    public void setFactoryDao(FactoryDao factoryDao) {
        this.factoryDao = factoryDao;
    }
}

    <bean name="springAction" class="com.bless.springdemo.action.SpringAction">
        
        <property name="factoryDao" ref="factoryDao">property>
    bean>

    
    <bean name="daoFactory" class="com.bless.springdemo.factory.DaoFactory">bean>
    <bean name="factoryDao" factory-bean="daoFactory" factory-method="getFactoryDaoImpl">bean>

对于第1、2种我们用的比较多，对后两种可能比较陌生。
下面我们来分析下Spring是如何完成依赖注入的。如果我们去看Spring的源码可能涉及的类和接口相当多，不易掌握，在此我用自己的代码和方式来帮助我们Spring依赖注入的过程。
当我们启动Spring容器的时候他会执行以下几个过程：
1、加载Xml配置文件(readXML(String filename))在Spring这个由ApplicationContext类完成
这一步会解析Xml属性，把bean的属性存放到BeanDefinition类中
代码如下：

/**
     * 读取xml配置文件
     * @param filename
     */
    private void readXML(String filename) {
           SAXReader saxReader = new SAXReader();   
            Document document=null;   
            try{
             URL xmlpath = this.getClass().getClassLoader().getResource(filename);
             document = saxReader.read(xmlpath);
             Map nsMap = new HashMap();
             nsMap.put("ns","http://www.springframework.org/schema/beans");//加入命名空间
             XPath xsub = document.createXPath("//ns:beans/ns:bean");//创建beans/bean查询路径
             xsub.setNamespaceURIs(nsMap);//设置命名空间
             List beans = xsub.selectNodes(document);//获取文档下所有bean节点 
             for(Element element: beans){
                String id = element.attributeValue("id");//获取id属性值
                String clazz = element.attributeValue("class"); //获取class属性值        
                BeanDefinition beanDefine = new BeanDefinition(id, clazz);
                XPath propertysub =  element.createXPath("ns:property");
                propertysub.setNamespaceURIs(nsMap);//设置命名空间
                List propertys = propertysub.selectNodes(element);
                for(Element property : propertys){                  
                    String propertyName = property.attributeValue("name");
                    String propertyref = property.attributeValue("ref");
                    PropertyDefinition propertyDefinition = new PropertyDefinition(propertyName, propertyref);
                    beanDefine.getPropertys().add(propertyDefinition);
                }
                beanDefines.add(beanDefine);
             } 
            }catch(Exception e){   
                e.printStackTrace();
            }
    }

2、Bean的实例化
在配置文件以bean的id为key，BeanDefinition为value放到Map中

/**
     * 完成bean的实例化
     */
    private void instanceBeans() {
        for(BeanDefinition beanDefinition : beanDefines){
            try {
                if(beanDefinition.getClassName()!=null && !"".equals(beanDefinition.getClassName().trim()))
                    sigletons.put(beanDefinition.getId(), Class.forName(beanDefinition.getClassName()).newInstance());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }

3、为Bean的输入注入值，完成依赖注入

/**
     * 为bean对象的属性注入值
     */
    private void injectObject() {
        for(BeanDefinition beanDefinition : beanDefines){
            Object bean = sigletons.get(beanDefinition.getId());
            if(bean!=null){
                try {
                    PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
                    for(PropertyDefinition propertyDefinition : beanDefinition.getPropertys()){
                        for(PropertyDescriptor properdesc : ps){
                            if(propertyDefinition.getName().equals(properdesc.getName())){
                                Method setter = properdesc.getWriteMethod();//获取属性的setter方法 ,private
                                if(setter!=null){
                                    Object value = sigletons.get(propertyDefinition.getRef());
                                    setter.setAccessible(true);
                                    setter.invoke(bean, value);//把引用对象注入到属性
                                }
                                break;
                            }
                        }
                    }
                } catch (Exception e) {
                }
            }
        }
    }

其实Spring依赖注入的过程就是这么简单，再就是各种细节了，比如懒加载、单例等的额外处理了。