Spring框架以及Spring的IOC

1.Spring 框架简介

1.1 Sping 概述

1.1.1 Spring是什么？

Spring 是企业级JAVA生态应用中的一个开源，轻量级的软件开发框架(Framework)，是一个半成品。主要是通过对软件开发中的共性进行封装，抽象，组合等方式来简化软件开发过程，降低软件开发周期及成本。

1.1.2 Sping应用场景

Spring框架最大的优势是它的资源整合能力。通过对多种资源进行有效整合，从多个维度解决问题，来提供一套企业级软件开发的完整解决方案。例如整合连接池，JDBC，MyBatis，Hibernate，消息中间件等框架资源以更好的提高软件性能，简化应用软件开发，降低软件开发周期。

1.2 Spring 框架体系

1.2.1 Spring 框架核心架构

Spring 从2.x到5.x版本在经历着不断的变化,但其核心架构，核心组件基本不变目标仍旧就是要整合一切优秀资源,然后对外提供一个统一的服务,其具体架构(Spring 4.0)如下：

1.2.2 Spring 核心模块

Spring 中的核心模块：

1. IOC  模块(控制反转容器):对象创建,对象存储,对象依赖管理。
2. DATA 模块(整合JDBC,MyBatis,JPA,....)
3. MVC  模块(重点解决与表示层通讯问题)
4. AOP  模块(重点解决对象功能扩展问题)
5. ............

2. Spring 框架IOC模块基础

2.1 Spring IOC 简介

Spring 中有一个核心容器,这个容器我们通常称之为IOC（Inversion of Control）容器,这个容器最核心的控制反转思想的实现.它可以负责对象的创建,对象的存储(map),对象的管理(依赖查找,依赖注入)。

Spring IOC 在项目架构中的定位:

控制反转：

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

Spring IOC组件思考：

1. 核心思想（控制反转，由框架控制的对象）
2. 核心构成 (工厂，容器，注入)
3. 核心技术（反射+xml，反射+注解）

2.2 Spring IOC 编程入门实现

2.2.1 SpringIOC编程步骤分析

Spring IOC项目构建基本步骤

1. 创建maven 桌面（jar）项目(名字为XQP-SPRING-IOC)
2. 添加spring 依赖(spring-context)及配置文件(spring-configs.xml)
3. 编写并配置java类(beans.HelloService)
4. 编写单元测试初始化容器,获取java对象.

其运行结构图：

2.2.2 Spring IOC 编程实现

Spring IOC 编程实现:参考XQP-SPRING-IOC

关键代码：HelloService对象

public class HelloService {
	 public HelloService() {
		 System.out.println("HelloService()");
	 }
	 public void sayHello(){
		 System.out.println("helloworld");
	 }
}

关键配置：spring-configs.xml

<bean id="helloService"  class="beans.HelloService"s>
</bean>

说明：Spring中可以通过bean标签描述由它管理的对象

1)id属性的值为bean对象的唯一标识

2)class属性的值为类全名(包名+类名)

测试代码：

public static void main(String[] args) {
		//1.初始化spring框架容器(IOC)对象
		//1.1读取xml文件中的配置信息(xml解析)
		//1.2存储配置信息
		ClassPathXmlApplicationContext ctx=
		new ClassPathXmlApplicationContext("spring-configs.xml");
		//2.获取bean对象(例如helloService)
		//2.1何时创建的？(要看配置，是否配置了延迟加载)
		//2.2如何创建的？(通过反射技术：Class.forName("beans.HelloService"))
		//2.3此对象从哪里获取？(IOC容器->底层map)
		HelloService hService=ctx.getBean("helloService",HelloService.class);
		//3.应用bean对象(例如访问对象的方法)
		hService.sayHello();
		//4.释放资源(一般会发生在服务器关闭或重启过程中)
		ctx.close();
	}

3. Spring 框架IOC模块基本应用

3.1 Bean 对象的基本配置

在软件应用中由Spring管理的所有对象都称之为Bean.我们自己创建的类

假如需要由spring管理,首先对这个类进行配置,常用配置方式有两种,一种

基于xml进行配置,一种基于注解进行配置.本小节主要是基于xml对bean

对象进行配置.

