Spring与IoC

比眉伴天荒 2022-05-14 12:16 162阅读 0赞

## Spring与IoC ##

一、IoC概述

*  控制反转（IoC，Inversion of Control），是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，其实现方式多种多样。当前比较流行的实现方式有两种：依赖注入和依赖查找。依赖注入方式应用更为广泛。
 *  依赖查找：  
    Dependency Lookup，DL，容器提供回调接口和上下文环境给组件，程序代码则需要提供具体的查找方式。比较典型的是依赖于 JNDI 服务接口（Java Naming and  
    Directory Interface）的查找。
 *  依赖注入：  
    Dependency Injection，DI，程序代码不做定位查询，这些工作由容器自行完成。依赖注入 DI 是指程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。  
    Spring 的依赖注入对调用者与被调用者几乎没有任何要求，完全支持 POJO 之间依赖关系的管理。依赖注入是目前最优秀的解耦方式。依赖注入让 Spring 的 Bean 之间以配置文件的方式  
    组织在一起，而不是以硬编码的方式耦合在一起的。

二、Spring程序举例

*  定义接口与实体类

public interface IStudentService{
        void some();
    }

public class SatudentServiceImpl implements IStudentService{ 
        public void some(){
            System.out.println("执行some()方法");
        }
    }

*  创建Spring配置文件  
    ![这里写图片描述][70]  
    bean标签 ：用于定义一个实例对象。一个实例对应一个 bean 元素。  
    id：该属性是 Bean 实例的唯一标识，程序通过 id 属性访问 Bean，Bean 与 Bean 间的依赖关系也是通过 id 属性关联的。  
    class：指定该 Bean 所属的类，注意这里只能是类，不能是接口。
 *  定义测试类

@Test
    public void test03(){
        //获取容器
        ApplicationContext context=
        new ClassPathXmlApplicationContext("application.xml");
        //从容器获取对象
        IStudentService Service=(IStudentService)context.getBean("studentservice");
        service.some();
    }

（1）ApplicationContext接口容器

ApplicationContext 用于加载 Spring 的配置文件，在程序中充当“容器”的角色。其实现类有两个。通过 Ctrl +T 查看：  
![这里写图片描述][70 1]

A、配置文件在类路径下

*  若Spring配置文件存放在项目的类路径下，则使用 ClassPathXmlApplicationContext 实现类进行加载。

ApplicationContext context=
        new ClassPathXmlApplicationContext("application.xml");

B、配置文件在本地目录中

*  若 Spring 配置文件存放在本地磁盘目录中，则使用 FileSystemXmlApplicationContext 实现类进行加载。

ApplicationContext context=
        new FileSystemApplicationContext("d：/application.xml");

C、配置文件在项目根路径下

*  若 Spring 配置文件存放在项目的根路径下，同样使用 FileSystemXmlApplicationContext实现类进行加载。存放在项目根路径下的情况，该配置文件与 src 目录同级，而非在 src 中。

ApplicationContext context=
        new FileSystemApplicationContext("application.xml");

（2）BeanFactory接口容器

*  BeanFactory 接口对象也可作为 Spring 容器出现。BeanFactory 接口是 ApplicationContext  
    接口的父类
 *  若要创建 BeanFactory 容器，需要使用其实现XmlBeanFactory（Ctrl+T 查看继承关系）。该类可以加载 Spring 配置文件。
 *  而 Spring 配置文件以资源 Resouce 的形式出现在 XmlBeanFactory 类的构造器参数中。Resouce 是一个接口，其具有两个实现类：ClassPathResource：指定类路径下的资源文件、FileSystemResource：指定项目根路径或本地磁盘路径下的资源文件。
 *  在创建了 BeanFactory 容器后，便可使用其重载的 getBean()方法，从容器中获取指定的Bean 对象  
    ![这里写图片描述][70 2]

（3）两个接口容器的区别

