Spring详解2.理解IoC容器

时间 2019-12-05

标签 spring 详解理解 ioc 容器栏目 Spring 繁體版

原文原文链接

点击进入个人博客

1 如何理解IoC

1.1 依然是KFC的案例

interface Burger {
    int getPrice();
}
interface Drink {
    int getPrice();
}

class ZingerBurger implements Burger {
    public int getPrice() {
        return 10;
    }
}
class PepsiCola implements Drink {
    public int getPrice() {
        return 5;
    }
}

/**
 * 香辣鸡腿堡套餐
 */
class ZingerBurgerCombo {
    private Burger burger = new ZingerBurger();
    private Drink drink = new PepsiCola();

    public int getPrice() {
        return burger.getPrice() + drink.getPrice();
    }
}

上述案例中咱们实现了一个香辣鸡腿堡套餐，在ZingerBurgerCombo中，咱们发现套餐与汉堡、套餐与饮品产生了直接的耦合。要知道肯德基中的套餐是很是多的，这样须要创建大量不一样套餐的类；并且若是该套餐中的百事可乐若是须要换成其余饮品的话，是不容易改变的。java

class KFCCombo {
    private Burger burger;
    private Drink drink;

    public KFCCombo(Burger burger, Drink drink) {
        this.burger = burger;
        this.drink = drink;
    }
}

class KFCWaiter {
    public KFCCombo getZingerBurgerCombo() {
        return new KFCCombo(new ZingerBurger(), new PepsiCola());
    }
    // else combo…
}

为了防止套餐和汉堡、饮品的耦合，咱们统一用KFCCombo来表示全部的套餐组合，引入了一个新的类KFCWaiter，让她负责全部套餐的装配。git

1.2 控制反转与依赖注入

控制反转IoC

IoC的字面意思是控制反转，它包括两部分的内容：github

控制：在上述案例中，控制就是选择套餐中汉堡和饮品的控制权。
反转：反转就是把该控制权从套餐自己中移除，放到专门的服务员手中。

对于Spring来讲，咱们经过Spring容器管理来管理和控制Bean的装配。web

依赖注入

因为IoC这个重要的概念比较晦涩隐讳，Martin Fowler提出了DI（Dependency Injection，依赖注入）的概念用以代替IoC，即让调用类对某一接口实现类的依赖关系由第三方（容器或协做类）注入，以移除调用类对某一接口实现类的依赖。spring

Spring容器

Spring就是一个容器，它经过配置文件或注解描述类和类之间的依赖关系，自动完成类的初始化和依赖注入的工做。让开发着能够从这些底层实现类的实例化、依赖关系装配等工做中解脱出来，专一于更有意义的业务逻辑开发。编程

2 IoC的类型

从注入方法上看，IoC能够分为：构造函数注入、属性注入、接口注入数组

构造函数注入

class KFCCombo {
    private Burger burger;
    private Drink drink;

    // 在此注入对应的内容
    public KFCCombo(Burger burger, Drink drink) {
        this.burger = burger;
        this.drink = drink;
    }
}

属性注入

class KFCCombo {
    private Burger burger;
    private Drink drink;

    // 在此注入对应的内容
    public void setBurger(Burger burger) {
        this.burger = burger;
    }

    // 在此注入对应的内容
    public void setDrink(Drink drink) {
        this.drink = drink;
    }
}

接口注入

interface InjectFood {
    void injectBurger(Burger burger);
    void injectDrink(Drink drink);
}

class KFCCombo implements InjectFood {
    private Burger burger;
    private Drink drink;
    
    // 在此注入对应的内容
    public void injectBurger(Burger burger) {
        this.burger = burger; 
    }
    // 在此注入对应的内容
    public void injectDrink(Drink drink) {
        this.drink = drink;
    }
}

接口注入和属性注入并没有本质的区别，并且还增长了一个额外的接口致使代码增长，所以不推荐该方式。缓存

3 资源访问

JDK提供的访问资源的类（如java.net.URL、File等）并不能很好地知足各类底层资源的访问需求，好比缺乏从类路径或者Web容器上下文中获取资源的操做类。所以，Spring提供了Resource接口，并由此装载各类资源，包括配置文件、国际化属性文件等资源。服务器

3.1 Resource类图

