Spring之IOC&DI/装配Bean(一)

简介

今天学习Spring的第一天，无非也就是入门基础知识。主要了解IOC和DI部分，要熟练掌握哦~

Spring简介

1. Spring介绍
	Spring是一个非常活跃的开源框架；它是一个基于Core来构架多层JavaEE系统的框架,它的主要目地是简化企业开发.
	Spring以一种非侵入式的方式来管理你的代码，Spring提倡”最少侵入”，这也就意味着你可以适当的时候安装或卸载Spring 

2. Spring框架的优势
	•方便解耦，简化开发
	•Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理
	AOP编程的支持
	•Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
	声明式事务的支持
	•只需要通过配置就可以完成对事务的管理，而无需手动编程
	方便程序的测试
	•Spring对Junit4支持，可以通过注解方便的测试Spring程序
	方便集成各种优秀框架
	•Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持
	降低JavaEE API的使用难度
	•Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低

3. Spring模块介绍
	Spring 框架是一个分层架构,,它包含一系列的功能要素并被分为大约20个模块。这些模块分为Core Container、Data Access/Integration、Web、AOP（Aspect Oriented Programming)、Instrumentation和测试部分

Spring开发准备

1. 准备Jar包
	dist\spring.jar	--spring的核心类库 在spring文档的dist下 
	lib\jakarta-commons\commons-logging.jar	--引入的第三方类库 都spring文档的lib下
	lib/aspectj/aspectjweaver.jar和aspectjrt.jar	--如果使用了切面编程(AOP),还需要下列jar文件 
	lib/cglib/cglib-nodep-2.1_3.jar
	如果使用了JSR-250中的注解,如@Resource/@PostConstruct/@PreDestroy,还需要下列jar文件 
	lib\j2ee\common-annotations.jar
2. Spring配置文件
	默认情况下是applicationContext.xml
	在beans.xml中引入约束的文件
	<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.xsd">
	</bean>
	beans.xml中不能显示对应的提示：此时xsd的文件没有被加载到myeclipse中.在beans包spring-beans-3.0xsd
	ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

 

Spring基本功能详解

1. 控制反转(IOC)
    Spring的控制反转：把对象的创建、初始化、销毁等工作交给spring容器来做。由spring容器控制对象的生命周期
    获取IOC容器的对象
        1). 启动spring容器
            在类路径下寻找配置文件来实例化容器 
                ApplicationContext ctx = new ClassPathXmlApplicationContext("");
        2). 从spring容器中提取对象
            ctx.getBeans("userService");
2. Spring配置别名
    <bean name="person" class="cn.itcast.aliasspring.Person"/>
    <alias name="person" alias="p"/>
3. 模拟spring底层：IOC和DI原理
    * IOC（控制反转）是利用java的反射思想实现的
    * DI（依赖注入）是利用java的内省机制实现
4. spring容器中bean节点id和name的区别
    区别1: 
        id指定唯一实例引用
        name可以指定多个实例引用
    区别2:
        id: 命名规范要满足xml对id属性命名规范
        name: 如果bean的名称含有特殊字符,就需要使用name属性
    备注：如果spring当前版本是3.0时候，id是有命名规范区别，
    如果当前版本是3.2可以 通用
    id和name不能出现重名
5. 加载spring容器的3种方式
    方式1:
        在类路径下寻找配置文件实例化容器
        ClassPathXmlApplicationContext
        可以一次性加载多个配置文件
    方式2:
        在文件系统下寻找配置文件
        FileSystemXmlApplicationContext
    方式3:
        BeanFactory ac = new XmlBeanFactory(new FileSystemResource("D:\\beans.xml"));
    ApplicationContext是对BeanFactory扩展，提供了更多功能
        国际化处理
        事件传递
        Bean自动装配
        各种不同应用层的Context实现

装配Bean

1. 三种实例化bean的方式
	1). 使用接口和类，直接在spring容器中创建一个类，使用接口进行操作
		<bean id="userService" class="cn.itcast.c_class.UserServiceImpl"></bean>
	2). 使用静态工厂方法实例化(简单工厂模式)
		<bean id="userObject" class="cn.itcast.d_staticMethod.UserObject" factory-method="createUser">
	3). 使用实例工厂方法实例化(工厂方法模式)
		<bean id="userObject" class="cn.itcast.e_method.UserObject"></bean>
		<bean id="user" factory-bean="userObject" factory-method="createUser"></bean>
		
