Spring4（一）IOC和DI

1、Spring简介

• Spring 是一个开源框架 .

• Spring 为简化企业级应用开发而生 ， 使用 Spring 可以使简单的 JavaBean 实现以前只有 EJB 才能实现的功能 。

        •Spring 是一个 IOC(DI) 和 AOP 容器框架

• 具体描述 Spring:

– 轻量级 ： Spring 是非侵入性 的 - 基于 Spring 开发的应用中的对象可以不依赖于 Spring 的 API

– 依赖注入 (DI --- dependency injection 、 IOC)

– 面向切面编程 (AOP --- aspect oriented programming)

– 容器 ：Spring 是一个容器 ， 因为它包含并且管理应用对象的生命周期

– 框架 ：Spring 实现了使用简单的组件配置组合成一个复杂的应用 ， 在 Spring 中可以使用 XML 和 Java 注解组合 这些 对象；

– 一站 式 ：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 （实际上 Spring 自身也提供了展现层的 SpringMVC 和 持久层的 Spring JDBC ）

 

Spring的模块：

 

2、Eclipse安装Spring插件

Eclipse工具想要更好更快的开发Spring，需要安装一个插件：SPRING TOOL SUITE ，利用该插件可以更方便的在 Eclipse 平台上开发基于 Spring 的应用。

• 安装 方法说明 （ springsource-tool-suite-3.4.0.RELEASE-e4.3.1-updatesite.zip ） ：

– Help --> Install New Software...

– Click Add...

– In dialog Add Site dialog, click Archive...

– Navigate to springsource-tool-suite-3.4.0.RELEASE-e4.3.1-updatesite.zip  and click   Open

– Clicking OK in the Add Site dialog will bring you back to the dialog 'Install'

– Select the xxx/Spring IDE that has appeared

– Click Next  and then Finish

– Approve the license

– Restart eclipse when that is asked

本次我使用的是InteliJ IDEA2019版作为开发工具，所以跳过了上述插件安装。

 

3、入门程序HelloWorld

3.1 环境准备

1、新建一个普通的Java工程：

File——》new ——》Project——》Java——》JavaEE，然后一路next知道完成。

2、引入依赖的jar包

本次需要用到的jar包：spring-core-4.0.0.RELEASE.jar，spring-beans-4.0.0.RELEASE.jar，spring-context-4.0.0.RELEASE.jar，spring-expression-4.0.0.RELEASE.jar和commons-logging-1.1.1.jar。

我们首先要把这几个包放到同一个目录下面，然后在IDEA中操作：

File——》Project Structure...——》Libraries——》点击+号，选择Java——》然后选择我们刚才存放jar包的目录即可。

我们就可以在工程的 External Libraries下面看到我们刚才引的jar包的目录，里面有我们需要的jar包了。

3、创建资源文件夹
在工程的根目录下面，创建一个conf的资源文件夹，用来存放一些Spring的配置文件，以及其他配置文件（比如日志文件）。

右键工程名——》new——》Directory——》文件名称为：conf

右键conf目录——》Mark Directory as——》Resources Root，那么这个conf就变成了资源目录了。

在conf目录下面创建一个spring目录，用来存放Spring的主配置文件：applicationContext.xml
 

3.2 代码实现

3.2.1 创建HelloWorld

在src下面创建包：com.spring.beans，然后创建HelloWorld：

package com.spring.beans;

public class HelloWorld {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public void sayHello(){
        System.out.println("Hello  "+name);
    }
}

3.2.2 配置文件applicationContext.xml

在conf/spring下面创建applicationContext.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

    <!--告诉Spring去创建一个变量为helloWorld的对象-->
    <bean id="helloWorld" class="com.spring.beans.HelloWorld">
        <!--调用HelloWorld的setName方法给name属性赋值-->
        <!--这两个操作都在Spring初始化的时候进行-->
        <property name="name" value="Spring"></property>
    </bean>

