Spring IOC 原理

概念

Spring 启动时读取应用程序提供的 Bean 配置信息，并在 Spring 容器中生成一份相应的 Bean 配置注册表，然后根据这张注册表实例化 Bean，装配好 Bean 之间的依赖关系，为上层应用提供准备就绪的运行环境。其中 Bean 缓存池为 HashMap 实现。

IOC容器的实现参考上篇

IOC和依赖注入

Spring IoC容器负责对象的生命周期和对象之间的（依赖）关系。

在创建新的Bean时，IoC容器会自动注入新Bean的所依赖的其他Bean，而无须自己手动创建。

IoC容器自动完成对象的初始化，避免在开发过程中写一大段初始化代码。
创建实例的时候不需要了解细节。

优点：不会对业务代码构成很强的侵入性，对象具有更好的可测试性，可重用性和可拓展性。

IoC 全称为 InversionofControl，翻译为 “控制反转”.

谁控制谁：在传统的开发模式下，我们都是采用直接 new 一个对象的方式来创建对象，也就是说你依赖的对象直接由你自己控制，但是有了 IOC 容器后，则直接由 IoC 容器来控制。所以“谁控制谁”，当然是 IoC 容器控制对象。
控制什么：控制对象。
为何是反转：没有 IoC 的时候我们都是在自己对象中主动去创建被依赖的对象，这是正转。但是有了 IoC 后，所依赖的对象直接由 IoC 容器创建后注入到被注入的对象中，依赖的对象由原来的主动获取变成被动接受，所以是反转。
哪些方面反转了：所依赖对象的获取被反转了。

“依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。
理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

谁依赖谁：“被注入的对象”依赖“依赖对象”。举个例子，对象A依赖B，那么IoC容器在注入A对象之前，需要先注入B对象；对象A依赖IoC容器；对象B被注入到对象A中，所以A是被注入的对象，B是依赖对象，A依赖B。
为什么需要依赖：容器管理对象需要IoC容器来提供对象需要的外部资源；
谁注入谁：很明显是IoC容器注入某个对象，也就是注入“依赖对象”；
注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

二者的关系
控制反转（Inversion of Control）就是依赖倒置原则的一种代码设计的思路。具体采用的方法就是所谓的依赖注入（Dependency Injection）。

Bean 作用域

Spring 中为 Bean 定义了 5 中作用域，分别为 singleton（单例）、 prototype（原型）、request、 session 和 global session， 5 种作用域说明如下：

singleton：单例模式（多线程下不安全）
Spring IOC 容器中只会存在一个共享的Bean实例，无论有多少个Bean引用它，始终指向同一对象。该模式在多线程下是不安全的。singleton作用域是Spring中的缺省作用域，也可以显示的将Bean定义为singleton模式，配置为：

<bean id="userDao" class="com.ioc.UserDaoImpl" scope="singleton"/>

prototype:原型模式，每次使用时创建
每次通过Spring容器获取prototype定义的Bean时，容器都将创建一个新的Bean实例，每个Bean实例都有自己的属性和状态。根据经验， 对有状态的bean使用prototype作用域，而对无状态的bean使用singleton作用域。
request：一次 request 一个实例
在一次Http请求中，容器会返回该Bean的同一实例。而对不同的Http请求则会产生新的Bean，而且该Bean仅在当前Http Request内有效,当前Http请求结束，该bean
实例也将会被销毁。
```
<bean id="loginAction" class="com.cnblogs.Login" scope="request"/>
```
session
在一次Http Session中，容器会返回该Bean的同一实例。而对不同的Session请求则会创建新的实例，该Bean实例仅在当前Session内有效。同Http请求相同，每一次
session请求创建新的实例，而不同的实例之间不共享属性，且实例仅在自己的session请求内有效，请求结束，则实例将被销毁。
```
<bean id="userPreference" class="com.ioc.UserPreference" scope="session"/>
```
global Session
在一个全局的Http Session中，容器会返回该Bean的同一个实例，仅在
使用portlet context时有效。

Bean 生命周期

Bean 的生命周期概括起来就是 4 个阶段：

实例化（Instantiation）；
属性赋值（Populate）；
初始化（Initialization）；
销毁（Destruction）。

