一、如何理解IoC

1.1 Spring IOC 概述

  控制反转 IoC(Inversion of Control)是一种设计思想，DI (依赖注入)是实现 IoC 的一种方法，也有人认为 DI 只是 IoC 的另一种说法。没有 IoC 的程序中我们使用面向对象编程对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试，如下图所示：

  要理解IoC，需要弄清楚 「到底什么被反转了？如何反转的」？IoC 是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器，控制权的转移就是所谓反转。对于 Spring 而言，就是由 Spring 来控制对象的生命周期和对象之间的依赖关系。所有的类都会在 spring 容器中登记，告诉 spring 这是个什么东西，你需要什么东西，然后 spring 会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring 来控制，也就是说控制对象生存周期的不再是引用它的对象，而是 spring。

  IoC 还有另外一个名字——“依赖注入（Dependency Injection）”。从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，即由容器动态地将某种依赖关系注入到组件之中。所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

1.2 IoC 是什么

  IoC 不是什么技术，而是一种设计思想，一个重要的面向对象编程的法则。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。我们来深入分析一下：

• 谁控制谁，控制什么：传统 Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象。而 IoC 是有专门一个容器来创建这些对象，即由 Ioc 容器来控制对象的创建。关于谁控制谁？当然是 IoC 容器控制了对象；至于控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。
• 为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象。那为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转。至于哪些方面反转了？依赖对象的获取被反转了。

在传统程序设计下，都是主动去创建相关对象然后再组合起来，我们需要用到那个类的对象，只需要 new 它就可以产生该类的对象了，然在在通过该对象调用它的属性和方法。如下图所示：

  类和类之间都是自行产生其他类的对象来进行使用，好处是使用简单，需要的时候 new 就行。但是缺点就有很多，用到哪些类都需要自身去创建，依赖度太高，不利于解耦，也有可能多个类都使用一个类的对象，但要产生多个对象，不能“共享”，冗余过多。当有了 IoC/DI 的容器后，在客户端类中不再主动去创建这些对象了，所有对象的产生都交给了容器来实现，当需要对象时，在通过容器获取它就行。如下图所示：

二、Ioc 配置的方式

  众所周知，Spring设计的两个大的要点：IOC和AOP。从框架的设计角度而言，更为重要的是简化开发，比如提供更为便捷的配置Bean的方式，直至0配置（即约定大于配置）。

2.1 xml 配置

  顾名思义，就是将bean的信息配置xml文件里，通过Spring加载文件为我们创建bean。这种方式出现很多早前的SSM项目中，将第三方类库或者一些配置工具类都以这种方式进行配置，主要原因是由于第三方类不支持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
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userService" class="org.dllwh.springframework.service.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

2.2 Java 配置

  将类的创建交给我们配置的JavcConfig类来完成，Spring只负责维护和管理，采用纯Java创建方式。其本质上，就是把在XML上的配置声明转移到Java配置类中。这种方式适用于任何场景，配置方便，因为是纯Java代码，扩展性高，十分灵活。但由于是采用Java类的方式，声明不明显，如果大量配置，可读性比较差。

  实现这种配置，需要创建一个配置类， 添加 @Configuration 注解声明为配置类。然后创建方法，在方法上加上 @bean，该方法用于创建实例并返回，该实例创建后会交给spring管理，方法名建议与实例名相同（首字母小写）。

@Configuration
public class BeansConfig {

    @Bean("userDao")
    public UserDaoImpl userDao() {
        return new UserDaoImpl();
    }

    @Bean("userService")
    public UserServiceImpl userService() {
        UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(userDao());
        return userService;
    }
}

2.3 注解配置

  通过在类上加注解的方式，来声明一个类交给 Spring 管理，Spring 会自动扫描带有 @Component、@Controller、@Service、@Repository 这四个注解的类，然后帮我们创建并管理，前提是需要先配置Spring的注解扫描器。使用这种方式开发便捷，通俗易懂，方便维护。当然其具有局限性，对于一些第三方资源，无法添加注解，只能采用XML或JavaConfig的方式配置。如下所示：

@Service
public class UserServiceImpl {
    @Autowired
    private UserDaoImpl userDao;

    public List<User> findUserList() {
        return userDao.findUserList();
    }
}

一些常用的注解，包括但不限于产生对象、引入依赖、设置配置等，如下表所示：

三、依赖注入的方式

常用的注入方式主要有三种：构造方法注入（Construct注入）、setter注入、基于注解的注入（接口注入）。

3.1 setter方式

  在XML配置方式中，property都是setter方式注入，比如下面的xml：

<?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
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userService" class="org.dllwh.springframework.service.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

  本质上包含两步：第一步，需要 new UserServiceImpl() 创建对象，所以需要默认构造函数；第二步，调用 setUserDao() 函数注入 userDao 的值，所以需要 setUserDao() 函数。所以对应的service类是这样的：

public class UserServiceImpl {
    private UserDaoImpl userDao;

    public UserServiceImpl() {
    }

    public List<User> findUserList() {
        return this.userDao.findUserList();
    }

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

  而在注解和Java配置方式下：

public class UserServiceImpl {
    private UserDaoImpl userDao;

    public List<User> findUserList() {
        return this.userDao.findUserList();
    }

    @Autowired
    public void setUserDao(UserDaoImpl userDao) {
        this.userDao = userDao;
    }
}

  在 Spring 3.x 刚推出的时候，推荐使用注入的就是这种, 但是这种方式比较麻烦，所以在 Spring4 .x 版本中推荐构造函数注入。

3.2 构造函数

在XML配置方式中，<constructor-arg> 是通过构造函数参数注入，比如下面的xml：

<?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
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userService" class="tech.pdai.springframework.service.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>
</beans>

  本质上是new UserServiceImpl(userDao)创建对象，所以对应的service类是这样的：

public class UserServiceImpl {
    private final UserDaoImpl userDao;

    public UserServiceImpl(UserDaoImpl userDaoImpl) {
        this.userDao = userDaoImpl;
    }

    public List<User> findUserList() {
        return this.userDao.findUserList();
    }
}

  在注解和Java配置方式下

@Service
public class UserServiceImpl {
    private final UserDaoImpl userDao;

    @Autowired
    public UserServiceImpl(final UserDaoImpl userDaoImpl) {
        this.userDao = userDaoImpl;
    }

    public List<User> findUserList() {
        return this.userDao.findUserList();
    }
}

3.3 注解注入

  以@Autowired（自动注入）注解注入为例，修饰符有三个属性：Constructor、byType、byName，默认按照byType注入。

比如：

@Service
public class UserServiceImpl {
    @Autowired
    private UserDaoImpl userDao;

    public List<User> findUserList() {
        return userDao.findUserList();
    }
}

小结

  其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

• https://www.pdai.tech/md/spring/spring-x-framework-ioc.html