2. bean 的作用域
	在spring容器中存在scope的属性
	1). singleton(单例：默认值) 表示创建UserServiceImpl对象，容器只创建一次
		* lazy-init属性（只针对单例有效）
	2). prototype （多例）
		表示每次加载ac.getBean("userService");都会执行UserServiceImpl的构造方法，容器此时可以创建多个对象。	注意：用途：如果通过spring创建struts的Action实例的时候，就必须指定prototype类型，因为struts2是多实例多线程，否则struts2的值栈会出现问题
	3). Request
		在依次Http请求中，一个bean定义对应一个实例，该作用域在Spring ApplicationContext情形下有效
	4). Session
		在意一个HttpSession中，一个bean定义对应一个实例
	5). Global session
3. 初始化bean时机
	Spring默认在启动时将所有singletonbean提前进行实例化。提前实例化意味着作为初始化的一部分，ApplicationContext会自动创建并配置所有的singleton bean.通常情况下这是件好事。因为这样在配置中有任何错误能立即发现。
		Lazy-init=”true or  false”
		Lazy-init 为false,spring容器将在启动的时候报错（比较好的一种方式）
		Lazy-init 为true,spring容器将在调用该类的时候出错
4. init、destroy
	Spring初始化bean或销毁bean时，有时需要作一些处理工作，因此spring可以在创建和拆卸bean的时候调用bean的两个生命周期方法
	  <bean id=“foo” class=“...Foo”
            init-method=“setup”
            destory-method=“teardown”/>
5. 创建bean的生命周期			
	**1.instantiate bean对象实例化
	2.populate properties 封装属性
	3.如果Bean实现BeanNameAware 执行 setBeanName
	4.如果Bean实现BeanFactoryAware 或者 ApplicationContextAware 设置工厂 setBeanFactory 或者上下文对象 setApplicationContext
	5.如果存在类实现 BeanPostProcessor（后处理Bean） ，执行如果Bean实现InitializingBean 执行 afterPropertiesSet 
	接口 BeanPostProcessor 后处理Bean 提供两个钩子函数，用于开发者 动态去修改Bean对象  （动态代理）
	6.如果bean实现InitializingBean，执行afterPropertiesSet()初始化
	7.调用<bean init-method=“userInitMethod"> 指定初始化方法 userInitMethod
	8.如果存在类实现 BeanPostProcessor（处理Bean） ，执行postProcessAfterInitialization
	**9.执行业务处理，即用户自定义的业务操作
	10.如果Bean实现 DisposableBean 执行 destroy（适用单例）
	11.调用<bean destroy-method=“userDestroyMethod"> 指定销毁方法 userDestroyMethod（适用单例）

 

依赖注入(DI)

1. 依赖注入（DI）
	所谓依赖注入就是指：在运行期，由外部容器动态地将依赖对象注入到另一个对象的组件中
	<bean id="boy" class="cn.itcast.b_di.Boy"></bean>
	<bean id="girl" class="cn.itcast.b_di.Girl">
		<!-- 
			将spring容器中创建的boy对象传递给Girl对象中的set方法
		    * name:在Girl对象中的set方法的属性名称
		    * ref：将容器创建的对象注入到set方法中
		 -->
		<property name="boy" ref="boy"></property>
	</bean>