</beans>

3.2.3 测试

package com.spring.test;

import com.spring.beans.HelloWorld;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    public static void main(String[] args) {
        //通过配置文件创建Spring的IOC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring/applicationContext.xml");
        //从IOC容器中，得到helloWorld对象
        HelloWorld helloWorld = (HelloWorld) ctx.getBean("helloWorld");
        helloWorld.sayHello();//调用方法
    }
}

打印结果：Hello  Spring

通过入门程序，我们发现，之前我们需要创建对象，给对象的属性赋值，现在的这些操作都是Spring帮我们做了，在通过配置文件创建Spring容器的时候，就会初始化配置文件里面所有的实例对象，并且赋值。这就是SPring的IOC和DI。

 

4、Spring中Bean的配置

4.1 IOC和DI概述

• IOC(Inversion of Control ) ：其 思想是 反转资源获取的方向 ， 传统的资源查找方式要求组件向容器发起请求查找资源 ， 作为回应 ， 容器适时的返回资源 。 而应用了 IOC 之后 ， 则是 容器主动地将资源推送给它所管理的组件 ， 组件所要做的仅是选择一种合适的方式来接受资源 ， 这种行为也被称为查找的被动形式

 

• DI(Dependency Injection) — IOC 的另一种表述方式：即 组件以一些预先定义好的方式 ( 例如 : setter 方法 ) 接受来自如容器的 资源 注入 。 相对于 IOC 而言，这种表述更直接

 

以前我们要创建一个对象，都是通过new 来获取，而现在，只要在配置文件配置了类全名，Spring就会通过发射帮我们把这个对象创建出来，存储到IOC容器中，到时候我们直接从容器里面取，其实这就是IOC；

同样，以前的时候，对象里面的属性赋值，需要提高set方法，我们手动的调用set方法给对象属性赋值，但是现在IOC容器可以把我们需要的值按照配置信息，自动注入到我们的对象中。这就是DI。

4.2 Bean配置概述

• 配置 bean

– 配置形式 ：基于 XML 文件的 方式 ；基于 注解的 方式

– Bean 的配置 方式：通过全类名（反射） 、通过工厂方法（静态工厂方法 & 实例工厂方法）、 FactoryBean

– IOC 容器 BeanFactory & ApplicationContext 概述

– 依赖注入的方式：属性注入；构造器注入

– 注入属性值细节

– 自动装配

– b ean 之间的关系：继承；依赖

– bean 的作用域： singleton（单例） ； prototype ； WEB 环境作用域

– 使用外部属性文件

– spEL

– IOC 容器中 Bean 的生命周期

– Spring 4.x 新特性：泛 型依赖注入

 

4.3 Spring容器

• 在 Spring IOC 容器 读取 Bean 配置创建 Bean 实例之前 , 必须对它进行实例化， 只有在容器实例化后 , 才可以从 IOC 容器里获取 Bean 实例并使用。

• Spring 提供了两种类型的 IOC 容器实现：

– BeanFactory ：IOC 容器的基本实现；

– ApplicationContext ： 提供了更多的高级特性 ， 是 BeanFactory 的子接口；

– BeanFactory 是 Spring 框架的基础设施，面向 Spring 本身； ApplicationContext 面向使用 Spring 框架的开发者， 几乎所有的应用场合都直接使用 ApplicationContext 而非底层的 BeanFactory。

– 无论 使用何种方式 ,， 配置文件时相同的。

4.3.1 ApplicationContext

• ApplicationContext 的主要实现类：

– ClassPathXmlApplicationContext ： 从 类路径下 加载配置文件

– FileSystemXmlApplicationContext ： 从文件系统中加载 配置文件

• ConfigurableApplicationContext 扩展于 ApplicationContext ，新增加两个主要方法： refresh() 和 close() ， 让 ApplicationContext 具有启动、刷新和关闭上下文的 能力