WritableResource：可写资源接口，Spring3.1新增的接口，有2个实现类：FileSystemResource和PathResource。
ByteArrayResource：二进制数组表示的资源，二进制数组资源能够在内存中经过程序构造。
ClassPathResource：类路径下的资源，资源以相对于类路径的方式表示。
FileSystemResouce：文件系统资源，资源以文件系统路径的方式表示。
InputStreamResource：以输入流返回标识的资源
ServletContextResource：为访问Web容器上下文中的资源而设计的类，负责以相对于Web应用根目录的路径来加载资源。支持以流和URL的形式访问，在war包解包的状况下，也能够经过File方式访问。该类还能够直接从JAR包中访问资源。
UrlResource：封装了java.net.URL，它使用户可以访问任何能够经过URL表示的资源，如文件系统的资源、HTTP资源、FTP资源
PathResource：Spring 4.0提供的读取资源文件的新类。PathResource封装了java.net.URL、java.nio.file.Path、文件系统资源，它使用户可以访问任何能够经过URL、Path、系统文件路径标识的资源，如文件系统的资源、HTTP资源、FTP资源

3.2 资源加载

为了访问不一样类型的资源，Resource接口下提供了不一样的子类，这形成了使用上的不便。Spring提供了一个强大的加载资源的方式，在不显示使用Resource实现类的状况下，仅经过不一样资源地址的特殊标示就能够访问对应的资源。架构

地址前缀	实例	释义
classpath:	classpath:com/ankeetc/spring/Main.class	从类不经中加载资源，classpath: 和 classpath:/ 是等价的，都是相对于类的根路径，资源文件能够在标准的文件系统中，也能够在jar或者zip的类包中
file:	file:/Users/zhengzhaoxi/.gitconfig	使用UrlResource从文件系统目录中装载资源，能够采用绝对路径或者相对路径
http://	http://spiderlucas.github.io/...	使用UrlResource从web服务器中加载资源
ftp://	ftp://spiderlucas.github.io/atom.xml	使用UrlResource从FTP服务器中装载资源
没有前缀	com/ankeetc/spring/Main.class	根据ApplicationContext的具体实现类采用对应类型的Resource

classpath:与classpath*:

假设有多个Jar包或者文件系统类路径下拥有一个相同包名（如com.ankeetc）：

classpath：只会在第一个加载的com.ankeetc包的类路径下查找
classpath*：会扫描到全部的这些JAR包及类路径下出现的com.ankeetc类路径。

这对于分模块打包的应用很是有用，假设一个应用分为2个模块，每个模块对应一个配置文件，分别为module1.yaml 、module2.yaml，都放在了com.ankeetc的目录下，每一个模块单独打成JAR包。可使用 classpath*:com/ankeetc/module*.xml加载全部模块的配置文件。

Ant风格的资源地址通配符

? 匹配文件名中的一个字符
* 匹配文件名中的任意字符
** 匹配多层路径

资源加载器

ResourceLoader接口仅有一个getResource(String loacation)方法，能够根据一个资源地址加载文件资源。不过，资源地址仅支持带资源类型前缀的表达式，不支持Ant风格的资源路径表达式。
ResourcePatternResolver扩展ResourceLoader接口，定义了一个新的接口方法getResource(String locationPattern)，改方法支持带资源类型前缀及Ant风格的资源路径表达式。
PathMatchingResourcePatternResolver是Spring提供的标准实现类。

4 BeanFactory

BeanFactory是Spring框架最核心的接口，它提供了高级IoC的配置机制。咱们通常称BeanFactory为IoC容器。
BeanFactory是Spring框架等基础设施，面向Spring自己。
BeanFactory是一个类工厂，能够建立并管理各类类的对象。
全部能够被Spring容器实例化并管理的Java类均可以成为Bean。
BeanFactory主要方法就是getBean(String beanName);
BeanFactory启动IoC容器时，并不会初始化配置文件中定义的Bean，初始化动做在第一个调用时产生。
对于单实例的Bean来讲，BeanFactory会缓存Bean实例，在第二次使用geBean()获取Bean时，将直接从IoC容器的缓存中获取Bean实例。

4.1 BeanFactory体系结构

