什么是控制反转

在一般情况下，如果Class A 使用到了Class B的对象，那么就要在Class A中new出来一个Class B的对象。

class B{
    public void run(){
        System.out.println("----我是B----");
    }
}
class A{
    public void run(){
        B b = new B();，
        b.run();
    }
}

对象A依赖于对象B，那么对象A在初始化或者运行到某一点的时候，自己必须主动去创建对象B或者使用已经创建的对象B。无论是创建还是使用对象B，控制权都在自己手上。

倘若粗心忘记了创建B的对象。。

这个时候就需要依赖注入框架来解决管理对象的问题，
采用依赖注入技术之后，A的代码只需要定义一个私有的B对象，不需要直接new来获得这个对象，而是通过相关的容器控制程序来将B对象在外部new出来并注入到A类里的引用中。
好莱坞有一条著名的原则：“不要给我们打电话，我们会给你打电话(don‘t call us, we‘ll call you)”。
就是所有的演员（对象）交由给演艺公司（spring）控制，导演需要的时候就从演艺公司把演员拿过来，不需要就把演员丢了。

class BeanFactory{
    public static Object create(String beanName){
        switch(beanName){
            case "B":
                return new B();
        }
    }
}

class B{
    public void run(){
        System.out.println("----我是B----");
    }
}
class A{
    private B b = BeanFactory.create("B");，
    public void run(){
        b.run();
    }
}

什么是依赖注入

依赖注入是实现控制反转的一种方式。

class B{
    public void run(){
        System.out.println("----我是B----");
    }
}
class A{
    A() {
        b = new B();
    }
    public void run(){
        b.run();
    }
}

还是这段代码，如果现在要改变B的生成方式会变得十分的麻烦，因为要去修改A的构造函数。如果B是一个接口的话，更加难以操作，因为B的实现类可能有多种。
但是改成下面这样就能很容易实现创建B的操作。
像这种非自己主动初始化依赖，而通过外部来传入依赖的方式，我们就称为依赖注入。

class B{
    public void run(){
        System.out.println("----我是B----");
    }
}
class A{
    private B b;
    A(B b) {
        this.b = b;
    }
    public void run(){
        b.run();
    }
}

Spring中的依赖注入

class B{
    public void run(){
        System.out.println("----我是B----");
    }
}
class A{
    private B b;
    public void setFinder(B b) {
        this.b = b;
    }
    public void run(){
        b.run();
    }
}

<beans>
    <bean id="A" class="A">
        <property name="b">
            <ref local="B"/>
        </property>
    </bean>
    <bean id="B" class="B">
    </bean>
</beans>

这样通过xml文件就能够将B的实例注入到A中

总结

控制反转是一种在软件工程中解耦合的思想，调用类只依赖接口，而不依赖具体的实现类，减少了耦合。控制权交给了容器，在运行的时候才由容器决定将具体的实现动态的“注入”到调用类的对象中。
依赖注入是一种设计模式，可以作为控制反转的一种实现方式。依赖注入就是将实例变量传入到一个对象中去(Dependency injection means giving an object its instance variables)。
通过IoC框架，类A依赖类B的强耦合关系可以在运行时通过容器建立，也就是说把创建B实例的工作移交给容器，类A只管使用就可以。