两篇 Spring 总结（一）

Spring4 概述以及 HelloWorld

概述

Spring 是一个 IOC(DI) 和 AOP 容器框架.
轻量级，Spring 是非侵入的，即使用的时候不需要实现任何接口或继承任何父类
面向切面编程（AOP）、依赖注入（DI）
容器，Spring 是一个容器，因为他包含并管理应用对象的生命周期
框架，Spring 实现了使用简单的组件配置组合成了一个复杂的应用，Spring 中使用 XML 文件和注解组合这些对象
一站式，在 IOC 和 AOP 的基础上可以整合各种企业应用的开源和优秀的第三方类库

Spring HelloWorld

搭建 Spring 开发环境
- 新建一个 Spring 项目，加入 Spring jar 包，以及其依赖包（commons-logging）

开发 HelloWorld

新建一个 HelloWorld 类

  public class HelloWorld {
  
      private String name;
  
      public void setName(String name) {
          System.out.println("setName: " + name);
          this.name = name;
      }
  
      public void print() {
          System.out.println("Hello " + name);
      }
  
      public HelloWorld() {
          System.out.println("HelloWorld's Construct");
      }
  }

Spring 配置文件中配置 HelloWorld Bean

  <bean id="helloWorld" class="com.spring.mysefl.first.test.HelloWorld">
      <property name="name" value="bgZyy"/>
  </bean>

Test 类中调用 HelloWorld 的 print() 方法

Spring 之前，我们使用 new 关键字去创建对应的对象进而调用对象对应的方法

  public static void main(String[] args) {
      HelloWorld helloWorld = new HelloWorld();
      helloWorld.setName("bgZyy");
  }

Spring 中，我们从 Spring 的 IOC 容器中获得配置好的 Bean，进而调用其对应的方法，不再需要使用 new 关键字

  public static void main(String[] args) {
  //        创建 Spring 的 IOC 容器，这一步会创建好对应的对象以及为对应的属性赋值
          ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  //        根据配置文件获取对应的 bean
          HelloWorld helloWorld = (HelloWorld) applicationContext.getBean("helloWorld");
          helloWorld.print();
  }

使用 Spring 容器的运行结果
- 如下图，使用 Spring 执行，其 IOC 容器首先会初始化构造器，然后对配置的属性进行赋值。
这个就是 Spring 的 HelloWorld，接下来对其进行一步步解读

Spring 中 Bean 的配置

IOC 和 DI
- IOC，其思想就是反转资源获取的方向，传统的资源查找方式要求组件向容器发起请求查找资源，容器返回相应的资源，而 IOC 之后则是容器主动将资源推送给它所管理的组件，组件所要做的就是选择一种合适的方式接受资源（Inversion of Control）
- DI，IOC 的另一种表述方式，即组件以一些预先定义好的方式（如 setXxx 方法）接受来自如容器的资源注入
SpringIOC 容器中配置 Bean
- SpringIOC 容器
  - 是什么？
    - 在 Spring IOC 容器读取 Bean 配置创建 Bean 实例之前，必须对它进行实例化，只有实例化后才可以从 IOC 容器里获取 Bean 实例并使用
  - 怎么用？
    - BeanFactory, IOC 容器的基本实现
    - ApplicationContext, 提供了更多的高级特性. 是 BeanFactory 的子接口
    - BeanFactory 是 Spring 框架的基础设施，面向 Spring 本身；ApplicationContext 面向使用 Spring 框架的开发者，几乎所有的应用场合都直接使用 ApplicationContext 而非底层的 BeanFactory
    - 无论使用何种方式, 配置文件时相同的
- ApplicationContext 介绍
  - 主要实现类
    - ClassPathXmlApplicationContext，从类路径下加载配置文件
    - FileSystemXmlApplicationContext，从文件系统中加载配置文件
    - ApplicationContext 在初始化上下文时就实例化所有单例的 Bean
- Spring 配置文件中使用 <bean/> 节点配置 Bean
- 依赖注入（DI）的方式
  - 属性注入
    - 属性注入即通过 setXxx 方法注入 Bean 的属性值或依赖的对象，属性注入使用 <property> 元素，其 name 属性指定 Bean 的属性名称，value 属性或 <value> 子节点指定属性的值
  - 构造器注入
    - 通过构造方法注入 Bean 的属性值或依赖的对象，他保证了 Bean 实例在实例化后就可以使用；构造器注入在 <constructor-arg> 元素里声明属性，该节点有 type（参数的类型）和 index（参数的位置）属性用来区分不同的构造器
  - 工厂方法注入（不推荐）
