Spring:（译为春天）

是一个开源框架，Spring是于2003 年兴起的一个轻量级的 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架，主要用于降低模块之间耦合度的框架，实际上Spring除了能够通过IoC降低模块之间的耦合度外还提供了其它功能

Spring作用于Action（控制层）、Service、Dao三层。

Action层常用框架：Struts、Struts2、SpringMVC

Dao层常用框架：Mybatis、Hibernate

Spring主要特性：DI(依赖注入)和AOP(面向切面编程)

 

1.使用Spring会使我们的代码结构良好(三层架构)

2.IOC + AOP  是更好完成以下编程原则：

面向接口编程 (解耦合，易于程序扩展)

高低原则    高内聚、低耦合(相同的东西放在一起)

开闭原则    对扩展开放，对修改关闭

3.代码通用支持

IOC:Inversion of Control   控制反转

DI:dependency injection   依赖注入

容器:存放对象(bean)的一个容器，用于管理对象

容器的类型:

BeanFactory接口(IOC核心容器)：其实现类XmlBeanFactory

ApplicationContext接口(也是一个BeanFactory，只是对其进行了扩展)，其实现类以下两种较常用：

ClasspathXmlApplicationContext

FileSystemXmlApplicationContext

WebApplicationContext

Resource(io中File封装,File文件路径比较复杂)

FileSystemResource    ---资源在文件系统

ClassPathResource      ---资源在Classpath

UrlResource                 ---资源在网络上的一个位置

ByteArrayResource      ---资源在内存中

InputStreamResource  ---资源在流中

*** IOC容器主要做的事情：

1.注入(装配):(实现属性的getter和setter方法)

(1)简单值的装配：8中基本类型以及其包装类，Class(java自带的一些类),String,Resource

byte short int long float double char boolean

注入配置：(使用value属性或value标签)

<property name="属性名" value="值"/>或

<property name="属性名">

<value>值</value>

</property>

(2)其他Bean的引用：(使用ref属性或ref标签)

<property name="属性名" ref="bean的名称"/>或

<property name="属性名">

<ref bean="bean名称"/>

</property>

(3)集合类型:(数组、集合(List Set Map)、Properties)

数组：

<list>

如果为简单值

<value>值</value>

如果为其他bean

<ref bean="bean的名称"/>

</list>

List：

<list>

如果为简单值

<value>值</value>

如果为其他bean

<ref bean="bean的名称"/>

</list>

Set：

<set>

如果为简单值

<value>值</value>

如果为其他bean

<ref bean="bean的名称"/>

</set>

Map：

<map>

<entry key="简单值"  key-ref="bean名称" value="简单值" value-ref="bean名称"/>

</map>

Properties：

可以使用map装配

<properties>

<props>

<prop key="key值">value值</prop>

</props>

</properties>

2.实例化:

代码块-->实例化-->注入--->(init)-->使用--->(destory)-->从容器中移除

初始化方法和销毁方法:

<bean  init-method=""  destory-method=""/>

销毁容器： 方法都是在其实现类中

<bean id="springBean" class="ioc5.SpringBean" init-method="init" destroy-method="destory">

1.ac.destroy();    //容器主动销毁

2.ac.registerShutdownHook(); // 代码正常结束容器销毁

实例化的三种方式:

1.构造方法

a.无参

<bean id="" class="">

<property/>

</bean>

b.有参

<bean id="" class="">

<constructor-arg index="" type="">  //index  表示参数的顺序

简单值                          //type   表示参数的类型

<value>值</value>

其他Bean

<ref bean="bean名称"/>

</constructor-arg>

</bean>

2.静态工厂

a.无参

<bean id="" class="" factory-method=""></bean>

b.有参

<bean id="" class="" factory-method="">

<constructor-arg>

<value>值</value>

</constructor-arg>

</bean>

3.实例工厂(需要一个bean去创建工厂)

a.无参

<bean id="" factory-bean="工厂bean名称" factory-method="">

b.有参

<bean id="" factory-bean="工厂bean名称" factory-method="">

<constructor-arg>

<value></value>

</constructor-arg>

</bean>

 ***容器实例化的时机：

① BeanFactory(容器，实现类XmlBeanFactory)

创建容器不会将容器中配置的实例初始化，在使用的时候进行初始化(懒初始化)

② ApplicationContext容器

是①的扩展，默认在创建容器时将容器中配置的实例进行初始化.(即使初始化)

