在看此片文章之前，请先看下面一片，是最基础的依赖注入和控制反转的spring简单实现。简单到看完就可以基本理解。
http://blog.csdn.net/qq_27093465/article/details/52547290
下面的这篇文章，和上边的那个文章，可能会有稍微重复。但也是为了理解这个术语。

　　依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。
具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，
在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，
因此，称为控制反转;创建被调用者实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。

spring的控制反转：把对象的创建、初始化、销毁等工作交给spring容器来做。由spring容器 控制对象的生命周期。

　　 不管是依赖注入，还是控制反转，都说明Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现互
相透明。在理解依赖注入之前，看如下这个问题在各种社会形态里如何解决:一个人(Java实例，调用者)需要一把斧子(Java实
例，被调用者)。

　　 (1)原始社会里，几乎没有社会分工。需要斧子的人(调用者)只能自己去磨一把斧子(被调用者)。对应的情形为:Java程序
里的调用者自己创建被调用者。

　　 (2)进入工业社会，工厂出现。斧子不再由普通人完成，而在工厂里被生产出来，此时需要斧子的人(调用者)找到工厂，购
买斧子，无须关心斧子的制造过程。对应Java程序的简单工厂的设计模式。

　　 (3)进入“按需分配”社会，需要斧子的人不需要找到工厂，坐在家里发出一个简单指令:需要斧子。斧子就自然出现在他面前。
对应Spring的依赖注入。

　　 第一种情况下，Java实例的调用者创建被调用的Java实例，必然要求被调用的Java类出现在调用者的代码里。无法实现二者
之间的松耦合。

　 第二种情况下，调用者无须关心被调用者具体实现过程，只需要找到符合某种标准(接口)的实例，即可使用。此时调用的代
码面向接口编程，可以让调用者和被调用者解耦，这也是工厂模式大量使用的原因。但调用者需要自己定位工厂，调用者与特定工
厂耦合在一起。

　 第三种情况下，调用者无须自己定位工厂，程序运行到需要被调用者时，系统自动提供被调用者实例。事实上，调用者和被调
用者都处于Spring的管理下，二者之间的依赖关系由Spring提供。

　 所谓依赖注入，是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部的注入。
Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。依赖注入通常有两种:

(哎，POJO知道是啥吗？不知道的话，看链接，如下：POJO是什么，怎么理解，大师兄查了，看看吧。点我。)

1，两个接口的声明。

person接口

/**
 * 定义Person接口
 * <p>
 * Created by lxk on 2017/3/22
 */
interface Person {
    void useAxe();  //Person接口里定义一个使用斧子的方法
}

/**
 * 定义Axe(斧子英文Axe)接口
 * <p>
 * Created by lxk on 2017/3/22
 */
interface Axe {
    String chop(); //Axe接口里有个砍(chop)的方法,返回String类型
}

第一类斧子

import org.springframework.stereotype.Component;

/**
 * Axe的第二个实现类 SteelAxe 钢斧
 * 这个@Component 等价于 <bean id="steelAxe" class="..SteelAxe">
 * Created by lxk on 2017/3/22
 */
@Component
class SteelAxe implements Axe{

    /** 实现Axe接口的chop方法 */
    @Override
    public String chop() {
        return "钢斧砍柴真快";
    }
}

import org.springframework.stereotype.Component;

/**
 * Axe的第一个实现类 StoneAxe 石斧
 * 这个@Component("stoneAxe") 等价于 <bean id="stoneAxe" class="..StoneAxe">
 * Created by lxk on 2017/3/22
 */
@Component("stoneAxe")
class StoneAxe implements Axe {

    /** 实现Axe接口的chop方法 */
    @Override
    public String chop() { return "石斧砍柴好慢"; }
}

import javax.annotation.Resource;

/**
 * Person的实现类（Chinese实现Person接口）
 *
 * Created by lxk on 2017/3/22
 */
@Component("chinese")
class Chinese implements Person {
    /** 面向Axe(斧子)接口编程，而不是具体的实现类 */
    @Resource(name = "stoneAxe")
    private Axe axe;

    /** 实现Person接口的useAxe方法 */
    public void useAxe() { System.out.println(axe.chop()); }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 依赖注入，使用注解实现
 * <p>
 * Created by lxk on 2017/3/22
 */
public class Main {
    public static void main(String[] args) {
        //因为是独立的应用程序，显式地实例化Spring的上下文。下面是启动spring容器代码：寻找配置文件实例化容器
        ApplicationContext context = new ClassPathXmlApplicationContext("com/lxk/spring/ioc/applicationContext.xml");
        //通过Person bean的id来获取bean实例，面向接口编程，因此
        //此处强制类型转换为接口类型
        Person p = (Person) context.getBean("chinese");
        //直接执行Person的userAxe()方法。
        p.useAxe();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-2.5.xsd">

    <context:component-scan base-package="com.lxk.spring.ioc"/>
</beans>

6，文件结构如下：

7，说明：

首先你要知道，在spring容器启动之后，会根据你的配置文件里面
<context:component-scan base-package="com.lxk.spring.ioc"/>
类扫描的注解解析器
这句话，去这个路径下面扫描所有类，其中带有注解的，他就会在spring容器中自动实例化一个对象
具体参考另外一篇文章：
http://blog.csdn.net/qq_27093465/article/details/52710925（spring类扫描注入-----类扫描的注解解析器）
可以看到在Chinese类里面可以直接使用石斧的chop方法。
你 不需要自己new一个对象，而是直接使用，声明一下，就可以使用了，你在spring项目里面会看到 大量的类似这个的用法。
不同的可能就是注解的名称不一样，主要有@Controller，@Service("xxxx"),@Resource(name = "xxx"),@Repository("xxx"),
等等，很多的类似的注解，都是这么个道理。都是将这些个类，托管给spring容器，哪里要使用，只要声明一下，就可以直接使用。

看了这个文章，你起码知道你整体做的spring项目里面他究竟是到底怎么在依赖注入和控制反转，而不是说，他不就是怎么怎么的。
还是说不明白。这里没有将依赖注入的构造注入和设值注入，在文章开头位置的那个链接里面详细讲解了。而且使用的是简单的xml配置
也给出了，如何复现我的这个测试环境的链接。

最后，觉得写的好的，对你有帮助的，不嫌弃麻烦的，点个赞，觉得不好的，提出来我改之，懒得提也可以，但是，麻烦，放下脚，不要踩我文章。