*  虽然这两个接口容器所要加载的 Spring 配置文件是同一个文件，但在代码中的这两个容器对象却不是同一个对象，即不是同一个容器：它们对于容器内对象的装配（创建）时机是不同的。
 *  ApplicationContext 容器中对象的装配时机：  
    ApplicationContext 容器，会在容器对象初始化时，将其中的所有对象一次性全部装配好。以后代码中若要使用到这些对象，只需从内存中直接获取即可。执行效率较高。但占用内存。
 *  BeanFactory 容器中对象的装配时机：  
    BeanFactory 容器，对容器中对象的装配与加载采用延迟加载策略，即在第一次调用getBean()时，才真正装配该对象。

三、Bear的装配

*  Bean 的装配，即 Bean 对象的创建。容器根据代码要求创建 Bean 对象后再传递给代码的过程，称为 Bean 的装配。

（1）默认装配方式

*  代码通过 getBean()方式从容器获取指定的 Bean 实例，容器首先会调用 Bean 类的无参构造器，创建空值的实例对象。

（2）动态工厂 Bean

*  有些时候，项目中需要通过工厂类来创建 Bean 实例，而不能像前面例子中似的，直接由 Spring 容器来装配 Bean 实例。使用工厂模式创建 Bean 实例，就会使工厂类与要创建的Bean 类耦合到一起。

（3）静态工厂 Bean

*  使用工厂模式中的静态工厂来创建实例 Bean。此时需要注意，静态工厂无需工厂实例，所以不再需要定义静态工厂bean。而对于工厂所要创建的 Bean，其不是由自己的类创建的，所以无需指定自己的类。但其是由工厂类创建的，所以需要指定所用工厂类。故 class 属性指定的是工厂类而非自己的类。当然，还需要通过 factory-method 属性指定工厂方法。

（4）容器中Bear的作用域

*  当通过 Spring 容器创建一个 Bean 实例时，不仅可以完成 Bean 的实例化，还可以通过scope 属性，为 Bean 指定特定的作用域。Spring 支持 5 种作用域。
    
     *  singleton：单态模式。即在整个 Spring 容器中，使用 singleton 定义的 Bean 将是单例的，只有一个实例。默认为单态的。
     *  prototype：原型模式。即每次使用 getBean 方法获取的同一个bean 的实例都是一个新的实例。
     *  request：对于每次 HTTP 请求，都将会产生一个不同的 Bean 实例。
     *  session：对于每个不同的 HTTP session，都将产生一个不同的 Bean 实例。
    
    注意：  
    （1）对于 scope 的值 request、session 与 global session，只有在 Web 应用中使用 Spring 时，该作用域才有效。  
    （2）对于 scope 为 singleton 的单例模式，该 Bean 是在容器被创建时即被装配好了。  
    （3）对于 scope 为 prototype 的原型模式，Bean 实例是在代码中使用该 Bean 实例时才进行装配的。

（5）bean后处理器

*  Bean 后处理器是一种特殊的 Bean，容器中所有的 Bean 在初始化时，均会自动执行该类的两个方法。由于该 Bean 是由其它 Bean 自动调用执行，不是程序员手工调用，故此 Bean无须 id 属性。
 *  需要做的是，在 Bean 后处理器类方法中，只要对 Bean 类与 Bean 类中的方法进行判断，就可实现对指定的 Bean 的指定方法进行功能扩展与增强。方法返回的 Bean 对象，即是增过的对象。
 *  代码中需要自定义 Bean 后处理器类。该类就是实现了接口 BeanPostProcessor 的类。该接口中包含两个方法，分别在目标 Bean 初始化完毕之前与之后执行。它们的返回值为：功能被扩展或增强后的 Bean 对象。
 *  Bean 初始化完毕有一个标志：一个方法将被执行。即当该方法被执行时，表示该 Bean被初始化完毕。所以 Bean 后处理器中两个方法的执行，是在这个方法之前之后执行。

public Object postProcessBeforeInitialization(Object bean, String beanId)
    throws BeansException
    该方法会在目标 Bean 初始化完毕之前由容器自动调用。

public Object postProcessAfterInitialization(Object bean, String beanId) throws BeansException
    该方法会在目标 Bean 初始化完毕之后由容器自动调用。

*  它们的参数是：第一个参数是系统即将初始化的 Bean 实例，第二个参数是该 Bean 实例的 id 属性值。若 Bean 没有 id 就是 name 属性值。

