SpringIOC

一，Spring

具体描述Spring：

1. 轻量级：Spring是非侵入性的。基于Spring开发的应用中的对象可以不依赖于Spring的API；
2. 依赖注入：（DI--dependency injection 、IOC）；
3. 面向切面：（AOP--aspect oriented programming）；
4. 容器：Spring是一个容器，因为它包含并且管理应用对象的生命周期；
5. 框架：Spring实现了使用简单的组件配置组合成一个复杂的应用。在Spring中可以使用XML和Java注解组合这些对象；
6. 一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方库（实际上Spring自身也提供了展现层的SpringMVC和持久层的SpringJDBC）

Spring模块

 二，Spring中的Bean配置

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

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

在Spring的IOC容器中配置Bean

在xml文件中通过bean节点来配置bean

属性：

1，id，Bean的名称

-在IOC容器中必须是唯一的

-若id没有指定，Spring自动将自动将其全类名定义为id

-id可以指定多个名字，名字之间用逗号，分号，或空格分隔

Spring容器

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

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

-ApplicationContext：提供了更多的高级特性。是BeanFactory的子接口

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

ApplicationContext

从容器中获取bean，调用ApplicationContext的getBean（）方法；

属性注入<property>

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

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

构造方法注入<constructor-arg>

第一种方式：使用节点中的name和value；

第二种方式：

因为构造器实际是一个可重载的方法，实际上可以根据顺序或类型进行区分：

-1，按索引匹配入参：

<constructor-arg value="奥迪" index="0">

-2，按照类型匹配入参

<constructor-arg value = "aodi " type="java.lang.String">

实际上索引和类型都不指定时是按参数顺序进行注入的。

字面值

字面值：可用字符串标识，可以通过通过<value>元素标签或value属性进行注入；

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

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

引用其他Bean

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

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

内部Bean

当Bean实例仅仅给的一个特定的属性使用时，可以将其声明为内部Bean，内部Bean声明直接包含在<property>或<construtor-agr>元素内;

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

    <bean id="person2" class="com.itdjx.spring.dependency.injection.Person">
        <property name="name" value="李玉"/>
        <property name="age" value="23"/>
        <property name="sex" value="女"/>
        <property name="car" >
            <bean class="com.itdjx.spring.dependency.injection.Car">
                <constructor-arg value="Ferrari" index="0"/>
                <constructor-arg value="Italy" index="1"/>
                <constructor-arg value="22500000" type="double"/>
            </bean>
        </property>
    </bean>

</beans>

null值和级联属性

可以使用专用的<null/>元素标签为Bean的字符串或其他队形类型的属性注入null值；

Spring支持计量属性的配置:

public class Car {
	private String name;
	private String address;
	private double price;
}

<!-- 引用bean -->
	<bean id="person" class="com.test.spring.beans.Person">
		<property name="name" value="zhangsan"></property>
		<property name="age" value="30"></property>
		<!-- 使用property的ref属性建立bean之间的引用关系 -->
		<property name="car" ref="car"></property>
		<!-- 为级联属性赋值，首先必须引用级联属性的类 -->
		<property name="car.price" value="35"></property>
	</bean>

集合属性

在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>标签里可以使用多个<enty>作为子标签。每个条目都包含一个键和一个值。在<key>标签里定义键；因为键和值的类型没有限制，所以可以自由地为它们指定<value>,<ref>,<bean>或者<null>元素。可以将Map地键和值作为<entry>地属性定义：简单常量使用key和value来定义；Bean引用通过key-ref和value\-ref属性定义。

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

使用utility scheme定义集合

使用基本地集合标签定义集合时，不能将集合作为独立地Bean定义，导致其他Bean无法引用该集合，所以无法在不同Bean之间共享集合。

可以使用 util schema 里面地集合标签定义独立地集合Bean。需要注意地时，必须在<beans>根元素里天机util schema定义。

<bean id="person3" class="com.itdjx.spring.dependency.injection.Person">
        <property name="name" value="李玉"/>
        <property name="age" value="23"/>
        <property name="sex" value="女"/>
        <property name="cars" ref="list"/>
    </bean>

    <util:list id="list">
        <ref bean="car"/>
        <ref bean="car2"/>
        <ref bean="car3"/>
        <ref bean="car4"/>
    </util:list>

使用p命名空间

