Spring系列之谈谈对Spring IOC的理解

时间 2019-12-18

标签 spring 系列谈谈 ioc 理解栏目 Spring 繁體版

原文原文链接

学习过Spring框架的人必定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念，对于初学Spring的人来讲，总以为IOC 、DI这两个概念是模糊不清的，是很难理解的，今天和你们分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解。java

1、分享Iteye的开涛对Ioc的精彩讲解
首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解，写得很是通俗易懂，如下内容所有来自原文spring

1.一、IoC是什么数据库

　　Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为什么是反转（有反转就应该有正转了），哪些方面反转了”，那咱们来深刻分析一下：编程

　　●谁控制谁，控制什么：传统Java SE程序设计，咱们直接在对象内部经过new进行建立对象，是程序主动去建立依赖对象；而IoC是有专门一个容器来建立这些对象，即由Ioc容器来控制对象的建立；谁控制谁？固然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不仅是对象包括好比文件等）。框架

　　●为什么是反转，哪些方面反转了：有反转就有正转，传统应用程序是由咱们本身在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙建立及注入依赖对象；为什么是反转？由于由容器帮咱们查找及注入依赖对象，对象只是被动的接受依赖对象，因此是反转；哪些方面反转了？依赖对象的获取被反转了。学习

　用图例说明一下，传统程序设计如图1-1，都是主动去建立相关对象而后再组合起来：测试

图1-1 传统应用程序示意图spa

当有了IoC/DI的容器后，在客户端类中再也不主动去建立这些对象了，如图2-2所示:设计

图1-2有IoC/DI容器后程序结构示意图code

1.二、IoC能作什么

IoC 不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导咱们如何设计出松耦合、更优良的程序。传统应用程序都是由咱们在类内部主动建立依赖对象，从而致使类与类之间高耦合，难于测试；有了IoC容器后，把建立和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，因此对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得很是灵活。

　　其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序本来是老大，要获取什么资源都是主动出击，可是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来建立并注入它所须要的资源了。

　　IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找咱们，咱们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

1.三、IoC和DI

DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并不是为软件系统带来更多功能，而是为了提高组件重用的频率，并为系统搭建一个灵活、可扩展的平台。经过依赖注入机制，咱们只须要经过简单的配置，而无需任何代码就可指定目标须要的资源，完成自身的业务逻辑，而不须要关心具体的资源来自何处，由谁实现。

　　理解DI的关键是：“谁依赖谁，为何须要依赖，谁注入谁，注入了什么”，那咱们来深刻分析一下：

　　●谁依赖于谁：固然是应用程序依赖于IoC容器；

　　●为何须要依赖：应用程序须要IoC容器来提供对象须要的外部资源；

　　●谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；

　　●注入了什么：就是注入某个对象所须要的外部资源（包括对象、资源、常量数据）。

　　IoC和DI由什么关系呢？其实它们是同一个概念的不一样角度描述，因为控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系），因此2004年大师级人物Martin Fowler又给出了一个新的名字：“依赖注入”，相对IoC 而言，“依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。

　　看过不少对Spring的Ioc理解的文章，好多人对Ioc和DI的解释都晦涩难懂，反正就是一种说不清，道不明的感受，读完以后依然是一头雾水，感受就是开涛这位技术牛人写得特别通俗易懂，他清楚地解释了IoC(控制反转) 和DI(依赖注入)中的每个字，读完以后给人一种豁然开朗的感受。我相信对于初学Spring框架的人对Ioc的理解应该是有很大帮助的。

2、分享Bromon的blog上对IoC与DI浅显易懂的讲解

2.一、IoC(控制反转)
　首先想说说IoC（Inversion of Control，控制反转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来讲，就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢，举个简单的例子，咱们是如何找女友的？常见的状况是，咱们处处去看哪里有长得漂亮身材又好的mm，而后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想办法认识她们，投其所好送其所要，而后嘿嘿……这个过程是复杂深奥的，咱们必须本身设计和面对每一个环节。传统的程序开发也是如此，在一个对象中，若是要使用另外的对象，就必须获得它（本身new一个，或者从JNDI中查询一个），使用完以后还要将对象销毁（好比Connection等），对象始终会和其余的接口或类藕合起来。