• ApplicationContext 在初始化上下文时就实例化所有单例的 Bean 。

• WebApplicationContext 是专门为 WEB 应用而准备的，它允许从相对于 WEB 根目录的路径中完成初始化工作

 

4.4 依赖注入

Spring支持3中注入方式：

      属性注入（settre方法）；

      构造器注入；

      工厂方法注入（很少用，不推荐）。

4.4.1 属性注入

• 属性注入即通过 setter 方法 注入 Bean 的属性值或依赖的对象

• 属性注入 使用 <property> 元素 ， 使用 name 属性指定 Bean 的属性 名称， value 属性或 <value> 子节点指定属性值

• 属性 注入是实际应用中最常用的注入方式

<!--告诉Spring去创建一个变量为helloWorld的对象-->
    <bean id="helloWorld" class="com.spring.beans.HelloWorld">
        <!--调用HelloWorld的setName方法给name属性赋值-->
        <!--这两个操作都在Spring初始化的时候进行-->
        <property name="name" value="Spring"></property>
    </bean>

4.4.2 构造器注入

• 通过构造方法注入 Bean 的属性值或依赖的 对象，它保证了 Bean 实例在实例化后就可以使用。

• 构造器注入在 <constructor- arg > 元素里声明属性 , < constructor- arg > 中没有 name 属性

 

• 按索引匹配入参：

• 按类型匹配入参：

4.5 不同类型的值的注入 

4.5.1 字面值

• 字面 值：可用字符串表示的值，可以通过 <value> 元素标签或 value 属性进行注入。

• 基本 数据类型及其封装类、 String 等类型都可以采取字面值注入的方式。

• 若字面值中包含特殊字符，可以使用 <![CDATA[]]> 把字面值包裹起来。

4.5.2 引入其他Bean

• 组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能 . 要 使 Bean 能够相互访问 , 就必须在 Bean 配置文件中指定对 Bean 的引用

• 在 Bean 的配置文件中 , 可以 通过 <ref> 元素或 ref  属性 为 Bean 的属性或构造器参数指定对 Bean 的引用

• 也可以 在属性或构造器里包含 Bean 的声明 , 这样的 Bean 称为 内部 Bean

<!-- 声明使用内部 bean -->
	<bean id="service2" class="com.atguigu.spring.ref.Service">
		<property name="dao">
			<!-- 内部 bean, 类似于匿名内部类对象. 不能被外部的 bean 来引用, 也没有必要设置 id 属性 -->
			<bean class="com.atguigu.spring.ref.Dao">
				<property name="dataSource" value="c3p0"></property>
			</bean>
		</property>
	</bean>

4.5.3 集合属性注入 

• 在 Spring 中 可以通过一组内置的 xml 标签 ( 例如 : <list>, <set> 或 <map>) 来配置集合属性 .

• 配置 java.util.List 类型的属性 ， 需要 指定 < list>   标签 ， 在标签里包含一些元素 。 这些标签可以通过 <value> 指定简单的常量值 ， 通过 <ref> 指定对其他 Bean 的引用 。 通过 <bean> 指定内置 Bean 定义 ， 通过 < null / > 指定空元素 ， 甚至可以内嵌其他集合 。

• 数组的定义和 List 一样 , 都使用 <list>

• 配置 java.util.Set 需要使用 <set> 标签 ， 定义元素的方法与 List 一样 。

• Java.util.Map 通过 <map> 标签定义 ， <map> 标签里可以使用多个 <entry> 作为子标签 ， 每个条目包含一个键和一个值 .

• 必须在 <key> 标签里定义键

• 因为键和值的类型没有限制 ， 所以可以自由地为它们指定 <value>, <ref>, <bean> 或 <null> 元素 .

• 可以将 Map 的键和值作为 <entry> 的属性定义 : 简单常量使用 key 和 value 来定义 ; Bean 引用通过 key-ref 和 value-ref 属性定义

