Spring系列__02IOC简介

时间 2019-11-30

原文原文链接

Spring的两大核心功能就是IoC和AOP，这篇文章主要介绍IoC。简单来讲，在面向对象思想下，A类中有一个B类的属性，那么咱们在建立A类时每每须要同时建立一个B类的对象，以便A类对其进行调用。可是，这样的后果即是，A类和B类的耦合度太高。而所谓的IoC（控制反转），其核心是DI，旨在提供一种更简单的机制来设置组件依赖项（一般称为对象的协做者），并在整个生命周期中管理这些依赖项。IoC一般能够分为两种子类型：依赖注入和依赖查找。java

依赖注入和依赖查找的介绍

依赖查找是一种更传统的方法，有两种类型：

依赖拉取（dependency pull，DL）在依赖拉取中，根据须要从注册表中提取依赖项，在IoC中，每每是使用JNDI查找来获取依赖项。
上下文依赖查找（contextualized dependency lookup, ontextualized dependency lookup, CDL）上下文查找和依赖拉取有些类似，可是不一样之处就是，查找是针对管理资源的容器执行的，而不是来自某个中央注册表。当容器准备将依赖传递给组件时，会依次调用每一个组件的performLookup()方法，而后，组件可使用Contaioner接口来查找所须要的依赖项。

依赖注入是目前被普遍采用的新方案，也有两种常见的风格

构造函数当在组件的构造函数中提供依赖项的时候，就会发生构造函数依赖注入。首先，组件声明一个或者一组构造函数，并将其做为依赖项做为参数；而后在组件实例化的时候有IoC容器将依赖项传递给组件。以下代码所演示：

public class ConstuctorInjecttion {
    private Dependency dependency;
    public ConstructorInjection(Dependency dependency) {
        this.dependency = dependency;
    }
}
复制代码

构造函数注入属于强制性的依赖注入，若是没有依赖项的时候，就不能建立对象；所以，必须有依赖项。
复制代码

setter方法注入在setter依赖注入中，IoC容器经过使用JavaBean样式的setter方法注入组件的依赖项。组件的setter方法公开了IOC容器能够管理的依赖项。示例以下：

public class SetterInjection {
    private Dependency dependency;
    
    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
    } 
}
复制代码

Setter注入属于可选依赖注入，能够在没有依赖项的状况下建立对象（调用默认的无参构造器）, 而后经过调用setter方法来提供依赖项。
复制代码

查找和注入的比较总结

- 查找：
1.依赖拉取代码必须主动得到对注册表的依赖选项；
2.难以独立于容器进行测试。
- 注入:
1.对代码没有任何影响；
2.能够独立于容器进行测试。
3.开发更加自由。
复制代码

setter注入和构造器注入比较总结

- 构造器注入：当对依赖项的依赖关系为强制依赖的时候，推荐使用这种方式，经过调用对应的带参数构造器来完成依赖的注入。
- setter方法注入：最简单的注入方式。当对依赖项的依赖关系为可选的时候，推荐使用这种方式。经过反射调用无参构造器来实例后，再调用对应的setter方法。这种方式的最大的好处就是：侵入性最小。
复制代码

Spring中的控制反转

对于控制反转，Spring的实现核心是基于依赖注入，而Spring的依赖注入的核心是BeanFactory接口。BeanFactory负责管理组件，包括依赖项以及他们的生命周期。可是，在实际的使用中，Beanfactory的使用并非不少，一般使用其扩展：ApplicationContext，其是BeanFactory的子接口。后面会有详细介绍。
复制代码

1.bean的配置

1.配置形式：

有三种配置形式，可是一般说两种：xml文件和注解，(有些书籍上说第三种是自动装配)。本文中主要介绍xml形式进行bean的配置。程序员

2.配置方式：

bean的配置方式有三种：spring

经过反射的方式进行配置：该方式会经过反射机制调用无参构造器来建立对象实例，可是，如果没有无参构造器，则会抛出异常。