　　那么IoC是如何作的呢？有点像经过婚介找女友，在我和女友之间引入了一个第三者：婚姻介绍所。婚介管理了不少男男女女的资料，我能够向婚介提出一个列表，告诉它我想找个什么样的女友，好比长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，而后婚介就会按照咱们的要求，提供一个mm，咱们只须要去和她谈恋爱、结婚就好了。简单明了，若是婚介给咱们的人选不符合要求，咱们就会抛出异常。整个过程再也不由我本身控制，而是有婚介这样一个相似容器的机构来控制。Spring所倡导的开发方式就是如此，全部的类都会在spring容器中登记，告诉spring你是个什么东西，你须要什么东西，而后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其余须要你的东西。全部的类的建立、销毁都由 spring来控制，也就是说控制对象生存周期的再也不是引用它的对象，而是spring。对于某个具体的对象而言，之前是它控制其余对象，如今是全部对象都被spring控制，因此这叫控制反转。

2.二、DI(依赖注入)

　IoC的一个重点是在系统运行中，动态的向某个对象提供它所须要的其余对象。这一点是经过DI（Dependency Injection，依赖注入）来实现的。好比对象A须要操做数据库，之前咱们老是要在A中本身编写代码来得到一个Connection对象，有了 spring咱们就只须要告诉spring，A中须要一个Connection，至于这个Connection怎么构造，什么时候构造，A不须要知道。在系统运行时，spring会在适当的时候制造一个Connection，而后像打针同样，注射到A当中，这样就完成了对各个对象之间关系的控制。A须要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3以后一个重要特征是反射（reflection），它容许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是经过反射来实现注入的。

　　理解了IoC和DI的概念后，一切都将变得简单明了，剩下的工做只是在spring的框架中堆积木而已。

3、我对IoC(控制反转)和DI(依赖注入)的理解

在平时的java应用开发中，咱们要实现某一个功能或者说是完成某个业务逻辑时至少须要两个或以上的对象来协做完成，在没有使用Spring的时候，每一个对象在须要使用他的合做对象时，本身均要使用像new object() 这样的语法来将合做对象建立出来，这个合做对象是由本身主动建立出来的，建立合做对象的主动权在本身手上，本身须要哪一个合做对象，就主动去建立，建立合做对象的主动权和建立时机是由本身把控的，而这样就会使得对象间的耦合度高了，A对象须要使用合做对象B来共同完成一件事，A要使用B，那么A就对B产生了依赖，也就是A和B之间存在一种耦合关系，而且是紧密耦合在一块儿，而使用了Spring以后就不同了，建立合做对象B的工做是由Spring来作的，Spring建立好B对象，而后存储到一个容器里面，当A对象须要使用B对象时，Spring就从存放对象的那个容器里面取出A要使用的那个B对象，而后交给A对象使用，至于Spring是如何建立那个对象，以及何时建立好对象的，A对象不须要关心这些细节问题(你是何时生的，怎么生出来的我可不关心，能帮我干活就行)，A获得Spring给咱们的对象以后，两我的一块儿协做完成要完成的工做便可。

　　因此控制反转IoC(Inversion of Control)是说建立对象的控制权进行转移，之前建立对象的主动权和建立时机是由本身把控的，而如今这种权力转移到第三方，好比转移交给了IoC容器，它就是一个专门用来建立对象的工厂，你要什么对象，它就给你什么对象，有了 IoC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IoC容器了，经过IoC容器来创建它们之间的关系。

　　这是我对Spring的IoC(控制反转)的理解。DI(依赖注入)其实就是IOC的另一种说法，DI是由Martin Fowler 在2004年初的一篇论文中首次提出的。他总结：控制的什么被反转了？就是：得到依赖对象的方式反转了。

4、IOC的实现原理

IOC的重点是在系统运行过程当中，动态的向某个对象提供它所须要的其它对象。这个提供的方法是经过DI（依赖注入）来实现的。好比，A类须要一个B类对象来完成某个动做，之前是A类本身new一个B，有了Spring以后，只须要告诉spring，A中须要一个B，至于B怎么构造，什么时候构造，A彻底不须要care，只须要在它须要的时候张嘴要就好了。在系统运行时，spring会在适当时候制造一个B，而后像打针同样，注射到A中，从而完成了对象之间的关联控制。A须要依赖B才能够正常运行，而B对象是由spring注入到A中去的。依赖注入就是这么来的。

DI的实现

DI是经过反射来实现的，反射容许程序经过某个类的名字或者对象来获得类自己。spring就是经过反射来完成注入的。