（6）定制Bean的生命始末

*  可以为 Bean 定制初始化后的生命行为，也可以为 Bean 定制销毁前的生命行为。首先，这些方法需要在 Bean 类中事先定义好：是方法名随意的 public void 方法。  
    ![这里写图片描述][70 3]
 *  其次，在配置文件的标签中增加如下属性：  
    init-method：指定初始化方法的方法名  
    destroy-method：指定销毁方法的方法名  
    ![这里写图片描述][70 4]  
    注意，若要看到 Bean 的 destroy-method 的执行结果，需要满足两个条件：  
    （1）Bean 为 singleton，即单例  
    （2）要确保容器关闭。接口 ApplicationContext 没有 close()方法，但其实现类有。所以，可以将 ApplicationContext 强转为其实现类对象，或直接创建的就是实现类对象。  
    ![这里写图片描述][70 5]

（7）Bean的生命周期

Step1：调用无参构造器，创建实例对象。
    Step2：调用参数的 setter，为属性注入值。
    Step3：若 Bean 实现了 BeanNameAware 接口，则会执行接口方法 setBeanName(String beanId)，使 Bean 类可以获取其在容器中的 id 名称。
    Step4：若 Bean 实现了 BeanFactoryAware 接口，则执行接口方法 setBeanFactory(BeanFactoryfactory)，使 Bean 类可以获取到 BeanFactory 对象。
    Step5 ： 若 定 义 并 注 册 了 Bean 后 处 理 器 BeanPostProcessor ， 则 执 行 接 口 方 法postProcessBeforeInitialization()。
    Step6：若 Bean 实现了 InitializingBean 接口，则执行接口方法 afterPropertiesSet ()。该方法在 Bean 的所有属性的 set 方法执行完毕后执行，是 Bean 初始化结束的标志，即 Bean 实例化结束。
    Step7：若设置了 init-method 方法，则执行。
    Step8 ： 若 定 义 并 注 册 了 Bean 后 处 理 器 BeanPostProcessor ， 则 执 行 接 口 方 法postProcessAfterInitialization()。
    Step9：执行业务方法。
    Step10：若 Bean 实现了 DisposableBean 接口，则执行接口方法 destroy()。
    Step11：若设置了 destroy-method 方法，则执行。

四、基于XML的DI

（1）注入分类

*  Bean 实例在调用无参构造器创建了空值对象后，就要对 Bean 对象的属性进行初始化。初始化是由容器自动完成的，称为注入。根据注入方式的不同，常用的有两类：设值注入、构造注入。还有另外一种，实现特定接口注入。由于这种方式采用侵入式编程，污染了代码，所以几乎不用。

1，设值注入

*  设值注入是指，通过 setter 方法传入被调用者的实例。这种注入方式简单、直观，因而在 Spring 的依赖注入中大量使用。  
    ![这里写图片描述][70 6]
 *  当指定 bean 的某属性值为另一 bean 的实例时，通过 ref 指定它们间的引用关系。ref的值必须为某 bean 的 id 值。  
    ![这里写图片描述][70 7]
 *  对于其它 Bean 对象的引用，除了标签的 ref 属性外，还可以使用ref标签。  
    ![这里写图片描述][70 8]

1，构造注入

*  构造注入是指，在构造调用者实例的同时，完成被调用者的实例化。即，使用构造器设置依赖关系。  
    ![这里写图片描述][70 9]

![这里写图片描述][70 10]  
constructor-arg 标签中用于指定参数的属性有：  
name：指定参数名称。  
index：指明该参数对应着构造器的第几个参数，从 0 开始。不过，该属性不要也行，但要注意，若参数类型相同，或之间有包含关系，则需要保证赋值顺序要与构造器中的参数顺序一致。  
另外，type 属性可用于指定其类型。基本类型直接写类型关键字即可，非基本类型需要写全限定性类名。

（2）集合属性注入  
\* 集合：

public class MyController{
        private String [] strs;
        private List<Student> students;
        private Set<String> myset;
        private Map<String,Integer> myMap;
        private Properties myPro;
    }