<!--
        bean的配置方式1：经过全类名方式（反射）
        id：IOC容器中惟一存在，若不指定会默认使用全类名
    -->
    <bean id="car" class="com.spring.demo.bean.Car">
 <!--
复制代码

经过工厂方法(静态工厂、实例工厂): 该方法会运用了工厂模式的思想，经过调用静态工厂、实例工厂的方法来建立bean的实例。

<!--
       bean的配置方式2：经过静态工厂方法
       id 属性：指定 bean 的 id，用于从容器中获取
       class 属性：指定静态工厂的全限定类名
       factory-method 属性：指定生产对象的静态方法
    -->
        <bean id="carByFactory" class="com.spring.demo.bean.StaticFactory"
              factory-method="getCarBean">

        </bean>


    <!--
         bean的配置方式2：经过实例工厂方法
        此种方式是：先把工厂的建立交给 spring 来管理，而后在使用工厂的 bean 来调用里面的方法
        factory-bean 属性：用于指定实例工厂 bean 的 id。
        factory-method 属性：用于指定实例工厂中建立对象的方法。
  -->
        <bean id="instanceFactory" class="com.spring.demo.bean.InstanceFactory"></bean>
        <bean id="carByInstance" class="com.spring.demo.bean.Car" factory-bean="instanceFactory"
              factory-method="getCarByInstance">
            <property name="brand" value="大众"/>
        </bean>
复制代码

经过Spring提供的FactoryBean进行配置（使用较少，暂不介绍）。

3.依赖注入的方式：属性注入、构造器注入

依赖注入： Dependency Injection。它是 spring 框架核心 ioc 的具体实现。咱们的程序在编写时，经过控制反转，把对象的建立交给了 spring，可是代码中不可能出现没有依赖的状况。IoC 解耦只是下降他们的依赖关系，但不会消除。例如：咱们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 Spring 以后，就让 Spring 来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用咱们本身去获取。依赖注入的方式主要有两种:数组

属性注入就是调用setter方法进行属性注入，;
构造器注入方式是调用重载的带参构造器。说到这里，能够来一些代码了：

<!--
        依赖注入方式1：属性注入，属性注入是经过setter方法注入bean的属性值或者依赖的对象。
        也是实际应用中最经常使用的方式。
        name指定属性值，value或者value节点指定属性值，ref指定依赖的对象
    -->
        <property name="company" value="大众"/>
        <property name="brand" value="宝来"/>
        <property name="price" value="200000.00"/>
        <property name="maxSpeed" value="200"/>
    </bean>

    <!--
       依赖注入方式2：构造器注入
       经过构造方法注入属性，可以保证bean在实例化后就能使用
       没有name属性，默认按照构造器的变量顺序加载，也能够经过index或者type进行限制
       index:指定参数在构造函数参数列表的索引位置
       type:指定参数在构造函数中的数据类型
   -->
    <!--
       若一个 bean 有多个构造器, 如何经过构造器来为 bean 的属性赋值
       能够根据 index 和 value 进行更加精确的定位. (了解)
       也能够经过name来具体制定属性名进行绑定
       若字面值中包含特殊字符, 则可使用 DCDATA 来进行赋值. (了解)
       使用构造器方式注入属性值时，可使用type或index来区别重载构造器
   -->
    <bean id="car1" class="com.spring.demo.bean.Car">
        <constructor-arg value="宝马" type="java.lang.String"/>
        <constructor-arg value="mini" type="java.lang.String"/>
        <constructor-arg value="200000.00" type="double"/>
        <constructor-arg value="240" type="int"/>
    </bean>
    <!--
        依赖注入方式3：工厂方法注入
        由于这种方法比较少使用，这里只是写一下注释，没有demo
     -->
复制代码

4.IOC容器BeanFactory和ApplicationContext简介