• 使用 <props> 定义 java.util.Properties ， 该标签使用多个 <prop> 作为子标签 。 每个 <prop> 标签必须定义 key 属性 。

• 使用基本的集合标签定义集合时 , 不能将集合作为独立的 Bean 定义 , 导致其他 Bean 无法引用该集合 , 所以无法在不同 Bean 之间共享集合， 可以使用 util schema 里的集合标签定义独立的集合 Bean. 需要注意的是 , 必须在 <beans> 根元素里添加 util schema 定义

<!-- 声明集合类型的 bean -->
	<util:list id="cars">
		<ref bean="car"/>
		<ref bean="car2"/>
	</util:list>
	
	<bean id="user2" class="com.atguigu.spring.helloworld.User">
		<property name="userName" value="Rose"></property>
		<!-- 引用外部声明的 list -->
		<property name="cars" ref="cars"></property>
	</bean>

4.6 XML 配置里的 Bean 自动装配

• Spring IOC 容器 可以自动 装配 Bean。 需要做的仅仅是 在 <bean> 的 autowire 属性里指定自动装配的模式

• byType ( 根据类型自动装配 )： 若 IOC 容器中有多个与目标 Bean 类型一致的 Bean， 在这种情况下 ，Spring 将无法判定哪个 Bean 最合适该属性 ， 所以不能执行自动装配 。

• byName ( 根据名称自动装配 )： 必须将目标 Bean 的名称和属性名设置的完全相同 。

• constructor( 通过构造器自动装配 )： 当 Bean 中存在多个构造器时 , 此种自动装配方式将会很复杂 . 不推荐 使用

 

缺点：

• 在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配 Bean 的所有属性 。 然而 ， 若只希望装配个别属性时 ， autowire 属性就不够灵活了 。

• autowire 属性 要么根据类型自动装配 ， 要么根据名称自动装配 ， 不能两者兼而有之 。

• 一般情况下，在实际的项目中很少使用自动装配功能，因为和自动装配功能所带来的好处比起来，明确清晰的配置文档更有说服力一些

 

4.7 Spring Bean的作用域

• 在 Spring 中 , 可以在 <bean> 元素的 scope 属性里设置 Bean 的作用域 。

• 默认 情况下 , Spring 只为每个在 IOC 容器里声明的 Bean 创建唯一一 个实例 , 整个 IOC 容器范围内都能共享该 实例 ： 所有 后续的 getBean () 调用和 Bean 引用都将返回这个唯一的 Bean 实例 ， 该作用域被称为 singleton ， 它是所有 Bean 的默认作用域 。

prototype：原型的， 每次调用 getBean 方法都会返回一个新的 bean. 且在第一次调用 getBean 方法时才创建实例
singleton：单例的， 每次调用 getBean 方法都会返回同一个 bean. 且在 IOC 容器初始化时即创建 bean 的实例. 默认值

4.8 使用外部配置文件

• 在 配置文件里配置 Bean 时 , 有时需要在 Bean 的配置里混入 系统部署的细节信息 ( 例如 : 文件路径 , 数据源配置信息等 ). 而这些部署细节实际上需要和 Bean 配置相分离

• Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器 ， 这个处理器允许用户将 Bean 配置的部分内容外移到 属性文件 中 。 可以在 Bean 配置文件里使用形式为 ${ var } 的变量 ， PropertyPlaceholderConfigurer 从属性文件里加载属性 ， 并使用这些属性来替换变量 .

• Spring 还允许在属性文件中使用 ${ propName } ，以实现属性之间的相互引用。

需要到context命名空间，在配置文件中引入如下配置：

<!-- 导入外部的资源文件 -->
	<context:property-placeholder location="classpath:db.properties"/>
	
	<!-- 配置数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="user" value="${jdbc.user}"></property>
		<property name="password" value="${jdbc.password}"></property>
		<property name="driverClass" value="${jdbc.driverClass}"></property>
		<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
		
		<property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>
		<property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
	</bean>

