Spring（一）Spring基础知识

• 创建Spring的主要目的是用来替代更加重量级的企业级Java技术，尤其是EJB（Enterprise JavaBean 企业级JavaBean）。相对于EJB来说，Spring提供了更加轻量级和简单的编程模型。它增强了简单老式Java对象（Plain Old Java Object， POJO）的功能，使其具备了之前只有EJB和其他企业级Java规范才具有的功能。
• Spring是为了解决企业级应用开发的复杂性而创建的。为了降低Java开发的复杂性，Spring采取了以下4种关键策略：

1. 基于POJO的轻量级和最小侵入性编程
2. 通过依赖注入和面向接口实现松耦合
3. 基于切面和惯例进行声明式编程
4. 通过切面和模板减少样版式代码

• 任何一个应用都会由两个或者更多的类组成，这些类相互之间进行协作来完成特定的业务逻辑。按照传统的做法，每个对象负责管理与自己相互协作的对象（即它所依赖的对象）的引用，这将导致高度耦合和难以测试的代码。
• 依赖注入DI带来的最大收益--松耦合，如果一个对象只通过接口（而不是具体实现或初始化过程）来表明依赖关系，那么这种依赖就能够在对象本身毫不知情的情况下，用不同的具体实现进行替换。
• Spring通过应用上下文（Application Context）装载bean的定义并把它们组装起来，Spring应用上下文全权负责对象的创建和组装。
• DI能够让相互协作的软件组件保持松散耦合，而面向切面编程（AOP）允许你把遍布应用各处的功能分离出来形成可重用的组件。
• 在基于Spring的应用中，应用对象生存于Spring容器中。Spring容器负责创建对象，装配它们，配置它们并管理它们的整个生命周期。
• Spring自带了多个容器实现，可以归为两种不同的类型：

1. bean工厂（由org.springframework.beans.factory.BeanFactory接口定义）是最简单的容器，提供基本的DI支持。
2. 应用上下文（由org.springframework.context.ApplicationContext接口定义）基于BeanFactory构建，并提供应用框架级别的服务。应用上下文比bean工厂更受欢迎。

　　　　Spring常用的应用上下文：

• AnnotationConfigApplicationContext：从一个或多个基于Java的配置类中加载Spring应用上下文
• AnnotationConfigWebApplicationContext：从一个或多个基于Java的配置类中加载SpringWeb应用上下文
• ClassPathXMLApplicationContext：从类路径下的一个或多个XML配置文件中加载上下文定义，把应用上下文的定义文件作为类资源
• FileSystemXMLApplicationContext：从文件系统下的一个或多个XML配置文件中加载上下文定义
• XMLWebApplicationContext：从Web应用下的一个或多个XML配置文件中加载上下文定义

• bean的生命周期：

　　

• Spring Bean的生命周期：

　　

1. Spring对Bean进行实例化
2. Spirng将值和Bean的引用注入到Bean对应的属性中
3. 如果Bean实现了BeanNameAware接口的setBeanName方法，那么就会调用这个方法。
4. 如果Bean实现了BeanFactoryAware接口的setBeanFactory方法，那么就会调用这个方法。
5. 如果Bean实现了ApplicationContextAware接口的setApplicationContext方法，且Spring IoC容器也必须是一个ApplicationContext接口的实现类，那么才会调用这个方法。
6. 如果Bean实现了BeanPostProcessor接口的postProcessBeforeInitialization方法，那么就会调用这个方法
7. 如果Bean实现了InitializingBean接口的afterPropertiesSet方法，那么就会调用这个方法
8. 如果Bean自定义了初始化方法，即使用init-method声明了自定义的初始化方法，那么就会调用这个方法
9. 如果Bean实现了BeanPostProcessor接口的postProcessAfterInitialization方法，那么就会调用这个方法。
10. 至此，Bean就完成了初始化，Bean就生存在Spring IoC容器中，使用者就可以从中获取Bean的服务。当服务器正常关闭，或者遇到其他关闭Spring IoC容器的时间，就会完成Bean的销毁。
11. 如果Bean实现了接口DisposableBean接口的destory方法，那么就会调用这个方法。
12. 如果Bean自定义了销毁方法，即使用destroy-method声明了自定义的销毁方法，那么就会调用这个方法。

　　注意：BeanPostProcessor接口是针对所有Bean而言的，而其他接口则是针对单个Bean而言的。

　　使用示例对Spring Bean的声明周期进行演示：

1. Source类POJO　　

   package com.ssm.chapter9.pojo;
   
   public class Source {
       private String fruit;    // 类型
       private String sugar;    // 糖分描述
       private String size;    // 大小杯
       public String getFruit() {
           return fruit;
       }
       public void setFruit(String fruit) {
           this.fruit = fruit;
       }
       public String getSugar() {
           return sugar;
       }
       public void setSugar(String sugar) {
           this.sugar = sugar;
       }
       public String getSize() {
           return size;
       }
       public void setSize(String size) {
           this.size = size;
       }
   
   }

   Source类