若要某一个bean想采用懒初始化<bean  lazy-init="true"/>

如果想让配置文件中的所有的bean都是懒初始化<beans default-lazy-init="true">

 ***实例的域：

ioc容器中实例默认的域为单例.scope="singleton"

如果想使用多例：scope="prototype"

另外还有以下两种在web工程中（基于WebApplicationContext）有效，不常用。

scope="session"

scope="request"

PS:如果配置为多例，实例不会被放入容器，那么destroy调用不到.

继承:

抽象出继承配置父配置

<bean id="parentBean" abstract="true"/>表示spring不会初始化该bean

子bean引用父bean

<bean parent="parentBean"/>

****自动装配:(autowire)

<bean autowire=""/>

autowire值:

default或no:  不会自动装配

byName(set方法的名称):    

1.setter方法的名称在IOC容器中必须可以找到一个Bean对象    

2.setter方法参数类型需要和找到的bean的类型一致

byType(set方法的参数类型):

1.setter方法参数的类型需要在IOC容器中找到一个bean的类型和其一致  

2.有且只能找到一个   

constructor(byName和byType的结合):

只要有一个可以装配，就可以装配上（byName使用的名称是构造方法参数的名称）(byType使用的类型是构造方法参数的类型) 

*** 从bean中获取容器:

1.让你的bean实现接口ApplicationContextAware(BeanFactoryAware);

2.将你的bean配置到IOC容器中。

spring-core.jar

org.springframework.util 工具类

StringUtils

CollectionUtils

ReflectionUtils

StreamUtils

Assert

获取Resource的两种方式:

1.获取方式：

直接创建Resource实现类

2.获取方式：

如果存在IOC容器

如果文件classpath    ac.getResource("classpath:文件路径")

如果文件文件系统中    ac.getResource("file:文件路径")

Resouce的装配:

1. 使用简单值装配（value属性或value标签）

2. classpath:文件路径

3. file:文件路径

FactoryBean:

1.配置Bean起来比较复杂，反而没有写代码简单.

2.在很多和其他框架整合时候，会使用到它。

实现:

1.实现接口FactoryBean

getObject           对象的创建过程

getObjectType   返回对象的类型

isSingleton         对象是否为单例的

2.需要将该FactoryBean配置到IOC容器中

<bean id="bean名称" class=""/>

如果ac.getBean("bean名称")  获取的对象为getObject返回的类型

如果ac.getBean("&bean名称") 获取的为FactoryBean的本身

后处理器:

代码块-->实例化-->注入--->(beforInit)--->(init)-->(afterInit)--->使用--->(destory)-->从容器中移除

接口:BeanPostProcessor(bean的后处理器)

BeanFactory的后处理器:实现接口BeanFactoryPostProcessor(主要用途:转换类型(字符串<==>类),读取properties文件)

postProcessBeanFactory()-->代码块-->实例化-->注入--->(beforInit)---> (init)-->(afterInit)--->使用--->(destory)-->从容器中移除

总结：IOC（控制反转）和DI（依赖注入）的关系：

1. IOC: 控制反转，把对象创建交给spring进行配置

在采用面向对象方法设计的软件系统中，底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。即软件系统中对象之间的耦合，对象A和对象B之间有关联，对象B又和对象C有依赖关系，这样对象和对象之间有着复杂的依赖关系，控制反转因此产生。

1. 软件系统在没有引入IoC容器之前，对象A依赖对象B，那么A对象在实例化或者运行到某一点的时候，自己必须主动创建对象B或者使用已经创建好的对象B，其中不管是创建还是使用已创建的对象B，控制权都在我们自己手上。

2. 如果软件系统引入了Ioc容器之后，对象A和对象B之间失去了直接联系，所以，当对象A实例化和运行时，如果需要对象B的话，IoC容器会主动创建一个对象B注入到对象A所需要的地方。

3. 通过前面的对比，可以看到对象A获得依赖对象B的过程，由主动行为变成了被动行为，即把创建对象交给了IoC容器处理，控制权颠倒过来，这就是控制反转。

2. DI: 依赖注入，向类里面的属性中设置值

上边介绍了通过配置文件，有三种方法可以实现对象的创建，那么如何向对象的属性中设置值呢？这就需要用到注入的方法。属性注入的方式介绍（三种方式）：

1. 使用set方法注入

2. 使用有参数构造注入

3. 使用接口注入

3. 关系：依赖注入不能单独存在，需要在ioc基础之上完成操作