为了简化XML文件地配置，越来越多地XML文件采用属性而非元素配置信息。

spring从2.5版本开始引入新的p命名空间，可以通过<bean>元素属性的方式配置Bean的属性。

使用p命名空间后，基于XML的配置方式将进一步简化。

自动装配：

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

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

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

-constructor（通过构造器自动装配）：当Bean中存在多个构造器时，此种自动装配方式将会很复杂。不推荐使用。

配置里的Bean自动装配的确定

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

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

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

bean之间的关系：继承，依赖

继承Bean配置

Spring允许继承bean的配置，被继承的bean称为父bean，继承这个父bean的bean称之为子bean；

子Bean从父Bean中继承配置，包括Bean的属性配置；

子Bean也可以覆盖父Bean继承过来的配置；

父Bean可以作为配置模板，也可以作为Bean实例。若只想把父Bean作为模板，可以设置<bean>的abstract属性为true，这样Spring将不会实例化这个Bean；

并不是<bean>元素的所有属性都会被继承。比如autowire，abstract等。

也可以忽略父Bean的class属性，让Bean指定自己的类，而共享相同的属性配置。但时abstract必须设置为true；

<!-- 抽象bean：bean的abstract 属性为true时，这样的bean不能被IOC容器实例化，只用于被继承配置，
          若某一个bean的class属性没有被指定，那么bean必须是一个抽象bean-->
    <bean id="address" abstract="true">
        <property name="city" value="BeiJing"></property>
        <property name="street" value="wuDaoKou"></property>
    </bean>
    
       <bean id="address1" parent="address" class="com.xia.entity.Address">
        <property name="street" value="daZhangSi"></property>
       </bean>

依赖Bean配置

Spring允许用户通过depends-on属性设定Bean前置依赖的Bean，前置依赖的Bean会在本Bean实例化之前创建好。

如果前置依赖于多个Bean，则可以通过逗号，空格的方式配置Bean的名称。

bean的作用域：singleton、prototype，web环境作用域

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

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

类型	说明
singleton	在SpringIOC容器中仅存在一个Bean实例，Bean以单实例的方式存在
prototype	每次调用getBean（）都会返回一个新的实例
request	每次Http请求都会创建一个新的Bean，该作用域仅适用于WebApplicationContext环境
session	同一个HttpSession共享一个Bean，不同的HTTP Session使用不同的Bean。该作用域仅适合WebApplicationContext环境

使用外部属性文件

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

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

使用方式：

<!-- Spring2.0 -->
<bean
    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="classpath:jdbc.properties">
</bean>
<!-- Spring2.5以后 -->
<context:property-placeholder location="classpath:db.properties">

Spring表达式：SpEL

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

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

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

通过SpEL可以实现：

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

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

-计算表达式的值

-正则表达式的匹配

SpEL：字面值

字面量的表示：

-整数：<proper name="count" value="#{5}"/>

-小数：<proper name="frequency" value="#{89.7}"/>

-科学计数法：<proper name="capacity" value="#{1e4}"/>

-String可以使用单引号或者双引号作为字符串的定界符号：

<proper name="name" value="#{'Chuck'}"/>

或<proper name=‘name’ value=‘#{“Chuck”}’/>

-Boolean：<proper name="enabled" value="#{false}"/>

SpEL：引用Bean、属性和方法

• 引用其他bean : <property name="prefix" value="#{prefixGenerator}"></property>  相当于ref
• 引用其他bean的属性： <property name="suffix" value="#{sequenceGenerator2.suffix}"/>
• 调用其他方法，还可以链式操作：

        <property name="suffix" value="#{sequenceGenerator2.toString()}">

        <property name="suffix" value= "#{sequenceGenerator2.toString().toUpperCase()}"/>

SpEL支持的运算符号

-1算术运算符：+，-，*，/，%，^

-2加号和可以用用作字符串连接

<construtor-arg value="#{performer.firstName + ' ' +performer.lastName}"/>

-3,比较运算符：<>,<,>,==,<=,>=,lt,gt,eq,le,ge

-4逻辑运算符号：and，or，not

-5if-else运算符：

<constructor-arg value="#{songSelector.selectSong=='Jingle Bell' ? "pinal":"Jingle Bells"}">

-6if-else的变体

<constructor-arg value="#{kenny.song ? : 'Greensleeves'}">