BeanFactory是Spirng框架的基础设施，面向Spring自己；ApplicationContext是BeanFactory的子接口，面向Spring框架的应用者，其提供了更多的功能。 ApplicationContext具备两个只要的实现类：ClasspathXmlApplicationContext和FileSystemXmlApplicationContext；前者经过在类路径下加载配置文件来完成bean的装配，后者从文件系统下加载配置文件。项目结构以下所示： ![](img2018.cnblogs.com/blog/163258…bash

BeanFactory 和 ApplicationContext 的区别：建立对象的时间点不同。

ApplicationContext：只要一读取配置文件，默认状况下就会建立对象。
BeanFactory：什么使用何时建立对象。

ApplicationContext 接口的实现类

ClassPathXmlApplicationContext：它是从类的根路径下加载配置文件推荐使用这种
FileSystemXmlApplicationContext：它是从磁盘路径上加载配置文件，配置文件能够在磁盘的任意位置。
AnnotationConfigApplicationContext：当咱们使用注解配置容器对象时，须要使用此类来建立 spring 容器。它用来读取注解。在这里，则能够进行测试了：

@Test
    public void teStetter() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-ioc.xml");
        Car car = (Car) context.getBean("car");
        System.out.println(car);
    }
复制代码

5.字面值

字面值能够用value标签或者value属性进行注入。基本类型及其包装类、String等都是采用字面值的方式进行注入。当具备特殊字符的时候，须要特殊处理：session

<!--
        value简介：
            基本类型及其包装类、String均可以经过value标签或者value属性注入，
            当字面值包含特殊字符的时候，可用<![CDATA[]]>包含
     -->
    <bean id="car2" class="com.spring.demo.bean.Car">
        <property name="company" value="大众"/>
        <property name="brand">
            <value><![CDATA[<DZ宝来>]]></value>
        </property>
        <property name="maxSpeed" value="200"/>
        <property name="price" value="200000.00"/>
    </bean>
复制代码

spring中某一属性不进行显式声明时，其会采用默认值，固然你能够显式的注入null：适应null标签同时，spring支持级联属性的注入。框架

6.引用其余bean

当须要引用其余的bean时(A类引用B类)，能够经过ref标签或者ref属性进行注入。其用法和value相似。泣别：value注入的是字面值，ref注入的是一个引用。固然，内部bean的注入也是这种方式。示例以下：函数

<!--
        引入其余bean：
            例如person有car属性，须要引入,这是就不是使用value属性了，
            而是使用ref指定须要引入的bean
            也能够声明一个内部bean，此时内部bean就无需再指定id了，道理和内部类类似
    -->
    <bean id="person" class="com.spring.demo.bean.Person">
        <property name="name" value="丽丽"/>
        <property name="age" value="23"/>
        <property name="car" ref="car"/>
    </bean>

    <!-- innerBean -->
    <bean id="person1" class="com.spring.demo.bean.Person">
        <property name="name" value="丽丽"/>
        <property name="age" value="23"/>
        <property name="car">
            <bean class="com.spring.demo.bean.Car">
                <property name="brand" value="BMW"/>
                <property name="company" value="BMW"/>
                <property name="maxSpeed" value="233"/>
                <property name="price" value="233333.33"/>
            </bean>
        </property>
    </bean>
复制代码

7.集合属性

在Spring中能够经过xml标签配置集合属性：测试

1.list和数组

配置java.util.LIst和数组类型时，能够经过标签来配置，list中的属性可使用value标签或者ref标签。可使用utility scheme来单独定义集合，这样的好处就是方便其余bean进行引用。ui

2.set

set的状况和list类似，使用set标签，用法和list标签同样。