实例化：实例化一个 Bean，也就是我们常说的 new。
IOC 依赖注入：按照 Spring 上下文对实例化的 Bean 进行配置，也就是 IOC 注入。
setBeanName实现：如果这个Bean已经实现了BeanNameAware接口，会调用它实现的setBeanName(String)方法，此处传递的就是Spring配置文件中Bean的id值
BeanFactoryAware实现：如果这个Bean已经实现了BeanFactoryAware接口，会调用它实现的setBeanFactory，setBeanFactory(BeanFactory)传递的是Spring工厂自身（可以用这个方式来获取其它Bean，只需在Spring配置文件中配置一个普通Bean就可以）。
ApplicationContextAware实现：如果这个Bean已经实现ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文（同样这个方式也可以实现步骤 4 的内容，但比 4 更好，因为 ApplicationContext是 BeanFactory 的子接口，有更多的实现方法）
postProcessBeforeInitialization 接口实现-初始化预处理：如果这个Bean关联了BeanPostProcessor 接口，将会调用postProcessBeforeInitialization(Object obj, String s)方法， BeanPostProcessor经常被用作是Bean内容的更改，并且由于这个是在Bean初始化结束时调用那个的方法，也可以被应用于内存或缓存技术。
init-method：如果Bean在 Spring 配置文件中配置了init-method属性会自动调用其配置的初始化方法。
postProcessAfterInitialization：如果这个Bean关联了 BeanPostProcessor 接口，将会调用postProcessAfterInitialization(Object obj, String s)方法。
注：以上工作完成以后就可以应用这个Bean了，那这个Bean是一个Singleton的
Destroy 过期自动清理阶段：当Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean这个接口，会调用其实现的destroy()方法；
destroy-method 自配置清理：最后，如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。

bean标签有两个重要的属性（init-method 和 destroy-method）。用它们可以自己定制初始化和注销方法。也有相应的注解（@PostConstruct 和@PreDestroy）
<bean id="" class="" init-method="初始化方法" destroy-method="销毁方法">

依赖注入方式

对于spring配置一个bean时，如果需要给该bean提供一些初始化参数，则需要通过依赖注入方式，所谓的依赖注入就是通过spring将bean所需要的一些参数传递到bean实例对象的过程（将依赖关系注入到对象中）

在创建新的Bean时，IoC容器会自动注入新Bean的所依赖的其他Bean，而无须自己手动创建。

构造器注入

private DependencyA dependencyA;
private DependencyB dependencyB;
private DependencyC dependencyC;

public DI(DependencyA dependencyA, DependencyB dependencyB, DependencyC dependencyC) {

   this.dependencyA = dependencyA;
   this.dependencyB = dependencyB;
   this.dependencyC = dependencyC;

}


2. setter 方法注入

private DependencyA dependencyA;
private DependencyB dependencyB;
private DependencyC dependencyC;

@Autowired
public void setDependencyA(DependencyA dependencyA) {

   this.dependencyA = dependencyA;

}

@Autowired
public void setDependencyB(DependencyB dependencyB) {

   this.dependencyB = dependencyB;

}

@Autowired
public void setDependencyC(DependencyC dependencyC) {

   this.dependencyC = dependencyC;

}


3. 字段注入

@Autowired
private DependencyA dependencyA;

@Autowired
private DependencyB dependencyB;

@Autowired
private DependencyC dependencyC;


| 注入方式        | **优点**                                             | **缺点**                                                     |
| --------------- | ---------------------------------------------------- | ------------------------------------------------------------ |
| 字段注入        | 简单，便于添加新的dependency                         | 可能会出现注入失败而出现NullPointedException；在Test和其他Module不可用；不可用于final字段，从而无法保证字段的不变性。 |
| setter注入      | 灵活性高，便于修改依赖对象                           | 对于仅使用setter注入的依赖对象需要进行非空检查；对象无法在构造完成后马上进入就绪状态 |
| constructor注入 | 对象在构造完成之后，即已进入就绪状态，可以马上使用。 | 当依赖对象比较多的时候，构造方法的参数列表会比较长，维护和使用也比较麻烦，根据单一职责原则，此时应该考虑重构了。使用不慎还有可能出现循环依赖。 |

***Spring4.x之后，注入方式应该按需选择setter或constructor注入方式。***

#### 自动装配方式

**自动装配是为了将依赖注入“自动化”的一个简化配置的操作。**
当一个对象的属性是另一个对象时，实例化时，需要为这个对象属性进行实例化。这就是装配。