2. 依赖注入（DI）
	1).  通过setter方法注入依赖
		<bean>元素的<property>子元素指明了使用它们的set方法来注入。可以注入任何东西，从基本类型到集合类，甚至是应用系统的bean
		a. 使用p命名空间
			为了简化XML文件配置，Spring从2.5开始引入一个新的p名称空间
			p:<属性名>="xxx" 引入常量值
			p:<属性名>_ref="xxx" 引用其它Bean对象
		b. 装配各种类型实现
			List: <property name="lists"><list>
			数组: <property name="obj"><list>
			Set: <property name="sets"><set>
			Map: <property name="maps"><map><entry key=""><value>	--需要注意的是key值必须是String
			Properties: <property name="props"><props>
			List(null): <property name="listnull"><null/>
	2). 通过构造器函数
		a. 通过参数
			<constructor-arg index="0">
				  <value>张三</value>
			</constructor-arg>
		b. 通过参数的类型
			<constructor-arg type="java.lang.Integer">
				   <value>56</value>
			</constructor-arg>
		c. 两者结合一起使用
			<constructor-arg type="java.lang.Integer" index="0">
				   <value>56</value>
			</constructor-arg>
	3). bean之间继承关系
		<bean id="person" class="" abstract="true"></bean>
		<bean id="student" parent="person">
			<property name="name" value="tom"></property>
		</bean>
	4). 依赖
		依赖，一个类内部运行依赖另一个Bean初始化一些数据
	5). 配置多个XML文件（spring容器）
		方式一 可以在创建ApplicationContext对象时传入多个配置文件
			ApplicationContext applicationContext = new 
			ClassPathXmlApplicationContext("beans1.xml", "beans2.xml");
		方式二 (一般采用)可以在配置文件中通过<import>引入其他配置文件
			<import resource="classpath:bean2.xml"/>
	6). 注解配置：使用@autowired和@Qualifier
		a. 引入context命名空间
			 xmlns:context="http://www.springframework.org/schema/context"
				   http://www.springframework.org/schema/context
				   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
		b. 在配置文件中添加context:annotation-config标签
		c. 使用注解@autowired标注在属性上
			Autowired标注在字段上	  
			@Autowired注解默认按类型进行装配
				获取该注解标注的字段的类型---PersonDao类型
				以该类型为条件到spring容器(beans.xml)中去查找bean的id节点的类型是PersonDao类型.
				找到以后,获取该节点对应的对象,利用反射直接为personDao变量赋值 
			@Qualifier(“personDao”)该注解以名字为条件查找依赖对象
				以该注解的的参数personDao条件到spring容器(beans.xml)中去查找bean的id节点的值是personDao的对象
				找到以后,获取该节点对应的对象, 利用反射直接为personDao变量赋值，如果不存在该名称,抛出异常
		d. 使用注解@autowired标注在set方法上
			Autowired标注在setter方法上	  
				 @Autowired注解默认按类型进行装配
				  *  获取 setPersonDao()方法的参数的类型---PersonDao类型
				  *  以该类型为条件到spring容器(beans.xml)中去查找bean的id节点的类型是PersonDao类型.
				  * 找到以后,获取该节点对应的对象, 把该对象作为实参传递给该setPersonDao(
			PersonDao personDao)的形参.
			@Qualifier("personDao")该注解以名字为条件查找依赖对象
				  *  以该注解的的参数personDao条件到spring容器(beans.xml)中去查找bean的id节点的值是PersonDao的对象
				  *  找到以后,获取该节点对应的对象, 把该对象作为实参传递给该setPersonDao(
			PersonDao personDao)的形参.
				  * 如果不存在该名称,抛出异常
		7). 使用@Resource
			esource注解标注在字段上	  
			* @Resource注解默认按名称装配。
			* 如果没有指定name属性
				 *  获取该注解标注的字段值---personDao
				 *  以该字段值为条件到spring容器(beans.xml)中去查找bean的id节点的值是 personDao的节点
				 * 找到以后,获取该节点对应的对象, 利用反射直接为personDao变量赋值
				 * 如果没有找到.并且按照默认的名称找不到依赖对象时, @Resource注解会回退到按类型装配
				 * 获取该注解标注的字段类型--PersonDao
				 * 以该类型为条件到spring容器(beans.xml)中去查找bean的节点的类型是PersonDao类型的对象
				 * 找到以后,获取该节点对应的对象,利用反射直接为personDao变量赋值
		   * 如果指定name属性，只能按名称装配
				 *  获取name属性的值 personDao
				 *  以该值为条件到spring容器(beans.xml)中去查找bean的id节点的值是PersonDao的对象
				 * 找到以后,获取该节点对应的对象, 利用反射直接为personDao变量赋值
				 * 如果不存在该名称,抛出异常
		8). 使用classpath自动扫描把组件纳入spring容器中管理
			作用：在开发时对项目的每一层进行划分
			Spring3.0为我们引入了组件自动扫描机制，它可以在类路径底下寻找标注了@Component、@Service、@Controller、@Repository注解的类，并把这些类纳入进spring容器中管理
			a. 引入context命名空间
			b. 在配置文件中添加
				<context:component-scan base-package="cn.itcast"/>