-7正则表达式

<constructor-arg

  value="#{admin.email matches '[a-zA-Z0-9.%+-]+@[a-zA-Z0-9]'}">

-8调用静态方法或静态属性：通过T()嗲用一个类的静态方法，他将返回一个Class Object，然后再调用相应的方法或属性：

<property name="initValue" value="#{T(java.lang.Math).PI}"/>

IOC容器中Bean的生命周期方法

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

Spring IOC容器对Bean的生命周期管理的过程

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

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

-调用Bean的初始化方法

-Bean可以使用了

-当容器关闭时，调用Bean的销毁方法

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

创建Bean后置处理器

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

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

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

postProcessAfterInitialization(Object bean，String beanName)在初始化之后调用

postProcessBeforeInitialization（Object bean，String beanName）；在初始化之前调用

创建后要注册到IOC中不用指定id；

添加后置处理器后

生命周期发生变化，在初始化前后分别调用方法；

通过调用静态静态工厂方法创建Bean

调用静态工厂方法创建Bean是将对象创建的过程封装到静态方法中，当哭护短需要对象时，只需要简单地调用静态方法，而不用关心创建对象地细节。

要声明通过静态方法创建地Bean，需要在bean地calss属性里指定拥有该工厂方法地类，同时在factory-method属性里指定工厂方法地名称。最后使用<constrctor-arg>为该方法传递方法参数

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

    <bean id="car" class="com.itdoc.spring.factory.StaticFactory"
          factory-method="getCar">
        <constructor-arg value="Maserati"/>
    </bean>

</beans>

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

    <bean id="carFactory" class="com.itdoc.spring.factory.InstanceFactory"></bean>

    <bean id="car2" factory-bean="carFactory" factory-method="getCar">
        <constructor-arg value="Ferrari"/>
    </bean>

</beans>

实现FactoryBean接口在SpringIoc容器中配置Bean

Spring中有两种类型中地Bean，一种时普通Bean，另一种时工厂Bean，即FactoryBean。

工厂Bean跟普通Bean突通，其返回地对象不是制定类地一个实例，其返回地时该工厂Bean的getObject方法所返回的对象；

 

基于注解的方式（配置Bean）

Spring特定的组件：

1. @Conmpont：基本注解，标识了一个受Spring管理的组件
2. @Respository：标识持久层组件
3. @Service：标识服务层（业务层）组件
4. @Controller：标识表现层组件

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

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

• base-package 属性指定一个需要扫描的基类包，Spring容器将会扫描这个基类包里以及子包中的所有类；
• 当需要扫描多个包时，可以使用逗号分隔。
• 如果仅希望扫描特定的类而非基包下的所有类，可以使用resource-pattern属性过滤特定的类，示例：

<context:component-scan
    base-package="com.atguigu.spring.beans"
    resource-pattern="autowire/*.class">

•  <context:include-filter>子节点标识要包含的目标类
• <context:exclude-filter>子节点表示要排除在外的目标类
• <context:compent-san>下可以拥有若干个<context:include-filter>和<context:exclude-filter>子节点
• <context:include-filter>和<context:exclude-filter>子节点支持多种类型的过滤表达式：

 

组件装配

<context:conponent-san> 元素还会自动注册AutowiredAnnotationBeanPostProcessor实例，该实例自已自动装配具有@Autowired和@Resource、@Inject注解的属性；

使用 @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 的名称作为键值；

使用@Resource或@Indect自动装配Bean

1. Spring 还支持 @Resource 和 @Inject 注解，这两个注解 和 @Autowired 注解的功用类似
2. @Resource 注解要求提供一个 Bean 名称的属性，若该属性为空，则自动采用标注处的变量或方法名作为 Bean 的名称
3. @Inject 和 @Autowired 注解一样也是按类型匹配注入的Bean， 但没有 reqired 属性
4. 建议使用 @Autowired 注解

​​​​​​​泛型依赖注入

Spring4.x中可以为子类注入子类对应的泛型类型的成员变量的引用；

整合多个配置文件

Spring允许通过<import>将多个配置文件引入到一个文件中，进行配置文件的集成。这样在启动Spring容器时，仅需要指定这个合并好的配置文件就可以了

inport元素的resource属性支持Spring的标准的路径资源：

​​​​​​​