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"/>
时间: 03-16

Spring之IOC&DI/装配Bean(一)的相关文章

JAVAWEB开发之Spring详解之——Spring的入门以及IOC容器装配Bean(xml和注解的方式)、Spring整合web开发、整合Junit4测试

Spring框架学习路线 Spring的IOC Spring的AOP,AspectJ Spring的事务管理,三大框架的整合 Spring框架概述 什么是Spring? Spring是分层的JavaSE/EE full-stack(一站式)轻量级开源框架. 所谓分层: SUN提供的EE的三层结构:web层.业务层.数据访问层(也称持久层,集成层). Struts2是web层基于MVC设计模式框架. Hibernate是持久的一个ORM的框架. 所谓一站式:Spring框架有对三层的每层解决方案.

Spring实战3:装配bean的进阶知识

主要内容: Environments and profiles Conditional bean declaration 处理自动装配的歧义 bean的作用域 The Spring Expression Language 在装配bean—依赖注入的本质一文中,我们探讨了Spring的三种管理bean的方式:自动装配.基于JavaConfig.基于XML文件.这篇文字将探讨一些Spring中关于bean的管理的高级知识,这些技能你可能不会每天都用,但是非常重要. 3.1 Environments

Spring框架—— IOC容器和Bean的配置

 1 IOC和DI ①IOC(Inversion of Control):反转控制. 在应用程序中的组件需要获取资源时,传统的方式是组件主动的从容器中获取所需要的资源,在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式,增加了学习成本,同时降低了开发效率. 反转控制的思想完全颠覆了应用程序组件获取资源的传统方式:反转了资源的获取方向--改由容器主动的将资源推送给需要的组件,开发人员不需要知道容器是如何创建资源对象的,只需要提供接收资源的方式即可,极大的降低了学习成本,提高了开发的效

Spring基础[IOC/DI、AOP]

一.Spring作用:管理项目中各种业务Bean(service类.Dao类.Action类),实例化类,属性赋值 二.Spring IOC(Inversion of Control )控制反转,也被称为依赖注入(Dependency Injection[DI]),是面向对象编程 中的一种设计理念,用来减轻程序代码之间的耦合度. IOC原理:侧重原理 在业务代码中不使用我们之间司空见惯的关键字new来构建一个业务实例,而是在配置文件中.通过xml节点来告知容器如何对内存中构建的对应类型的对象名称

用大白话说Spring的IOC,DI

IOC(Inverse of  Control)控制反转 Java即生活,鄙人的感悟. ---------好比我们需要租房.现在我们房源不需要找到某个具体的房东(new fangdong() 房东对象才能租他的房 fangdong.rent()).如果我们对这个房东的房源不满意,离地铁太远了.....heh.我们还需要找下个房东new下个房东.IOC容器就像个中介,他手里有很多房源.而我们只要通过这个中介第三方,就可以选到合适的房源.中介的存在减少了你和房东之间的耦合度.中介增加了你的容错性,

Spring学习总结之---装配Bean

Spring配置的可选方案 前言:Spring容器负责创建应用程序中的bean并通过DI来协调这些对象之间的关系,作为开发人员,你需要告诉Spring容器要创建那些Bean,以哪种方式创建,并且如何将这些bean装配在一起. 1.装配方式可选方案: 1-1:在XML中进行显示配置:在java中进行显示配置:隐式的bean发现机制和自动装配:可以使用互相搭配使用.备注:建议使用自动装配方式. 2.自动化装配:组件扫描(Spring会自动对发现组件类进行扫描并创建上下文bean):自动装配(Spri

Spring之IOC/DI(反转控制/依赖注入)_入门Demo

软件152 刘安民 在平时的java应用开发中,我们要实现某一个功能或者说是完成某个业务逻辑时至少需要两个或以上的对象来协作完成,在没有使用Spring的时候,每个对象在需要使用他的合作对象时,自己均要使用像new object() 这样的语法来将合作对象创建出来,这个合作对象是由自己主动创建出来的,创建合作对象的主动权在自己手上,自己需要哪个合作对象,就主动去创建,创建合作对象的主动权和创建时机是由自己把控的,而这样就会使得对象间的耦合度高了,A对象需要使用合作对象B来共同完成一件事,A要使用

&lt;Spring实战&gt;2:装配Bean

1 声明Bean 1.1 创建 Spring 配置 Spring 容器提供两种配置 Bean 的方式:xml 配置和基于注解配置. Spring 配置文件: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/

Spring 实战-第二章-装配Bean

Bean是Spring对象的声明(装配wiring),要使用Spring,必须先装配需要使用的对象,有3种装配的方式 自动化装配Bean 通过Java代码装配 通过XML装配 自动化装配Bean 自动化装配Bean很简单 1.声明接口 package soundsystem; public interface CompactDisc { void play(); } 2.添加注解 package soundsystem; import org.springframework.stereotype