Spring4 概述以及 HelloWorld

Spring 是什么

概述

• 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（参数的位置） 属性用来区分不同的构造器
      • 
    • 工厂方法注入（不推荐）
  • 属性值注入细节
    • 字面值
      • 字面值：可用字符串表示的值，可以通过
      • 基本数据类型及其封装类、String 等类型都可以采取字面值注入的方式；
      • 若字面值中包含特殊字符，可以使用 <[CDATA[]]> 把字面值包裹起来。
      • 
    • 内部 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} 形式的变量；在配置文件中使用 ，使用 ${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 方法）
• 

这些是本次博客的所有内容，大家发现啥问题以及任何建议欢迎提出，谢谢！