Spring 装配包括手动装配和自动装配，手动装配是有基于 xml 装配、 构造方法、 setter 方法等；自动装配有五种自动装配的方式，可以用来指导Spring容器用自动装配方式来进行依赖注入。
1. no：默认的方式是不进行自动装配，通过显式设置 ref 属性来进行装配。
2. byName：通过参数名 自动装配， Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byname，之后容器试图匹配、装配和该 bean 的属性具有相同名字的 bean。
3. byType：通过参数类型自动装配， Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byType，之后容器试图匹配、装配和该 bean 的属性具有相同类型的 bean。如果有多个 bean 符合条件，则抛出错误。
4. constructor：这个方式类似于 byType， 但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。
5. autodetect：首先尝试使用 constructor 来自动装配，如果无法工作，则使用 byType 方式。

常用的自动装配注解有以下几种：@Autowired，@Qualifier(@Resource, @Inject, @Named为JavaEE的标准，不建议使用)。

**@Autowired**注解是byType类型的，这个注解可以用在属性上面，setter方面上面以及构造器上面。使用这个注解时，就不需要在类中为属性添加setter方法了。但是这个属性是强制性的，也就是说必须得装配上，如果没有找到合适的bean能够装配上，就会抛出异常：｀NoSuchBeanDefinitionException，如果required=false时，则不会抛出异常。另一种情况是同时有多个bean是一个类型的，也会抛出这个异常。此时需要进一步明确要装配哪一个Bean，这时可以组合使用@Qualifier注解，值为Bean的名字即可。

**@Qualifier**注解使用byName进行装配，这样可以在多个类型一样的bean中，明确使用哪一个名字的bean来进行装配。@Qualifier注解起到了缩小自动装配候选bean的范围的作用。

自动检测配置，也是springmvc中最牛的一项功能。只要一个配置`<context:component-scan base-package="">`或者注解`@ComponentScan("")`

该配置会自动扫描指定的包及其子包下面被构造型注解标注的类，并将这些类注册为spring bean，这样就不用在配置文件一个一个地配置成bean标签。构造型注解包括：@Controller，@Components，@Service，@Repository和使用@Component标注的自定义注解。

#### 循环依赖

依赖注入稍不注意就会出现循环依赖：
Bean之间的依赖顺序： BeanA -> BeanB -> BeanA

举个例子：

@Component
public class CircularDependencyA {

private CircularDependencyB circB;

@Autowired
public CircularDependencyA(CircularDependencyB circB) {
    this.circB = circB;
}

}

@Component
public class CircularDependencyB {

private CircularDependencyA circA;

@Autowired
public CircularDependencyB(CircularDependencyA circA) {
    this.circA = circA;
}

}


**解决办法**

出现循环依赖是因为设计问题，**最佳处理方法是重新设计**。

在实际开发中，推倒重来往往是不允许的，所以会有以下几种补救方法。

1. 改用setter注入方式(推荐)
   与constructor注入不同，setter是按需注入的，并且允许依赖对象为null；

@Component
public class CircularDependencyA {


   private CircularDependencyB circB;

   @Autowired
   public void setCircB(CircularDependencyB circB) {
       this.circB = circB;
   }

   public CircularDependencyB getCircB() {
       return circB;
   }

}

@Component
public class CircularDependencyB {


   private CircularDependencyA circA;

   @Autowired
   public void setCircA(CircularDependencyA circA) {
       this.circA = circA;
   }

}


2. @Lazy注解（延迟初始化）

  // 先构建 CircularDependencyA完成后， 再构建CircularDependencyB，打破dependency circle。
  @Component
  public class CircularDependencyA {
   
      private CircularDependencyB circB;
   
      @Autowired
      public CircularDependencyA(@Lazy CircularDependencyB circB) {
          this.circB = circB;
      }
  }
  ```

使用ApplicationContextAware, InitializingBean

// ApplicationContextAware获取SpringContext，用于加载bean；InitializingBean定义了设置Bean的property之后的动作。
@Component
public class CircularDependencyA implements InitializingBean, ApplicationContextAware {
    private CircularDependencyB circB;
    private ApplicationContext context;
    
    @Override
    public void afterPropertiesSet() throws Exception {
        this.circB = context.getBean(CircularDependencyB.class);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }

    public CircularDependencyB getCircularDependencyB() {
        return circB;
    }
}

Spring循环以来处理原理

https://cloud.tencent.com/dev...

Spring IOC 原理