Spring之IOC核心模块详解

Spring IOC简述

IOC称为控制反转，也有一种说法叫DI（依赖注入）。IOC也是spring最核心的模块，Spring的所有工作几乎都围绕着IOC展开。

什么是控制反转呢？简单的说，控制反转就是把我们要做的事情交给别人来做，就像是招了个小弟专门为我们做事情，我们需要做好的东西时直接去找小弟拿。

这里要做的事情就是new 一个对象。我们不再自己去new对象然后使用，而是spring容器帮我们去创建对象然后我们要用的时候直接去拿就行了。spring帮我们

生成对象就是控制反转，而我们要用对象从spring取对象就是依赖注入。

一切的开始要从spring容器的加载说起

我认为一切的开端要从spring 容器开始说起，所有工作都是围绕着Spring容器展开的。

这里只描述两种最常见的加载spring配置文件的方式，其余方式不做描述。

Spring容器是再spring配置文件被加载的一刻生成的。有两种常见加载方式，分别为使用BeanFactroy加载和使用AppilicationContext记载。

BeanFactory

BeanFactory加载spring配置文件又可以称为延迟加载，当BeanFactroy加载完配置文件后，bean并没有生成，而是当第一次使用bean的使用bean才创建。

Resource resource = new ClassPathResource("applicationContext.xml");
BeanFactory beanFactory = new XmlBeanFactory(resource);
Warehouse warehouse = beanFactory.getBean("warehouse",Warehouse.class);

ApplicationContext

而Applicationcontext加载方式是立即加载方式，BeanFactory有的功能它都有，而它有的功能BeanFactroy不一定有，所以是目前最主流的加载方式。

立即加载的意思就是当配置文件加载，spring容器创建的时候，我们配置好的bean就都创建了，这些bean与容器同生共死。

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
Warehouse warehouse = applicationContext.getBean("warehouse",Warehouse.class);

容器加载完后就得谈谈bean的创建了

bean有三种创建方式：

默认无参构造函数创建、静态工厂创建、实例工厂创建

默认无参创建方式

也是最常用的创建方式。我们定义一个实体类时默认有一个无参构造函数，可以不用创建。

//实体类
public class User {
    private String name;
    private int age;
    //get set...
}

//bean创建
<bean id="user" class="springIOCTest.User"/>

但是当我们定义的实体类有带参构造函数时就得显式的为其创建一个无参构造函数，否则bean创建失败

public class User {
    private String name;
    private int age;

    public User() {

    }
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // get set...
}

静态工厂创建bean

首先的先定义一个静态工厂类

public class StaticFactroy {
    private User user;
    public static User getUser() {
        return new User();
    }
}

在创建bean的时候类路径选择静态工厂类路径，指定factory-method

<bean id="user" class="springIOCTest.StaticFactroy" factory-method="getUser"/>

实例工厂创建bean

定义一个普通工厂类

public class InstanceFactory {
    private User user;
    public User getUser() {
        return new User();
    }
}

在创建bean的时候先创建工厂bean，再根据工厂bean创建我们需要的bean

<bean id="instanceFactroy" class="springIOCTest.InstanceFactory"/>
<bean id="user" factory-bean="instanceFactroy" factory-method="getUser"/>

虽然我们知道了如何创建一个bean，但是我们每个bean里面可能有很多属性，需要我们去注入。

接下来谈谈bean的注入方式

每当我们new一个对象的时候，经常需要给它里面的属性设值或者传递引用，spring也可以帮我们完成这项工作

比如我们要为上面的User类的name属性和age属性注入值。那么有两种方式注入：属性注入和构造函数注入

首先做下准备工作，为User类加个实体属性：

public class User {
    private String name;
    private int age;
    private UserSon mySon;
    // get set...
}

属性注入

属性注入就是我们平常new 一个对象后setxxx

<bean id="mySon" class="springIOCTest.UserSon"/>
<bean id="user" class="springIOCTest.User">
   <property name="name" value="张三"/>
   <property name="age" value="18"/>
   <property name="mySon" ref="mySon"/>
</bean>

可以看到属性中包含实体类的时候必须先创建一个该类的bean，然后通过ref的方式注入

 构造函数注入

public class User {
    private String name;
    private int age;
    private UserSon mySon;
    public User(String name, int age, UserSon mySon) {
        this.name = name;
        this.age = age;
        this.mySon = mySon;
    }
    // get set...
}
<bean id="mySon" class="springIOCTest.UserSon"/>
    <bean id="user" class="springIOCTest.User">
    <constructor-arg index="0" name="name" value="张三"/>
    <constructor-arg index="1" name="age" value="18"/>
    <constructor-arg index="2" name="mySon" ref="mySon"/>
</bean>

构造函数注入的前提时提供对应的构造函数，但是使用构造函数容易产生一个问题，那就是循环依赖问题

循环依赖问题

当使用构造函数注入的时候可能会出现一下一种情况

public class UserSon {
    private User father;

    public UserSon(User father) {
        this.father = father;
    }
    //get set..
}

User实体类需要注入UserSon实例，而UserSon实体类也需要注入User实例，那么在生成bean的时候会出现以下情况

<bean id="mySon" class="springIOCTest.UserSon">
    <constructor-arg index="0" name="father" ref="user"/>
</bean>
<bean id="user" class="springIOCTest.User">
   <constructor-arg index="0" name="name" value="张三"/>
   <constructor-arg index="1" name="age" value="18"/>
   <constructor-arg index="2" name="mySon" ref="mySon"/>
</bean>

这样就形成了死胡同，类时死锁，这时候就会报错。

解决办法很简单，改为属性注入方式即可。

因此，使用构造函数注入的时候可能会产生问题，又比较麻烦，所以实际场景中使用属性注入是比较常见的