<!--
        集合属性:
            list标签：数组和list数据使用这个标签，
            set标签：set数据使用，使用方法同list标签
    -->
    <bean id="stu" class="com.spring.demo.bean.Student">
        <property name="name" value="苏大强"/>
        <property name="age" value="60"/>
        <property name="cars">
            <list>
                <ref bean="car"/>
                <ref bean="car1"/>
                <ref bean="car2"/>
                <ref bean="car3"/>
            </list>
        </property>
    </bean>

    <!--
        也能够单独定义list，而后直接绑定
    -->
    <util:list id="carList">
        <ref bean="car"/>
        <ref bean="car1"/>
        <ref bean="car2"/>
        <ref bean="car3"/>
    </util:list>

    <bean id="stu1" class="com.spring.demo.bean.Student">
        <property name="name" value="苏大强"/>
        <property name="age" value="60"/>
        <property name="cars" ref="carList"/>
    </bean>
复制代码

3.map和properties

java.util.Map能够经过map标签进行指定，map标签中有多个entity子标签，每一个entity定义一对键值对。在entity中能够经过key属性或者key标签来指定键，同理可使用value、ref、bean、null属性或者标签指定值。

<!--
        map:
            map的使用可list类似，使用entry标签来保存每一对键值对，
            同时可使用key属性或者key标签来存储key，
            value值或value属性绑定普通的字面值，ref绑定其余bean做为值
    -->
    <bean id="teacher" class="com.spring.demo.bean.Teacher">
        <property name="name" value="张莉"/>
        <property name="age" value="24"/>
        <property name="carMap">
            <map>
                <entry key="car" value-ref="car"/>
                <entry key="car1" value-ref="car1"/>
                <entry key="car2" value-ref="car2"/>
                <entry key="car3" value-ref="car3"/>
            </map>
        </property>
    </bean>
复制代码

props标签用来定义java.util.Properties，该标签有子标签prop，具体使用方法与map同样。

8.p命名空间

Spring2.5以后支持p命名空间，能够简化xml配置，属性与原来的配置同样：

<!--
        spring2.5以后，可使用p命名空间来简化属性配置,须要在配置文件中引入p命名空间
       xmlns:p="http://www.springframework.org/schema/p"
    -->
    <bean id="car4" class="com.spring.demo.bean.Car" p:brand="宝马" p:company="宝马"
          p:price="2000000.00" p:maxSpeed="200"/>
复制代码

8.Java配置

前面的例子都是经过xml文件进行bean的配置，如今来示范一下经过Java配置方式来配置。

@Configuration   //该注解表示这个类是一个配置类，其做用至关于配置文件。
public class CarConfigure {
    @Bean    //该注解表示会向容器中配置一个bean，其value属性是设置bean的id，
                    //没有的话默认使用方法名做为id，bean的类型就是返回值类型
    public Car carByAnnotation() {
        return new Car();
    }
}
复制代码

9.autowire

Spring的IOC容器能够经过自动装配来配置bean，使用方式就是使用autowire属性，有两种模式：byName和byType。 byName会在Spring容器中根据名字取寻找匹配的bean，没有的话就没法完成装配； byType会在Spring容器中按照类型来查找并进行bean的配置，可是当找到多个符合条件的类型的bean时会报异常，不过能够经过primary属性或注解来制定bean的优先级，可是当你设置了多个同一类型的bean的primary属性为true的时候失效；这个时候，能够借助@Qualifier注解来加以限制。