基于xml方式对象Bean对象进行配置时,首先需要在spring的核心配置文件中使用bean标签对bean类型进行声明,借助id或name属性指定的bean的一个标识.通过class属性指定bean的具体类型(必须写全类名);

<bean id="helloService"	
            class="beans.HelloService"/>

3.2 Bean 对象的构建

Spring 中Bean对象的构建,提供了如下几种方式:

1. 直接通过构造方法
2. 通过工厂的实例方法(调用FactoryBean的getObject方法)

代码实现：通过类的构造方法，静态方法，实例及实例方法构建对象

      <!-- 直接通过类的构建方法构建对象(重点) -->
      <bean id="helloService" class="beans.HelloService"/>

说明:以上无论通过那种方式构建对象,底层都会用到反射.

通过工厂Bean构建工厂对象如何实现?（这种方式一般适合创建工厂对象）

代码实现：通过FactoryBean的getObject方法创建类的实例。

定义一个工厂对象，此类型的对象交给FactoryBean类型的对象进行实例化。

package beans;
public class ObjectFactory {

}

定义一个Bean工厂ObjectFactoryBean（要实现FactoryBean接口），此工厂要创建ObjectFactory类型对象，然后将此对象交给Spring管理。

package beans;
import org.springframework.beans.factory.FactoryBean;
/**定义一个创建工厂对象的Bean对象*/
public class ObjectFactoryBean implements FactoryBean<ObjectFactory> {
	/**
	 * 通过getObject方法创建一个工厂对象
	 * 当我们在通过Spring的getBean方法获取
	 * ObjectFactory类的实例时,首先会调用
	 * 对象的isSingleton,当此方法返回值为
	 * true时getObject方法的返回值只会执行
	 * 一次.
	 */
	public ObjectFactory getObject() throws Exception {
		System.out.println("getObject()");
		//........
		return new ObjectFactory();
	}
	/**当容器在关闭时会调用对象的isSingleton
	 * 方法判定对象是否是单例对象,假如isSingleton
	 * 方法返回值为true,此时会调用getObjectType
	 * 方法获取具体对象类型,然后底层依据类型销毁
	 * 对应的对象.
	 */
	public Class<?> getObjectType() {
		//System.out.println("getObjectType()");
		return ObjectFactory.class;
	}
	public boolean isSingleton() {
		System.out.println("isSingleton()");
		return true;
	}
}

在配置文件中配置此Bean对象

<bean id="objectFactory"
             class="beans.ObjectFactoryBean"/>

3.3 Bean 对象的作用域

在Spring容器中管理的Bean对象,可以在声明时通过scope属性或

相关注解指定其作用域,最常用是singleton,prototype.其含义如下

1. singleton (这个作用域标识的对象具备全局唯一性):系统默认
2. prototype(这个作用域标识的对象每次获取都会创建新的对象)

例如:

3.4 Bean 对象的生命周期

在Spring框架应用中,所有的的Bean对象都有生命周期,所谓Bean对象的生命周期是指Bean对象的创建,初始化,服务,销毁的这个过程.

   在spring配置文件中可以通过Init-method,destory-method属性指定bean的生命周期方法.例如:

 <bean id="helloService"
            class="beans.HelloService"
            scope="prototype"
            init-method="init"
            destroy-method="destory"/>

  在Spring应用由Spring创建的对象是否由spring销毁,还取决于Bean对象的作用域的配置.例如

1. singleton作用域的对象可以在容器关闭时销毁(会调用对象的销毁资源的方法)
2. prototype作用域的对象可以由容器创建对象,初始化对象,但不负责销毁.

3.5 Bean 对象的延迟加载

在spring框架应用,容器初始化时候,默认会构建所有由spring管理的Bean对象.但假如这些对象长时间不使用还占用着内存就会造成一定的资源浪费.为了解决这个问题,spring中提供了一种延迟加载机制.通过这种机制来提高系统资源的有效使用.

Spring中的延迟加载需要通过bean元素中lazy-init属性或beans元素的default-lazy-init="true"属性进行设置.两者应用的不同点:

1. lazy-init: 应用在bean标签中用于指定这个bean的加载策略.
2. default-lazy-init:应用在beans标签中用于指定所有bean的加载策略.

例如:

<bean id="helloService"
            class="beans.HelloService"
            scope="singleton"
            lazy-init="true"/>