Spring IOC 总结

IOC

简介

IOC是（Inversion of Control，控制反转）的简写。Spring提供IOC容器，将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的的过度程序耦合。它由DI(Dependency Injection，依赖注入)来实现。

那么到底什么是Spring IOC？

IOC 将传统的在对象内部直接控制对象（如new方式）改为交由Spring IOC容器去控制。由于控制对象的权限反转了所以叫做 控制反转。

比如：

在传统的java程序设计中我们一般会在对象内部通过new的方式直接创建对象。但是在IOC中我们将对象的控制权限转交给Spring的IOC容器，由容器根据需求创建对象。

IoC容器是啥？

Spring IOC容器是一个管理Bean的容器，在Spring的定义中要求所有的IOC容器都实现接口BeanFactory(它是一个顶层容器接口)。

如下部分源码：

import org.springframework.beans.BeansException;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;

public interface BeanFactory {
    //前缀
    String FACTORY_BEAN_PREFIX = "&";
    // 多个 getBean 方法
    Object getBean(String var1) throws BeansException;

    <T> T getBean(String var1, Class<T> var2) throws BeansException;

    Object getBean(String var1, Object... var2) throws BeansException;

    <T> T getBean(Class<T> var1) throws BeansException;

    <T> T getBean(Class<T> var1, Object... var2) throws BeansException;

    <T> ObjectProvider<T> getBeanProvider(Class<T> var1);

    <T> ObjectProvider<T> getBeanProvider(ResolvableType var1);

    //是否包含 Bean
    boolean containsBean(String var1);

    //是否是单例
    boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;

    //是否是原型
    boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;

    //是否类型匹配
    boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;

    //获取Bean 类型
    @Nullable
    Class<?> getType(String var1) throws NoSuchBeanDefinitionException;

    //获取Bean别名
    String[] getAliases(String var1);
}

• 从源码中有多个getBean()方法，这是IOC容器最重要的方法之一。从多种getBean()方法中我们可以看出Spring IOC容器允许我们通过多种方式获取Bean。
• isSingleton 方法则判断 Bean 是否在 Spring IoC 中为单例。这里需要记住的是 在 Spring IoC 容器中，默认情况下，Bean 都是单例存在的，也就是说使用 getBean 方法返回的都是同一个对象。
• 与 isSingleton 方法相反的是 isPrototype 方法。如果它返回的是 true，那么当我们使用 getBean 方法获取 Bean 的时候， Spring IoC 容器就会创建一个新的 Bean 返回给调用者。

但是，BeanFactory的功能不够强大，在后期开发者在Spring BeanFactory 的基础上又设计了一个更高级的接口ApplicationContext。在现实使用上我们使用的大多数Spring IOC 容器都是ApplicationContext接口的实现类。



在SpringBoot中我们主要采用注解的方式来装配Bean到Spring容器。此时使用到一个基于注解的IOC容器AnnotationConfigApplicationContext。

演示(以SpringBoot中注解方式装配Bean到Spring容器中为例)

1.首先我们定义一个简单的User对象

public class User{
    private Long id;
    private String userName;
    private String note;

    /*** getter and setter ***/
}

2.然后定义一个java的配置文件APPConfig.java

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    @Bean(name = "user")
    public User initUser(){
        User user = new User();
        user.setId(1L);
        user.setUserName("name");
        user.setNote("note");
        return user;
    }
}

注意：

• @Configuration:代表这是一个 Java 配置文件，Spring 容器会根据它来生成 IoC 容器去装配Bean。
• 代表将 initUser 方法返回的 POJO 装配到 IoC 容器中，而其 属性 name 定义这个Bean 的名称，如果没有配置它，那么则将方法名 initUser 作为Bean的名称并保存到 Spring IoC 容器中。

3.做好这些 ，就可以使用 AnnotationConfigApplicationContext 来构建自己的 IoC 容器了

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class IoCTest {
    private static Logger logger = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);
    public static void main(String[] args){
        ApplicationContext ctx =
                new AnnotationConfigApplicationContext(AppConfig.class);
        User user = ctx.getBean(User.class);
        logger.info("user' id is " + user.getNote());
    }
}

代码中将 Java 配置文件 AppConfig 传递给 AnnotationConfigApplicationContext 的构造方法，这样它就能读取配置了。 然后将配置中的 Bean 装配到 IoC 容器中，于是就可以使用 getBean 方法获取对应的 POJO。