BeanFactory：BeanFactory接口位于类结构树的顶端，它最主要的方法就是getBean(String beanName) ，该方法从容器中返回特定名称的Bean，BeanFactory的功能经过其余接口而获得不断扩展。
ListableBeanFactory：该接口定义了访问容器中Bean基本信息的若干方法，如：查看 Bean 的个数、获取某一类型Bean的配置名、或查看容器中是否包含某一个Bean。
HierarhicalBeanFactory：父子级联 IoC 容器的接口，子容器能够经过接口方法访问父容器。
ConfigurableBeanFactory：该接口加强了IoC容器的可定制性，它定义了设置类装载器、属性编辑器、容器初始化后置处理器等方法。
AutowireCapableBeanFactory：定义了将容器中的Bean按某种规则（如：按名称匹配、按类型匹配）进行自动装配的方法。
SingletonBeanFactory：定义了容许在运行期间向容器注册单实例Bean的方法。
BeanDefinitionRegistry：Spring配置文件中每个Bean节点元素在Spring容器里都经过一个 BeanDefinition对象表示，它描述了Bean的配置信息。而BeanDefinitionRegistry接口提供了向容器手工注册BeanDefinition对象的方法。

4.2 初始化BeanFactory

BeanFactory有多种实现，最经常使用的是 XmlBeanFactory，但在Spring 3.2时已被废弃。目前建议使用XmlBeanDefinitionReader与DefaultListableBeanFactory。

<?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-4.0.xsd">
    <bean id="car" class="com.ankeetc.spring.Car"></bean>
</beans>

public static void main(String[] args) throws Exception {
        ResourceLoader resourceLoader = new DefaultResourceLoader();
        Resource resource = resourceLoader.getResource("beans.xml");

        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
        reader.loadBeanDefinitions(resource);

        beanFactory.getBean("");
    }

4.3 BeanFactory中Bean的生命周期