外部文件配置：db.properties

jdbc.user=root
jdbc.password=1230
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///test

jdbc.initPoolSize=5
jdbc.maxPoolSize=10

 

4.9 Spring表达式语言：SPEL

• Spring 表达式 语言 （简称 SpEL ）：是 一个 支持运行时查询和操作对象图的强大的表达式语言 。

• 语法类似于 EL ： SpEL 使用 # {…} 作为定界符，所有在大框号中的字符都将被认为是 SpEL

• SpEL 为 bean 的属性进行动态赋值提供了便利

• 通过 SpEL 可以实现：

– 通过 bean 的 id 对 bean 进行 引用

– 调用 方法以及引用对象中的属性

– 计算 表达式的值

– 正则表达式 的 匹配

<!-- 测试 SpEL: 可以为属性进行动态的赋值(了解) -->
	<bean id="girl" class="com.atguigu.spring.helloworld.User">
		<property name="userName" value="周迅"></property>
	</bean>
	
	<bean id="boy" class="com.atguigu.spring.helloworld.User" init-method="init" destroy-method="destroy">
		<property name="userName" value="高胜远"></property>
		<property name="wifeName" value="#{girl.userName}"></property>
	</bean>

 

4.10 Spring Bean的生命周期

• Spring IOC 容器可以管理 Bean 的生命周期 ，Spring 允许在 Bean 生命周期的特定点执行定制的任务 。

• Spring IOC 容器对 Bean 的生命周期进行管理的过程 ：

– 通过构造器或工厂方法创建 Bean 实例

– 为 Bean 的属性设置值和对其他 Bean 的引用

– 调用 Bean 的初始化方法

– Bean 可以使用了

– 当容器关闭时 , 调用 Bean 的销毁 方法

        在 Bean 的声明里设置 init-method 和 destroy-method 属性， 为 Bean 指定初始化和销毁方法

4.10.1 创建 Bean 后置处理器

• Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理。

• Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理 ， 而非单一实例 . 其典型应用是 ： 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性

• 对 Bean 后置处理器而言 ，需要实现   org.springframework.beans.factory.config.BeanPostProcessor 接口 。 在初始化方法被调用前后 ，Spring 将把每个 Bean 实例分别传递给上述接口的以下两个方法 :

@Override
//bean：Bean实例本身
//beanName：IOC容器配置的bean的名字
//返回值：是实际上返回给用户的那个bean，注意：可以在下面的两个方法中修改返回的bean，甚至返回一个新的bean。
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }

添加 Bean 后置处理器后 Bean 的生命周期：

• Spring IOC 容器对 Bean 的生命周期进行管理的过程：

– 通过构造器或工厂方法创建 Bean 实例

– 为 Bean 的属性设置值和对其他 Bean 的引用

– 将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法

– 调用 Bean 的初始化方法（init-method）

– 将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization 方法

– Bean 可以使用了

– 当容器关闭时 , 调用 Bean 的销毁方法(destory-method)

 

后置处理器的配置：

<!-- 配置 bean 后置处理器: 不需要配置 id 属性, IOC 容器会识别到他是一个 bean 后置处理器, 并调用其方法 -->
	<bean class="com.atguigu.spring.ref.MyBeanPostProcessor"></bean>

 

4.11 实现 FactoryBean 接口在 Spring IOC 容器中配置 Bean

• Spring 中有两种类型的 Bean， 一种是普通 Bean， 另一种是工厂 Bean， 即 FactoryBean .

• 工厂 Bean 跟普通 Bean 不同 ， 其返回的对象不是指定类的一个实例 ， 其返回的是该工厂 Bean 的 getObject 方法所返回的对象。

package org.springframework.beans.factory;

public interface FactoryBean<T> {
    T getObject() throws Exception;

