IOC（控制反转）-526互联

1、通过下面这个案例来理解IOC这种思想

创建一个项目，建一个dao层的包。在包下建立一个UserDao接口，里面写一个方法。再写这个接口的几个实现类，每个实现类中的方法实现不同的效果。

建一个service层的包，下面写一个UserService接口，然后写接口实现类，实现类就是调用Dao层的方法（用以下两种方法来写就可以体会出IOC思想了）

public class UserServiceImpl implements UserService{
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void getUser() {
        userDao.getUser();
    }

}

public class UserServiceImpl implements UserService{
    private UserDao userDao=new UserDaoImpl();
    public void getUser() {
        userDao.getUser();
    }

}

Service层中第一种写法和第二种写法对比来看就能理解IOC的思想了。假如我们的Controller层调用Service这个接口时需要实现不同的方法，第二种方法就需要去修改Service层的代码，去new成Dao层的不同实现类，万一实现类有很多，Controller层又需要不同的方法，这样就很麻烦啊。第一种通过set方法可以在Controller层将需要的Dao层实现类new出来注入，可以动态的实现，将原本的由Service层代码控制Dao层不同实现类来实现各种功能换成了通过Controller层用set方法注入不同Dao层实现类来实现，这就是控制反转的思想。

这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低，可以更加专注的在业务的实现上!这是IOC的原型!
2、IOC本质

控制反转IOC(Inversion of Control),是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IOC的另一种说法。没有IOC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是:获得依赖对象的方式反转了。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体,Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。控制反转是一种通过描述(XML或注解)并通过第3三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入(Dependency Injection,DI)。

3、HelloSpring

创建一个Hello类

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

在resources目录下创建一个spring的配置文件beans.xml，将Hello类实例化成对象放到Spring容器中。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--在spring中创建对象，在spring中这些称为bean-->
    <bean id="hello" class="com.along.pojo.Hello">
        <property name="str" value="spring"/>
    </bean>
</beans>

测试

public class MyTest {
    public static void main(String[] args) {
　　　　 //获取spring上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
　　　　 //现在我们的对象都在spring中管理了，我们要使用，直接去里面取出来就可以了。
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);
    }
}

控制:谁来控制对象的创建,传统应用程序的对象是由程序本身控制创建的,使用Spring后,对象是由Spring来创建的。
反转:程序本身不创建对象,而变成被动的接收对象。
依赖注入:就是利用set方法来进行注入的。
IOC是一种编程思想,由主动的编程变成被动的接收。
可以通过newClassPathXmlApplicationContext去浏览一下底层源码。
OK,到了现在,我们彻底不用再程序中去改动了,要实现不同的操作,只需要在xml配置文件中进行修改,所谓的IoC,-句话搞定:对象由Spring来创建,管理,装配!

4、IOC创建对象的方式

Spring中的对象如何创建的

1）下标赋值

<bean id="user" class="com.along.pojo.User">
　  <constructor-arg index="0" value="along"/>
</bean>

2）类型（不推荐）

<bean id="user" class="com.along.pojo.User">
    <constructor-arg type="java.lang.String" value="along"/>
</bean>

3）参数名

<bean id="user" class="com.along.pojo.User">
    <constructor-arg name="name" value="along"/>
</bean>

总结：在配置文件加载好后，容器中管理的对象就已经实例化了。