1，为数组注入值  
![这里写图片描述][70 11]  
2，为 List 注入值  
![这里写图片描述][70 12]  
3，为 Set 注入值  
![这里写图片描述][70 13]  
4，为 Map 注入值  
![这里写图片描述][70 14]  
5，为 Properties 注入值  
![这里写图片描述][70 15]

（3）对于域属性的自动注入

*  对于域属性的注入，也可不在配置文件中显示的注入。可以通过为bean标签设置autowire 属性值，为域属性进行隐式自动注入。根据自动注入判断标准的不同，可以分为两种：  
    byName：根据名称自动注入  
    byType：根据类型自动注入
    
    1，byName 方式自动注入：当配置文件中被调用者 Bean 的 id 值与代码中调用者 Bean 类的属性名相同时，可使用byName 方式，让容器自动将被调用者 Bean 注入给调用者 Bean。容器是通过调用者的 Bean类的属性名与配置文件的被调用者 bean 的 id 进行比较而实现自动注入的。  
    2，byType 方式自动注入：使用 byType 方式自动注入，要求：配置文件中被调用者 bean 的 class 属性指定的类，要与代码中调用者 Bean 类的某域属性类型同源。即要么相同，要么有 is-a 关系（子类，或是实现类）。但这样的同源的被调用 bean 只能有一个。多于一个，容器就不知该匹配哪一个了。

（4）为应用指定多个 Spring 配置文件

*  将配置文件分解为地位平等的多个配置文件，并将所有配置文件的路径定义为一个String 数组，将其作为容器初始化参数出现。其将与可变参的容器构造器匹配。

1，平等关系的配置文件  
\* 将配置文件分解为地位平等的多个配置文件，并将所有配置文件的路径定义为一个String 数组，将其作为容器初始化参数出现。其将与可变参的容器构造器匹配。  
![这里写图片描述][70 16]

2，包含关系的配置文件  
\* 各配置文件中有一个总文件，总配置文件将各其它子文件通过引入。在 Java代码中只需要使用总配置文件对容器进行初始化即可。  
![这里写图片描述][70 17]

五、基于注解的DI  
[https://blog.csdn.net/king\_cannon\_fodder/article/details/80170665][https_blog.csdn.net_king_cannon_fodder_article_details_80170665]

[70]: /images/20220514/caaa2164ada94075931be60503b1d372.png
[70 1]: /images/20220514/da2ba6ed0eb143fcab7bb0d1812849ea.png
[70 2]: /images/20220514/69b872edfbf74497a8a91ef6829eeb50.png
[70 3]: /images/20220514/88f78da61af2419c94b1aa6c696818e9.png
[70 4]: /images/20220514/a6a21a88546545c8bb57483d32611747.png
[70 5]: /images/20220514/8c1b904c35164bb5b7df2f55eaf57114.png
[70 6]: /images/20220514/caa7c842eb48405c8fccbd48dbf53547.png
[70 7]: /images/20220514/60a28b393cfb44d1bb761bf84dff26a0.png
[70 8]: /images/20220514/bba56907aa004f43acfb2e114ed12092.png
[70 9]: /images/20220514/738bbd2d2ee8440ebae9df456743cc5a.png
[70 10]: /images/20220514/86c63ccf06e74fd38e26b92f0416a4e3.png
[70 11]: /images/20220514/2b276932b7b047da90f45f6dec65889f.png
[70 12]: /images/20220514/4214de87e725430780a43a919529fd73.png
[70 13]: /images/20220514/71ee6650a9944814a3af9d4db8158517.png
[70 14]: /images/20220514/4a22ecf73d9748ff9654fda6792a92ab.png
[70 15]: /images/20220514/0327be5c2a3047d4b903565d3e711d7e.png
[70 16]: /images/20220514/02e81321a8e24e4c8e07d14d0f893775.png
[70 17]: /images/20220514/e5efd3d0e52a43218f10e6015aac7d47.png
[https_blog.csdn.net_king_cannon_fodder_article_details_80170665]: https://blog.csdn.net/king_cannon_fodder/article/details/80170665