这里要对循环依赖再做个详细说明

 为什么通过setter注入引用可以避免循环依赖而通过构造函数注入就不能呢，这就涉及到了spring容器的三级缓存和bean的提前曝光

举个例子A引用B，B引用C，C引用A。当Spring容器加载并且要创建BeanA的时候，BeanA根据无参构造函数创建BeanA，但这里BeanA还没有

成功创建完成，因为它发现了它需要setterB，这时候BeanA虽然没创建完成但是会把它提前曝光并且加入到三级缓存中，然后容器去加载B，BeanB

根据无参构造函数创建BeanB，BeanB发现需要setterC，先将BeanB提前曝光加入三级缓存，然后容器又去创建BeanC，BeanC根据无参构造函数创建

BeanC，并提前曝光加入三级缓存，然后BeanC从三级缓存中找到BeanA，虽然BeanA还没创建完成，但是BeanC可以将其setter进去，然后BeanC创建完成

然后BeanB也成功setter进BeanC，BeanA也成功setter进BeanB了。那么为什么构造器相互引用无法避免循环依赖呢，原因是当BeanA在调用构造函数生成BeanA的

时候发现需要BeanB，于是去创建BeanB，由于这时候构造函数没有执行结束，也就是BeanA无法提前爆光加入三级缓存，BeanB发现它也是通过构造函数注入，且需要注入

BeanA，因此BeanB也无法提前曝光加入三级缓存，因此两者就无法将对方的引用注入到自己属性上，产生了死循环。

总而言之

Spring避免循环依赖的方式就是构造函数调用完但是setter还没执行的半成品Bean提前曝光加入三级缓存，这时候其他需要引用该Bean的就可以从三级缓存中取到这个引用，

虽然Bean还没创好，但是引用却是不会随着后面bean创建完成而该变的。

到这里我们就讲完了如何完整的创建一个bean了，接下来就来谈谈bean的生命周期吧

bean的生命周期

bean的完整生命周期从spring容器着手实例化bean开始，直到最终销毁bean。其中经过了很多关键点，每个关键点都涉及到特定的方法调用，

我们可以将这些方法大致分以下四类。

  • Bean自身的方法
  • Bean级生命周期接口方法
  • 容器级生命周期接口方法
  • 工厂后处理器接口方法

Bean自身的方法调用Bean的构造函数实例化Bean，调用setter设置Bean的属性值以及通过<bean> 的 init-method 和destory-method所指定的方法。

Bean级生命周期接口方法如BeanNameAware、BeanFactoryAware、InitialzingBeanh、DisposableBean等等，这些接口方法由Bean类直接实现。

容器级生命周期接口方法独立于Bean，实现类以容器附加装置的形式注册到Spring容器中，一般这些方法产生的影响是整个容器，而不是自己的bean

工厂后处理器接口方法也是容器级别的，在应用上下文装配配置文件后立即调用。

Bean级生命周期接口方法和容器级生命周期接口方法前者解决Bean个性化处理的问题，后者解决容器中某些Bean共性化处理的问题。

对于Bean生命周期接口的探讨。

我们都知道，spring推崇不对应用程序类做任何限制， spring的好处在于用户可以完全将业务类POJO化，不用实现容器特定的接口，只要关心用户自定义的接口。

但是如果为了实现这些接口就将Bean和Spring牢牢的绑定在了一起，违反了初衷。

因此我们可以通过<bean> 的 init-method 和destory-method属性配置方式为Bean指定初始化和销毁的方法，采用这种方式对bean的生命周期的控制效果和通过Bean级生命周期的

InitialzingBeanh和DisposableBean接口所达到的效果是完全相同的，并且采用前者可以达到了框架解耦的目的。因此除非必要，我们都可以抛弃Bean级生命周期接口方法使用更好的

方式取代。

在这里不对生命周期中的一些spring接口做详细介绍，若想了解更多，可自行查找资料。

在这里可以简单的为生命周期做个简化：

单例模式的bean：

出生：容器加载bean就加载

存活：容器存在bean就存在

死亡：容器销毁bean就销毁

原型模式的bean：

出生：bean在使用的时候才创建

存活：bean在使用的期间存活

死亡：当bean不在使用并且没有其他对象引用该bean的时候由垃圾回收期帮忙回收

现在我们知道bean怎么创建的了，也了解了它的生命周期了，那我们下面就来谈谈它的作用域吧！

Bean的作用域

Bean有五种作用域：单例，原型，请求，会话，全局会话。

单例（singleton）：每个容器中只有一个bean

原型（prototype）：用到bean一次生成一个bean

请求（request）：一次请求产生一个bean

会话（session）：一次会话产生一个bean

全局会话（globalsession）：当采用服务器集群的时候同一个session可能访问不同的服务器，这时候使用该作用域可以做到多个服务器都是同一个bean

配置会话可以在<bean>内的scope中配置

嗯~现在Bean的作用域我们也知道了，但是Bean有三种不同的装配方式，也就是说我们可以采用三种方式标明该类是一个bean，容器要去加载它。

Bean的装配方式

  • XML方式
  • 注解方式
  • Java代码方式

上面我们所用到的例子都是使用xml配置方式声明一个bean。

注解方式就是在我们要配置的bean类上面加个注释，一共有四个注释：

@Component、@Repository、@Service、@Controller；后三个分别对应持久层、服务层、控制层的bean

但是四个注解都是可以统用的，弄了这么多主要是为了提高程序可读性。使用注解方式还要再spring配置中

加个小小的配置，即扫描加了配置的bean类的所在包

<context:component-scan base-package="test1"/>

由于我主要使用XML配置和注解配置，故Java代码方式不做展开，但是现在Java代码配置Bean逐渐取代xml方式，读者可自行去了解。

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/czsy/p/10843163.html