<!-- 自动装配: 只声明 bean, 而把 bean 之间的关系交给 IOC 容器来完成 -->
    <!--
        byType: 根据类型进行自动装配. 但要求 IOC 容器中只有一个类型对应的 bean, 如有多个则没法完成自动装配.
        byName: 若属性名和某一个 bean 的 id 名一致, 便可完成自动装配. 若没有 id 一致的, 则没法完成自动装配
    -->
    <!-- 在使用 XML 配置时, 自动转配用的很少. 但在基于 注解 的配置时, 自动装配使用的较多.  -->
    <bean id="car" class="com.spring.demo.bean.Car">
        <property name="company" value="大众"/>
        <property name="brand" value="宝来"/>
        <property name="price" value="200000.00"/>
        <property name="maxSpeed" value="200"/>
    </bean>

    <bean id="person" class="com.spring.demo.bean.Person" autowire="byName">
        <property name="name" value="James"/>
        <property name="age" value="23"/>
        <property name="car" ref="carSub"/>
    </bean>

   <!-- <bean id="person1" class="com.spring.demo.bean.Person" autowire="byType">
        <property name="name" value="James"/>
        <property name="age" value="23"/>
    </bean>-->

    <!--
        自动装配的缺点：
            1.autowire默认会为bean装配所有属性，因此当你只想装配部分属性时显得不够灵活；
            2.byName和byType两种模式只能选择一个，不能兼有。
            
    -->

 @Test
    public void testByName() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-autowire.xml");
        Person person = (Person) context.getBean("person");
        System.out.println(person);
    }

    @Test
    public void testByType() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-autowire.xml");
        Person person = (Person) context.getBean("person1");
        System.out.println(person);
    }
复制代码

10.bean的继承与依赖

做为一个Java程序员，确定会接触到继承。Spring中也提供了bean的继承，思想和面向对象的继承的思想类似。区别在于Spring中的bean的继承是指bean的配置能够被继承(复用)。

<!--
        bean的继承：
            你能够定义一个bean并有其余bean继承，这样作的好处是能减小配置
            父bean的配置会由子bean继承，固然部分属性除外(autowire，abstract)
            子bean能够从新赋值一些属性，进行bean从新定义
            父bean能够定义为abstract，定义为abstract的bean只能被继承，不能被注册（实例化）
            父bean能够不定义class属性，由子类本身定义
            子bean须要经过parent属性指定你继承的父bean
    -->
    <bean id="carSup" class="com.spring.demo.bean.Car" p:company="宝马" p:brand="mini"
          p:maxSpeed="270" p:price="300000.00" abstract="true"/>

    <bean id="carSub" parent="carSup"/>

 @Test
    public void testInherit() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-autowire.xml");
        Car car = (Car) context.getBean("carSub");
        System.out.println(car);
    }
复制代码

在本文的开头，咱们引入了A类和B类，当你想建立A类时，而A类又必须有B类的变量时，即可以使用依赖来解决这件事：

<!--
        bean的依赖：
            你能够声明当前bean依赖于哪些bean，这样当前bean初始化以前会去初始化依赖的bean，
            若是没有注册致使没法初始化便会报错
            依赖多个bean的时候，可使用逗号或者空格分开
    -->
    <bean id="person1" parent="person" depends-on="carSub"/>

 @Test
    public void testDepends() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-autowire.xml");
        Person person1 = (Person) context.getBean("person1");
        System.out.println(person1);
    }
复制代码

9.bean的做用域

Spring中的bean的做用域有如下几种： singleton， property， request，session 默认状况下，spring中每一个bean只有一个实例，可是能够显示指定。

<!--
        bean的生命周期：
            singleton：默认选项，IOC容器默认为每一个bean只实例化一个实例，该实例在调用具体的bean以前完成。
            property：原型。该方式下IOC容器会在每次调用bean的时候实例化一个新的实例，而且只有在调用时进行bean的初始化
           request和session同JavaWeb中同样，在此很少加介绍
    -->

    <bean id="dog" class="com.spring.demo.bean.Dog" p:name="haki" scope="prototype"/>

package com.spring.demo.bean;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@AllArgsConstructor
@ToString
public class Dog {
    private String name;
    public Dog() {
        super();
        System.out.println("dog's constructor");
    }
}

@Test
    public void testScope() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-autowire.xml");
        Dog dog = (Dog) context.getBean("dog");
        Dog dog1 = (Dog) context.getBean("dog");
        System.out.println(dog == dog1);
    }
复制代码

在上面的demo中，除了能够查看bean的建立个数，还应该查看bean的建立时机。