    Class<?> getObjectType();

    boolean isSingleton();
}

 

5、Spring注解使用

5.1 基于注解的方式配置Bean

• 组件扫描 (component scanning)：Spring 能够 从 classpath 下自动扫描 , 侦测和实例化具有特定注解的组件 .

• 特定组件包括 :

– @Component: 基本注解 , 标识了一个受 Spring 管理的组件

– @ Respository : 标识持久层组件

– @Service: 标识服务层 ( 业务层 ) 组件

– @Controller: 标识表现层 组件

• 对于扫描到的组件 , Spring 有默认的命名策略 : 使用非限定类名 , 第一个字母小写 . 也可以 在注解中通过 value 属性值标识组件的名称

 

• 当在组件类上使用了特定的注解之后 , 还需要在 Spring 的配置文件中 声明 < context:component-scan > ：

– base-package 属性指定一个需要扫描的基类包 ， Spring 容器将会扫描这个基类包里及其子包中的所有类 .

– 当需要扫描多个包时 , 可以使用逗号分隔。

– 如果仅希望扫描特定的类而非基包下的所有类，可使用 resource-pattern 属性过滤特定的类，示例：

<!-- 配置自动扫描的包: 需要加入 aop 对应的 jar 包 -->
	<context:component-scan base-package="com.atguigu.spring.annotation"
		resource-pattern="repository/*.class"
	></context:component-scan>

–<context:include-filter> 子节点表示要包含的目标类

– < context:exclude-filter > 子节点表示 要排除在外的 目标 类

– < context:component-scan > 下可以拥有若干个 < context:include-filter > 和 < context:exclude-filter > 子节点

 

• < context:include-filter > 和 < context:exclude-filter > 子 节点支持多种类型的过滤表达式：

5.2 注解来进行组件装配

<context:component-scan> 元素还会自动注册 AutowiredAnnotationBeanPostProcessor （Bean的后置处理器）实例, 该实例可以自动装配具有 @Autowired 和 @Resource 、@Inject注解的属性

5.2.1 @Autowired 自动装配 Bean

@ Autowired 注解自动装配 具有兼容类型 的单个 Bean 属性

– 构造器 , 普通字段 ( 即使是非 public), 一切具有参数的方法都可以应用 @ Authwired 注解

– 默认 情况下 , 所有使用 @ Authwired 注解的属性都需要被设置 . 当 Spring 找不到匹配的 Bean 装配属性时 , 会抛出异常 , 若某一属性允许不被设置 , 可以设置 @ Authwired 注解的 required 属性为 false

– 默认 情况下 , 当 IOC 容器里存在多个类型兼容的 Bean 时 , 通过类型的自动装配将无法工作 . 此时可以在 @Qualifier 注解里提供 Bean 的名称 . Spring 允许对方法的入参标注 @ Qualifiter 已指定注入 Bean 的名称

– @ Authwired 注解也可以应用在 数组类型 的属性上 , 此时 Spring 将会把所有匹配的 Bean 进行自动装配 .

– @ Authwired 注解也可以应用在 集合属性 上 , 此时 Spring 读取该集合的类型信息 , 然后自动装配所有与之兼容的 Bean.

– @ Authwired 注解用 在 java.util.Map 上时 , 若该 Map 的键值为 String, 那么 Spring 将自动装配与之 Map 值类型兼容的 Bean, 此时 Bean 的名称作为键值

 

5.2.2 @Resource 或 @Inject 自动装配 Bean

• Spring 还支持 @Resource 和 @Inject 注解，这两个注解和 @ Autowired 注解的功用类似

• @Resource 注解要求提供一个 Bean 名称的属性，若该属性为空，则自动采用标注处的变量或方法名作为 Bean 的名称

• @Inject 和 @ Autowired 注解 一样也是按类型匹配注入的 Bean ， 但没有 reqired 属性

• 建议使用 @ Autowired 注解