当调用者经过getBean()向容器请求一个Bean时，若是容器注册了InstantiationAwareBeanPostProcessor接口，则在实例化Bean以前，调用postProcessBeforeInstantiation()方法。
根据配置调用构造方法或者工厂方法实例化Bean。
调用InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation()。
调用InstantiationAwareBeanPostProcessor#postProcessPropertyValues()方法。
设置属性值。
若是Bean实现了BeanNameAware接口，则将调用BeanNameAware#setBeanName()接口方法，将配置文件中该Bean对应的名称设置到Bean中。
若是Bean实现了BeanFactoryAware接口，将调用BeanFactoryAware#setBeanFactory()接口方法。
若是容器注册了BeanPostProcessor接口，将调用BeanPostProcessor#postProcessBeforeInitialization()方法。入參Bean是当前正在处理的Bean，BeanName是当前Bean的配置名，返回的对象为处理后的Bean。BeanPostProcessor在Spring框架中占有重要的地位，为容器提供对Bean进行后续加工处理的切入点，AOP、动态代理都经过BeanPostProcessor来实现。
若是Bean实现了InitializingBean接口，则将调用InitializingBean#afterPropertiesSet()方法。
若是<bean>中定义了init-method初始化方法，则执行这个方法。
调用BeanPostProcessor#postProcessAfterInitialization()方法再次加工Bean。
若是<bean>中指定了Bean的做用范围为scope='prototype'，则将Bean返回给调用者，Spring再也不管理这个Bean的生命周期。若是scope='singleton'，则将Bean放入Spring IoC容器的缓存池中，并返回Bean。
对于scope='singleton'的Bean，当容器关闭时，将触发Spring对Bean的后续生命周期的管理工做。若是Bean实现了DisposableBean接口，将调用DisposableBean#destroy()方法。
对于`scope='singleton'的Bean，若是经过<bean>的destroy-method属性指定了Bean的销毁方法，那么Spring将执行这个方法。

Bean方法的分类

Bean自身的方法：构造方法、Setter设置属性值、init-method、destroy-method。
Bean级生命周期接口方法：如上图中蓝色的部分。BeanNameAware、BeanFactoryAware、InitializingBean、DisposableBean，这些由Bean自己直接实现。
容器级生命周期接口方法：如上图中的红色的部分。InstantiationAwareBeanPostProcessor和BeanPostProcessor这两个接口，通常称它们的实现类为后处理器。后处理器接口不禁Bean自己实现，实现类以容器附加装置的形式注册到Spring容器中。当Spring容器建立任何Bean的时候，这些后处理器都会起做用，因此这些后处理器的影响是全局的。若是须要多个后处理器，能够同时实现Ordered接口，容器将按照特定的顺序依此调用这些后处理器。
工厂后处理器接口方法：AspectJWeavingEnabler、CustomAutowireConfigurer、ConfigurationClassPostProcessor等方法，工厂后处理器也是容器级的，在应用上下文装配配置文件后当即使用。

4.4 BeanFactory生命周期案例

public class Main {
    public static void main(String[] args) {
        Resource resource = new PathMatchingResourcePatternResolver().getResource("classpath:beans.xml");

        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
        reader.loadBeanDefinitions(resource);

        beanFactory.addBeanPostProcessor(new InstantiationAwareBeanPostProcessor() {
            public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
                System.out.println("InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()");
                return null;
            }

            public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
                System.out.println("InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()");
                return true;
            }

            public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
                System.out.println("InstantiationAwareBeanPostProcessor.postProcessPropertyValues()");
                return pvs;
            }

            public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
                System.out.println("BeanPostProcessor.postProcessBeforeInitialization()");
                return bean;
            }

            public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
                System.out.println("BeanPostProcessor.postProcessAfterInitialization()");
                return bean;
            }
        });

        MyBean myBean = beanFactory.getBean("myBean", MyBean.class);
        beanFactory.destroySingletons();
    }
}

class MyBean implements BeanNameAware, BeanFactoryAware, InitializingBean, DisposableBean {
    private String prop;

    public MyBean() {
        System.out.println("MyBean:构造方法");
    }

    public String getProp() {
        System.out.println("MyBean:get方法");
        return prop;
    }

    public void setProp(String prop) {
        System.out.println("MyBean:set方法");
        this.prop = prop;
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("MyBean:BeanFactoryAware.setBeanFactory()");
    }

    public void setBeanName(String name) {
        System.out.println("MyBean:BeanNameAware.setBeanName()");
    }

    public void destroy() throws Exception {
        System.out.println("MyBean:DisposableBean.destroy()");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("MyBean:InitializingBean.afterPropertiesSet()");
    }

    // 配置文件中init-method
    public void myInit() {
        System.out.println("MyBean:myInit()");
    }

    // 配置文件中destroy-method
    public void myDestroy() {
        System.out.println("MyBean:myDestroy()");
    }
}

<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-4.0.xsd">

    <bean class="com.ankeetc.spring.MyBean" name="myBean" init-method="myInit" destroy-method="myDestroy">
        <property name="prop" value="prop"/>
    </bean>
</beans>

4.5 关于Bean生命周期接口的探讨

Bean生命周期带来的耦合：经过实现Spring的Bean生命周期接口对Bean进行额外控制，虽然让Bean具备了更细致的生命周期阶段，但也带来了一个问题，Bean和Spring框架紧密绑定在一块儿了，这和Spring一直推崇的“不对应用程序类做任何限制”的理念是相悖的。业务类本应该彻底POJO化，只实现本身的业务接口，不须要和某个特定框架（包括Spring框架）的接口关联。
init-method和destroy-method：能够经过<bean>的init-method和destroy-method属性配置方式为Bean指定初始化和销毁的方法，采用这种方式对Bean生命周期的控制效果和经过实现InitializingBean、DisposableBean接口所达到的效果是彻底相同的，并且达到了框架解耦的目的。
BeanPostProcessor：BeanPostProcessor接口不须要Bean去继承它，能够像插件同样注册到Spring容器中，为容器提供额外功能。

5 ApplicationContext

5.1 Application体系结构

ApplicationEventPublisher：让容器拥有了发布应用上下文事件的功能，包括容器启动事件、关闭事件等。实现了ApplicationListener事件监听接口的Bean能够接收到容器事件，并对容器事件进行响应处理。在ApplicationContext抽象实现类AbstractApplicationContext中存在一个 ApplicationEventMulticaster，它负责保存全部的监听器，以便在容器产生上下文事件时通知这些事件监听者。
MessageSource：为容器提供了i18n国际化信息访问的功能。
ResourcePatternResolver：全部ApplicationContext实现类都实现了相似于PathMatchingResourcePatternResolver的功能，能够经过带前缀 Ant 风格的资源类文件路径来装载Spring的配置文件。
LifeCycle：它提供了start()和stop()两个方法，主要用于控制异步处理过程。在具体使用时，该接口同时被ApplicationContext实现及具体Bean实现，ApplicationContext会将start/stop的信息传递给容器中全部实现了该接口的Bean，以达到管理和控制JMX、任务调度等目的。
ConfigurableApplicationContext：它扩展了ApplicationContext，让ApplicationContext具备启动、刷新和关闭应用上下文的能力。上下文关闭时，调用 refresh()便可启动上下文；若是已经启动，则调用refresh()可清除缓存并从新加载配置信息；调用close()可关闭应用上下文。

5.2 初始化ApplicationContext

ClassPathXmlApplicationContext：从类路径中加载XML配置文件，也能够显示的使用带资源类型前缀的路径。
FileSystemXmlApplicationContext：从文件系统路径下加载XML配置文件，也能够显示的使用带资源类型前缀的路径。
AnnotationConfigApplicationContext：一个标注@Configuration注解的POJO便可提供Spring所需的Bean配置信息。
GenericGroovyApplicationContext：从Groovy配置中提取Bean。

public static void main(String[] args) throws Exception {
        ClassPathXmlApplicationContext classPathXmlApplicationContext =
                new ClassPathXmlApplicationContext("beans.xml");
        FileSystemXmlApplicationContext fileSystemXmlApplicationContext =
                new FileSystemXmlApplicationContext("file:/Users/zhengzhaoxi/Git/spring/src/main/resources/beans.xml");
        AnnotationConfigApplicationContext annotationConfigApplicationContext =
                new AnnotationConfigApplicationContext(Config.class);
    }

5.3 WebApplicationContext体系结构

见后续章节

5.4 ApplicationContext中Bean的生命周期

不一样点

Bean在ApplicationContext和BeanFactory中生命周期相似，但有如下不一样点

若是Bean实现了ApplicationContextAware接口，则会增长一个调用该接口方法的ApplicationContextAware.setApplicationContext的方法。
若是在配置文件中生命了工厂后处理器接口BeanFactoryPostProcessor的实现类，则应用上下文在装在配置文件以后、初始化Bean实例以前会调用这些BeanFactoryPostProcessor对配置信息进行加工处理。Spring提供了多个工厂容器，如CustomEditorConfigure、PropertyPlaceholderConfigurer等。工厂后处理器是容器级的，只在应用上下文初始化时调用一次，其目的是完成一些配置文件加工处理工做。
ApplicationContext能够利用Java反射机制自动识别出配置文件中定义的BeanPostProcessor、InstantiationAwareBeanPostProcessor、BeanFactoryPostProcessor，并自动将它们注册到应用上下文中（以下所示）；而BeanFactory须要经过手工调用addBeanPostProcessor()方法注册。

<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-4.0.xsd">

    <bean class="com.ankeetc.spring.MyBean" name="myBean" init-method="myInit" destroy-method="myDestroy">
        <property name="prop" value="prop"/>
    </bean>

    <!-- 工厂后处理器 -->
    <bean id="myBeanPostProcessor" class="com.ankeetc.spring.MyBeanPostProcessor"/>

    <!-- 注册Bean后处理器 -->
    <bean id="myBeanFactoryPostProcessor" class="com.ankeetc.spring.MyBeanFactoryPostProcessor"/>
</beans>

6 BeanFactory与ApplicationContext区别

通常称BeanFactory为IoC容器：Bean工厂（com.springframework.beans.factory.BeanFactory）是Spring框架中最核心的接口，它提供了高级 IoC 的配置机制。BeanFactory使管理不一样类型的Java对象成为可能。BeanFactory是Spring框架的基础设施，面向Spring自己。
通常称ApplicationContext为应用上下文或Spring容器：应用上下文（com.springframework.context.ApplicationContext）创建在BeanFactory基础之上，提供了更多面向应用的功能，它提供了国际化支持和框架事件体系，更易于建立实际应用。 ApplicationContext 面向使用 Spring 框架的开发者，几乎全部的应用场合均可以直接使用 ApplicationContext。
BeanFactory在初始化容器的时候，并未实例化Bean，直到第一次访问某个Bean时才实例化Bean；ApplicationContext在初始化应用上下文的时候就实例化所有单实例Bean。
ApplicationContext能够利用Java反射机制自动识别出配置文件中定义的BeanPostProcessor、InstantiationAwareBeanPostProcessor、BeanFactoryPostProcessor，并自动将它们注册到应用上下文中；而BeanFactory须要经过手工调用addBeanPostProcessor()方法注册。

7 父子容器

经过HierarchicalBeanFactory接口，Spring的IoC容器能够创建父子层级关联的容器体系，子容器能够访问父容器中的 Bean，但父容器不能访问子容器的Bean。
在容器内，Bean的id必须是惟一的，但子容器能够拥有一个和父容器id相同的 Bean。
父子容器层级体系加强了Spring容器架构的扩展性和灵活性，所以第三方能够经过编程的方式，为一个已经存在的容器添加一个或多个特殊用途的子容器，以提供一些额外的功能。
Spring使用父子容器的特性实现了不少能力，好比在Spring MVC中，展示层Bean位于一个子容器中，而业务层和持久层的Bean位于父容器中。这样展示层Bean就能够引用业务层和持久层的Bean，而业务层和持久层的Bean则看不到展示层的Bean。