2. JuiceMaker2类，实现了BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean接口，和自定义的初始化方法init()和销毁方法destory()，以及业务方法makeJuice()

   package com.ssm.chapter9.pojo;
   
   import org.springframework.beans.BeansException;
   import org.springframework.beans.factory.BeanFactory;
   import org.springframework.beans.factory.BeanFactoryAware;
   import org.springframework.beans.factory.BeanNameAware;
   import org.springframework.beans.factory.InitializingBean;
   import org.springframework.context.ApplicationContext;
   import org.springframework.context.ApplicationContextAware;
   
   public class JuiceMaker2 implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean {
       private String beverageShop = null;
       private Source source = null;
   
       public String getBeverageShop() {
           return beverageShop;
       }
   
       public void setBeverageShop(String beverageShop) {
           this.beverageShop = beverageShop;
       }
   
       public Source getSource() {
           return source;
       }
   
       public void setSource(Source source) {
           this.source = source;
       }
   
       public String makeJuice() {
           String juice = "这是一杯由" + beverageShop + "饮品店，提供的" + source.getSize() + source.getSugar() + source.getFruit();
           return juice;
       }
   
       public void init() {
           System.out.println("【" + this.getClass().getSimpleName() + "】执行自定义初始化方法");
       }
   
       public void destroy() {
           System.out.println("【" + this.getClass().getSimpleName() + "】执行自定义销毁方法");
       }
   
       @Override
       public void setBeanName(String arg0) {
           System.out.println("【" + this.getClass().getSimpleName() + "】调用BeanNameAware接口的setBeanName方法");
   
       }
   
       @Override
       public void setBeanFactory(BeanFactory arg0) throws BeansException {
           System.out.println("【" + this.getClass().getSimpleName() + "】调用BeanFactoryAware接口的setBeanFactory方法");
       }
   
       @Override
       public void setApplicationContext(ApplicationContext arg0) throws BeansException {
           System.out.println(
                   "【" + this.getClass().getSimpleName() + "】调用ApplicationContextAware接口的setApplicationContext方法");
       }
   
       @Override
       public void afterPropertiesSet() throws Exception {
           System.out.println("【" + this.getClass().getSimpleName() + "】调用InitializingBean接口的afterPropertiesSet方法");
       }
   }

   JuiceMaker2类

3. 实现了BeanPostProcessor接口的BeanPostProcessorImpl Bean

   package com.ssm.chapter9.bean;
   
   import org.springframework.beans.BeansException;
   import org.springframework.beans.factory.config.BeanPostProcessor;
   
   public class BeanPostProcessorImpl implements BeanPostProcessor {
   
       @Override
       public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
           System.out.println("【" + bean.getClass().getSimpleName() + "】对象" + beanName + "开始实例化");
           return bean;
       }
   
       @Override
       public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
           System.out.println("【" + bean.getClass().getSimpleName() + "】对象" + beanName + "实例化完成");
           return bean;
       }
   
   }

   BeanPostProcessorImpl

4. 实现了DisposableBean接口的DisposableBeanImpl Bean

   package com.ssm.chapter9.bean;
   
   import org.springframework.beans.factory.DisposableBean;
   
   public class DisposableBeanImpl implements DisposableBean {
   
       @Override
       public void destroy() throws Exception {
           System.out.println("调用接口DisposableBean的destroy方法");
       }
   
   }

   DisposableBeanImpl

5. Spring配置文件spring-cfg.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
   
       <!--BeanPostProcessor定义 -->
       <bean id="beanPostProcessor" class="com.ssm.chapter9.bean.BeanPostProcessorImpl" />
   
       <!--DisposableBean定义 -->
       <bean id="disposableBean" class="com.ssm.chapter9.bean.DisposableBeanImpl" />
   
       <bean id="source" class="com.ssm.chapter9.pojo.Source">
           <property name="fruit" value="橙汁" />
           <property name="sugar" value="少糖" />
           <property name="size" value="大杯" />
       </bean>
   
       <bean id="juiceMaker2" class="com.ssm.chapter9.pojo.JuiceMaker2"
           destroy-method="destroy" init-method="init">
           <property name="beverageShop" value="贡茶" />
           <property name="source" ref="source" />
       </bean>
   
   </beans>

   Spring XML配置文件

6. 测试方法

   package com.ssm.chapter9.main;
   
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   
   import com.ssm.chapter9.pojo.JuiceMaker2;
   
   public class Chapter9Main {
       public static void main(String[] args) {
           testIoC();
       }
   
       public static void testIoC() {
           ClassPathXmlApplicationContext ctx =
                   new ClassPathXmlApplicationContext("spring-cfg.xml");
           JuiceMaker2 juiceMaker2 = (JuiceMaker2) ctx.getBean("juiceMaker2");
           System.out.println(juiceMaker2.makeJuice());
           ctx.close();
       }
   }

   测试主方法

7. 测试结果

   十月 09, 2018 8:44:28 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
   信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5e8c92f4: startup date [Tue Oct 09 08:44:28 GMT+08:00 2018]; root of context hierarchy
   十月 09, 2018 8:44:28 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
   信息: Loading XML bean definitions from class path resource [spring-cfg.xml]
   【DisposableBeanImpl】对象disposableBean开始实例化
   【DisposableBeanImpl】对象disposableBean实例化完成
   【Source】对象source开始实例化
   【Source】对象source实例化完成
   【JuiceMaker2】调用BeanNameAware接口的setBeanName方法
   【JuiceMaker2】调用BeanFactoryAware接口的setBeanFactory方法
   【JuiceMaker2】调用ApplicationContextAware接口的setApplicationContext方法
   【JuiceMaker2】对象juiceMaker2开始实例化
   【JuiceMaker2】调用InitializingBean接口的afterPropertiesSet方法
   【JuiceMaker2】执行自定义初始化方法
   【JuiceMaker2】对象juiceMaker2实例化完成
   这是一杯由贡茶饮品店，提供的大杯少糖橙汁
   十月 09, 2018 8:44:28 上午 org.springframework.context.support.ClassPathXmlApplicationContext doClose
   信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@5e8c92f4: startup date [Tue Oct 09 08:44:28 GMT+08:00 2018]; root of context hierarchy
   【JuiceMaker2】执行自定义销毁方法
   调用接口DisposableBean的destroy方法

   测试结果

• Spring框架由6个定义良好的模块分类组成：