接下来手动写一个屌丝版的Spring IOC容器。
首先，咱们定义一个Bean类，这个类用来存放一个Bean拥有的属性。

    /* Bean Id */
    private String id;
    /* Bean Class */
    private String type;
    /* Bean Property */
    private Map<String, Object> properties = new HashMap<String, Object>();

一个Bean包括id,type（类全域名）,和Properties（属性域）。

接下来Spring 就开始加载咱们的配置文件了，将咱们配置的信息保存在一个HashMap中，HashMap的key就是Bean 的 Id ，HasMap 的value是这个Bean，只有这样咱们才能经过context.getBean("animal")这个方法得到Animal这个类。咱们都知道Spirng能够注入基本类型，并且能够注入像List，Map这样的类型，接下来就让咱们以Map为例看看Spring是怎么保存的吧。

Map配置能够像下面的。

<bean id="test" class="Test">
        <property name="testMap">
            <map>
                <entry key="a">
                    <value>1</value>
                </entry>
                <entry key="b">
                    <value>2</value>
                </entry>
            </map>
        </property>
    </bean>

Spring是怎样保存上面的配置呢？代码以下：

if (beanProperty.element("map") != null) {
                    Map<String, Object> propertiesMap = new HashMap<String, Object>();
                    Element propertiesListMap = (Element) beanProperty
                            .elements().get(0);
                    Iterator<?> propertiesIterator = propertiesListMap
                            .elements().iterator();
                    while (propertiesIterator.hasNext()) {
                        Element vet = (Element) propertiesIterator.next();
                        if (vet.getName().equals("entry")) {
                            String key = vet.attributeValue("key");
                            Iterator<?> valuesIterator = vet.elements()
                                    .iterator();
                            while (valuesIterator.hasNext()) {
                                Element value = (Element) valuesIterator.next();
                                if (value.getName().equals("value")) {
                                    propertiesMap.put(key, value.getText());
                                }
                                if (value.getName().equals("ref")) {
                                    propertiesMap.put(key, new String[] { value
                                            .attributeValue("bean") });
                                }
                            }
                        }
                    }
                    bean.getProperties().put(name, propertiesMap);
                }

接下来就进入最核心部分了，让咱们看看Spring 究竟是怎么依赖注入的吧，其实依赖注入的思想也很简单，它是经过反射机制实现的，在实例化一个类时，它经过反射调用类中set方法将事先保存在HashMap中的类属性注入到类中。让咱们看看具体它是怎么作的吧。
首先实例化一个类，像这样

public static Object newInstance(String className) {
        Class<?> cls = null;
        Object obj = null;
        try {
            cls = Class.forName(className);
            obj = cls.newInstance();
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
        return obj;
    }

接着它将这个类的依赖注入进去，像这样

public static void setProperty(Object obj, String name, String value) {
        Class<? extends Object> clazz = obj.getClass();
        try {
            String methodName = returnSetMthodName(name);
            Method[] ms = clazz.getMethods();
            for (Method m : ms) {
                if (m.getName().equals(methodName)) {
                    if (m.getParameterTypes().length == 1) {
                        Class<?> clazzParameterType = m.getParameterTypes()[0];
                        setFieldValue(clazzParameterType.getName(), value, m,
                                obj);
                        break;
                    }
                }
            }
        } catch (SecurityException e) {
            throw new RuntimeException(e);
        } catch (IllegalArgumentException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }
}

最后它将这个类的实例返回给咱们，咱们就能够用了。咱们仍是以Map为例看看它是怎么作的，我写的代码里面是建立一个HashMap并把该HashMap注入到须要注入的类中，像这样

if (value instanceof Map) {
                Iterator<?> entryIterator = ((Map<?, ?>) value).entrySet()
                        .iterator();
                Map<String, Object> map = new HashMap<String, Object>();
                while (entryIterator.hasNext()) {
                    Entry<?, ?> entryMap = (Entry<?, ?>) entryIterator.next();
                    if (entryMap.getValue() instanceof String[]) {
                        map.put((String) entryMap.getKey(),
                                getBean(((String[]) entryMap.getValue())[0]));
                    }
                }
                BeanProcesser.setProperty(obj, property, map);
            }

这样咱们就能够用Spring 给咱们建立的类了（虽然细节没太弄明白，里面一些方法都不知道具体实现是什么）固然Spring能作到的远不止这些，这个示例程序仅仅提供了Spring最核心的依赖注入功能中的一部分。