- 属性值注入细节
  - 字面值
    - 字面值：可用字符串表示的值，可以通过元素标签或 value 属性进行注入；
    - 基本数据类型及其封装类、String 等类型都可以采取字面值注入的方式；
    - 若字面值中包含特殊字符，可以使用把字面值包裹起来。
  - 内部 Bean 引用其他 Bean
    - 组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能. 要使 Bean 能够相互访问, 就必须在 Bean 配置文件中指定对 Bean 的引用
    - 在 Bean 的配置文件中, 可以通过 <ref> 元素或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用.
    - 还可以在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为内部 Bean
  - 集合属性
    - 在 Spring中可以通过一组内置的 xml 标签(例如: <list>, <set> 或 <map>) 来配置集合属性.
    - 配置 java.util.Set 需要使用 <set> 标签, 定义元素的方法与 List 一样.
    - Java.util.Map 通过 <map> 标签定义, <map> 标签里可以使用多个 <entry> 作为子标签. 每个条目包含一个键和一个值.
    - 必须在 <key> 标签里定义键
    - 可以使用 util 命名空间的 util:list 节点将集合独立出来，供所有的 Bean 调用
- 使用 p 命名空间
  - 为了简化 XML 文件的配置，越来越多的 XML 文件采用属性而非子元素配置信息。
  - Spring 从 2.5 版本开始引入了一个新的 p 命名空间，可以通过 <bean> 元素属性的方式配置 Bean 的属性

Bean 的自动装配、继承和作用域

概述

Bean 的自动装配
- Spring IOC 容器可以自动装配 Bean. 需要做的仅仅是在 <bean> 的 autowire 属性里指定自动装配的模式
- byType(根据类型自动装配): 若 IOC 容器中有多个与目标 Bean 类型一致的 Bean. 在这种情况下, Spring 将无法判定哪个 Bean 最合适该属性, 所以不能执行自动装配.
- byName(根据名称自动装配): 必须将目标 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 节点中采用 scope 属性指定 Bean 的作用域；
- 默认值为 singleton，即 IOC 容器里只创建唯一一个实例，整个 IOC 容器都会共享该实例，那么后续的获取的该 Bean 为同一个,且在创建 IOC 容器的时候便会创建好对应的实例
- 还可以取值 Prptotype 那么在创建 IOC 容器的时候并不会创建对应的实例，且每次获取的时候 IOC容器才会去创建，且每次都不一样。

使用外部属性文件

在配置文件中配置 Bean 时，需要在 Bean 的配置里混入系统部署细节的信息，例如数据库连接信息，这些部署细节需要和 Bean 配置分离；
Spring 提供了 BeanFactory 后置处理器，允许用户将 Bean 配置的部分内容移到属性文件中，可以在 Bean 配置文件中使用 ${var} 形式的变量；在配置文件中使用 <context:property-placeholder location=classpath:xxx>****引入外部配置文件，使用 ${user} 等引入变量
这里再贴出对数据源的可用性测试代码

Bean 的生命周期和后置处理器

Bean 的声明周期

SpringIOC 容器可以管理 Bean 的生命周期，Spring 允许在 Bean 生命周期的特特定点执行定制的任务；
Spring IOC 容器对 Bean 的生命周期进行管理的过程:
- 通过构造器或工厂方法创建 Bean 实例（执行构造器）
- 为 Bean 的属性设置值和对其他 Bean 的引用（setXxx）
- 调用 Bean 的初始化方法（init）
- Bean 可以使用了（执行 Bean 的方法）
- 当容器关闭时, 调用 Bean 的销毁方法（destroy）
在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法.

Bean 的后置处理器

Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例，所以想要对某一 Bean 进行处理需要判断
可以检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
添加后置处理器后执行过程：
- 通过构造器或工厂方法创建 Bean 实例（构造方法）
- 为 Bean 的属性设置值和对其他 Bean 的引用（setXxx 方法）
- 将 Bean 实例传递给 Bean 后置处理器（postProcessBeforeInitialization 方法 ）
- 调用 Bean 的初始化方法（init方法）
- 将 Bean 实例传递给 Bean 后置处理器（ postProcessAfterInitialization方法）
- Bean 可以使用了（执行 Bean 的方法）
- 当容器关闭时, 调用 Bean 的销毁方法（destroy 方法）