第2章 Spring中的Bean教案

学习目标

掌握

Applicationcontext容器使用

属性setter方法注入的实现

了解

Bean的常用属性及其子元素

熟悉

Bean的作用域和

生命周期

2.1Bean的配置

2.1Bean的配置

什么是Spring中的Bean?

如果把Spring看做一个大型工厂，则Spring容器中的Bean就是该工厂的产品。要想使用这个工

f生产和管理Bean,就需要在配置文件中告诉它需要哪些Bean,以及需要使用何种方式将这些Bean

装配到一起。

Bean的本质就是Java中的类，而Spring中的Bean其实就是对实体类的引用，来生产Java类对

象，从而实现生产和管理Bean。

Spring容器支持两种格式的配置文件：Properties文件和XML文件

在实际开发中，最常使用的是XML文件格式的配置方式，这种配置方式是通过XML文件来注册并

管理Bean之间的依赖关系。

XML配置文件的根元素是＜beans＞,＜beans＞中包含了多个＜bean＞子元素，每一个＜bean＞子元素

定义了一个Bean,并描述了该Bean如何被装配到Spring容器中。关于＜beans＞元素的常用属性如下

表所示：

属性或子元素名称，描述。

是一个Bean的唯一标识符，Spring容器对Bean的配置、管理都通

ick

过该属性来完成。一

Spring容器同样可以通过此属性对容器中的Bean进行配置和管

name/理，name属性中可以为Bean指定多个名称，每个名称之间用逗

号或分号隔开。~

该属性指定了Bean的具体实现类，它必须是一个完整的类名，使

class*3

用类的全限定名。一

用来设定Bean实例的作用域，其属性值后：singleton（单例）、

scopesprototype（原型）、request、session、globalSession、application

和websocket0其默认值为singleton0『

在配置文件中，通常一个普通的Bean只需要定义id（或name）和class两个属性即可，定义Bean

的方式如下所示：

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns="http:〃/schema/beans”

xmlns:xsi="/2001/XMLSchema-instance"

xsi:schemaLocation="/schema/beans

/schema/beans/spring-beans.xsd">

<beanid="beanl"class="com.unknown.Beanl"/>

<beanname="bean2"class="com.unknown.Bean2"/>

</beans>

如果在Bean中未指定id和name»则Spring会将class值当作id使用。

2.2Bean的实例化

Bean的实例化有哪些方式？

在面向对象的程序中，想要使用某个对象，就需要先实例化这个对象。同样，在Spring中，要想

使用容器中的Bean,也需要实例化Bean。实例化Bean有三种方式，分别为构造器实例化、静态工厂

方式实例化和实例工厂方式实例化（其中最常用的是构造器实例化）。

2.2.1构造器实例化

构造器实例化是指Spring容器通过Bean对应的类中默认的构造函数来实例化Bean。接下来演示

构造器实例化的使用：

步骤1:在上个项目中创建一个类

packagecom.unknown.ioc;

publicclassBeanl{

)

步骤2：配置xml文件

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns="/schema/beans"

xmlns:xsi="/2001/XMLSchema-irstance"

xsi:schemaLocation="/schema/beans

/schema/beans/spring-beans.xsd">

<beanid="userDao"class="com.unknown.ioc.UserDaoImpI"/>

<beanid="userService"class="com.unknown.ioc.UserServicelmpl">

<propertyname="userDao"ref="userDao"/>

</bean>

<beanid="beanl"class="com.unknown.ioc.Beanl"/>

</beans>

步骤3：创建实例

importcom.unknown.ioc.Beanl;

importorg.springframework.context.ApplicationContext;

importorg.springframework.context.support.ClassPathXmlApplicationContext;

publicclassInstanceTestl{

publicstaticvoidmain(String[]args){

Applicationcontextapplicationcontext=

newClassPathXmlApplicationContextC'applicationContext.xmr1);

Beanlbean=(Beanl)applicationContext.getBean("beanl");

System.out.println(bean);

)

)

factory-method="createBean"/>

</beans>

步骤4:创建实例

importorg.springframework.context.ApplicationContext;

importorg.springframework.context.support.ClassPathXmlApplicationContext;

publicclasslnstanceTest2{

publicstaticvoidmain(String[]args){

Applicationcontextapplicationcontext=

newClassPathXmlApplicationContext("applicationContext.xmr,);

System.out.println(applicationContext.getBean("bean2"));

)

)

2.2.3实例工厂方式实例化

实例工厂是采用直接创建Bean实例的方式，在配置文件中，通过factory-bean属性配置一个实例

工厂，然后使用factory-method属性确定使用工厂中的哪个方法。接下来演示实例工厂实例化的使用：

步骤1:在上个项目中创建一个类

publicclassBean3{

)

步骤2：创建一个Java工厂类

packagecom.unknown.ioc;

publicclassMyBean3Factory{

publicBean3createBean(){

returnnewBean3();

步骤3：配置文件

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns="hltp:〃/schema/beans”

xmlns:xsi="http:〃/2001/XMLSchema-irstance”

xsi:schemaLocation="/schema/beans

/schema/beans/spring-becns.xsd">

<beanid="userDao"class="com.unknown.ioc.UserDaolmpl"/>

<beanid="userService"class="com.unknown.ioc.UserServicelmpl">

<propertyname="userDao"ref="userDao"/>

</bean>

<beanid="beanl"class="com.unknown.ioc.Beanl"/>

<beanid="bean2"class="com.unknown.ioc.MyBean2Factory"

factory-method="createBean'7>

<beanid="myBean3Factory"class="com.unknown.ioc.MyBean3Factory"/>

<beanid="bean3"factory-bean="myBean3Factory"factory-method="createBean"/>

</beans>

步骤4：创建实例

importorg.springframework.context.ApplicationContext;

importorg.springframework.context.support.ClassPathXmlApplicationContext;

publicclasslnstanceTest3{

publicstaticvoidmain(StringQargs){

Applicationcontextapplicationcontext=

newClassPathXmlApplicationContext("applicationContextxml")：

System.out.println(applicationContext.getBean("bean3"))；

)

)

2.3Bean的作用域

2.3.1作用域的种类

Spring4.3中为Bean的实例定义了7种作用域，如下表所示:

作用域名称。说明

使用singleton定义的Bean在Spring容器中将只有一个实例，也

singleton（单例）r就是说，无论有多少个Bean引用它，始终将指向同一个对象。这

也是Spring容器默认的作用域。一

每次通过Spring容器获取的prototype定义的Bean时，容器都将

prototype（原型）小

创建一个新的Bean实例。/

在一次HTTP请求中，容器会返回该Bean的同一个实例。对不同

request*3的HTTP请求则会产生一个新的Bean,而且该Bean仅在当前

HTTPRequest内有效。『

在一次HTTPSession中，容器会返回该Bean的同一个实例。对

session^不同的HTTP请求则会产生一个新的Bean,而且该Bean仅在当

刖HlIPSession内有效。/

在一个全局的HTTPSession中，容器会返回该Bean的同一个实

globalSession^

例,仅在使用portlet上下文时有效。~

为每个SendetContext对象创建一个实例。仅在Web相关的

applications

Applicationcontext中生效。3

为每个websocket对象创建一个实例。仅在Web相关的

websocket*3

Applicationcontext中生效。/

在上表7种作用域中，singleton和prototype是最常用的两种作用域。

2.3.2singleton作用域（默认）

singleton是Spring容器默认的作用域，当Bean的作用域为singleton时，Spring容器就只会存在

一个共享的Bean实例。singleton作用域对于无会话状态的Bean（如Dao组件、Service组件）来说,

是最理想的选择V

在Spring配置文件中，可以使用vbean>元素的scope属性，将Bean的作用域定义成singleton。

<beanid="beanl"class="com.unknown.ioc.Beanl"scope="singleton"/>

2.3.3prototype作用域

对需要保持会话状态的Bean（如Struts2的Action类）应该使用prototype作用域。在使用prototype

作用域时，Spring容器会为每个对该Bean的请求都创建一个新的实例。

在Spring配置文件中，同样使用<bean>元素的scope属性，将Bean的作用域定义成prototype。

<beanid="beanl"class="com.unknown.ioc.Beanl"scope="prototype"/>

2.4Bean的生命周期

r解Sp.iny中Bean的生命周期的意义就在丁，可以利用Bean在其存活期间的特定时刻完成些

相关操作。这种时刻可能有很多,但一般情况下，常会在Bean的postinitialion（初始化后）和predestruction

（销毁前）执行一些相关操作。

Spring容器可以管理Bean部分作用域的生命周期。有关说明具体如下：

singleton作用域:Spring容器可以管理singleton作用域的Bean的生命周期，在此作用域下，Spring

能够精确的知道该Bean何时被创建，何时初始化完成，以及何时被销毁。

prototype作用域：prototype作用域的Bean,Spring只负责创建，当容器创建了Bean实例后，

Bean的实例就交给客户端代码来管理，Spring容器将不再跟踪其生命周期。

Spring容器中Bean的生命周期流程如下图所示：

2.5Bean的装配方式

Bean的装配可以理解为依赖关系注入，Bean的装配方式即Bean依赖注入的方式。Spring容器支

持多种形式的Bean的装配方式，如基于XML的装配、基于注解（Annotation）的装配和自动装配（其

中最常用的是基于注解的装配），本节将主要讲解这三种装配方式的使用。

2.5.1基于XML的装配

基于XML的装配

（2种方式）

设值注入构造注入

(SetterInjection)(ConstructorInjection)

备

备

必

必

下

下

以

以

件

件

条

条

Bean类Bean类Bean类

必须有必须为必须提

一个无属性提供有参

参构造供setter构造方

方法方法法

______）I1

在配置工件中，使用配置文件中，”用、

〈property,元素来为每个属<constructor-arg>元素来为

性注入值参数注入值

步骤1：创建Java类，提供有参、无参构造以及属性setter方法;

packagecom.unknown.ioc;

importjava.util.List;

publicclassUser{

privateStringusername;

privateIntegerpassword;

publicStringgetUsername(){

returnusername;

)

publicvoidsetllsername(Stringusername){

this.username=username;

)

publicIntegergetPasswordQ{

returnpassword;

)

publicvoidsetPasswordilntegerpassword){

this.password=password;

)

publicList<String>getList(){

returnlist;

)

publicvoidsetList(List<String>list){

this.list=list;

)

privateList<String>list;

publicUser(Stringusername,Integerpassword,List<String>list){

super();

this.username=username;

this.password=password;

this.list=list;

)

publicUser(){

super();

)

)

步骤2：配置xml；

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns="http:〃/schema/beans”

xmlns:xsi="http:〃/2001/XMLSchema-irstance”

xsi:schemaLocation="/schema/beans

/schema/beans/spring-becns.xsd">

<beanid="userDao"class="com.unknown.ioc.UserDaolmpl"/>

<beanid="userService"class="com.unknown.ioc.llserServicelmpl">

<propertyname="userDao"ref="userDao"/>

</bean>

<beanid="beanl"class="com.unknown.ioc.Beanl"sccpe="singleton"/>

<beanid="bean2"class="com.unknown.ioc.MyBean2Factory"

factory-method="createBean"/>

<beanid="myBean3Fac:ory"class="com.unknown.ioc.MyBean3Factory"/>

<beanid="bean3"factory-bean="myBean3Factory"factory-method="createBean7>

<!--l.使用构造注入方式装配User•实例

<beanid="userl"class="com.unknown.ioc.User">

<constructor-argindex="0"value="tom"/>

<constructor-argindex="l"value="123456,7>

<constructor-argindex="2">

<list>

<value>"constructorvaluel"</value>

<value>"constructorvalue2"</value>

</list>

</constructor-arg>

</bean>

<!--2.使用设值注入方式装配User•实例

<beanid="user2"class="com.unknown.ioc.llser">

<propertyname="username"value=“张三”>v/property>

<propertyname="password"value="654321"x/property>

<!-注入list集合->

<propertyname="list">

<list>

<value>"setlistvaluel"</value>

<value>"setlistvalue2"</value>

</list>

</property>

</bean>

</beans>

步骤3：创建测试类;

importorg.springframework.context.ApplicationContext;

importorg.springframework.context.support.ClassPathXmlApplicationContext;

publicclassXmlBeanAssembleTest{

publicstaticvoidmain(Strmg[]args){

Applicationcontextapplicationcontext=

newClassPathXmlApplicationContextC'applicationContext.xml");

//构造方式输出结果

System.out.println(applicationContext.getBean("userl"));

//设值方式输出结果

System.out.println(applicationContext.getBean("user2"));

)

}

2.5.2基于Annotation的装配

基于XML的装配可能会导致XML配置文件过于臃肿，给后续的维护和升级带来一定的困难。为

此，Spring提供了对Annotation（注解）技术的全面支持。

>©Component：用于描述Spring中的Bean,它是一个泛化的概念，仅仅表示一个组件。

>©Repository：用于将数据访问层（DAO）的类标识为Spring中的Bean。

>©Service：用于将业务层（Service）的类标识为Spring中的Bean。

>©Controller：用于将控制层（Controller）的类标识为Spring中的Bean。

>©Autowired：用于对Bean的属性变量、属性的setter方法及构造方法进行标注，配合对应的

注解处理器完成Bean的自动配置工作。

>©Resource：其作用与Autowired一样。@Resource中有两个重要属性：name和type。Spring

将name属性解析为Bean实例名称，type属性解析为Bean实例类型。

>©Qualifier：4@Autowired注解配合使用，会将默认的按Bean类型装配修改为按Bean的实例

名称装配，Bean的实例名称由@Qualifier注解的参数指定。

在这个实例中需要引入：spring-aop-4.3.6.RELEASE.jar

步骤1：创建接口UserDao,并定义方法;

packagecom.unknown.AnnotationTest;

publicinterfaceUserDao{

publicvoidsave();

)

步骤2：创建接口实现类UserDaoImpI,用@Repository声明类;

packagecom.unknown.AnnotationTest;

importorg.springframework.stereotype.Repository;

(§)Repository("userDao")

publicclassUserDaoImpIimplementsUserDao{

publicvoidsave(){

System.out.println("userdao...save...")；

)

)

步骤3：创建接口UserService,并定义方法;

packagecom.unknown.AnnotationTest;

publicinterfaceUserService{

publicvoidsave();

)

步骤4：创建接口实现类UserServicelmph用©Service声明类，并使用

©Resource注入UserDao属性；

packagecom.unknown.AnnotationTest;

importorg.springframework.stereotype.Service;

importjavax.annotation.Resource;

@Service("userService")

publicclassUserServicelmpIimplementsUserService{

@Resource(name="userDao")

privateUserDaouserDao;

publicvoidsave(){

〃调用userDao中的save方法

this.userDao.save();

System.out.println("userservice....save...");

)

)

步骤5：创建控制器类，用©Controller声明，并使用@Resource注入

UserService属性;

packagecom.unknown.AnnotationTest:

importorg.springframework.stereotype.Controller;

importjavax.annotation.Resource;

@Controller("userController")

publicclassUserController{

@Resource(name="userService")

privateUserServiceuserService;

publicvoidsave(){

this.userService.save();

System.out.println("userController…save…

)

)

步骤6：配置bean；

<context:component-scanbase-package="com.unknown.AnnotationTest"/>：这一段内容是扫描该

包下的所有类

<beanid="userDao"class="com.unknown.AnnotationTest.UserDaolmpr7>

<beanid="userService"

class="com.unknown.AnnotationTest.UserServicelmpr7>

<beanid="userController"

class="com.unknown.AnnotationTest.UserController'7>

这一段是指定了对应关系

上面两部分，任选其一使用，也可以同时使用

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns="http://www.springframework.org/schema/beans”

xmlns:xsi="http://wvvw.w3.org/2001/XMLSchema-irstance"

xmlnscontext="http://www.springframework.org/schema/context”

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.Org/schema/beans/spring-beans-4.3.xsd

http://www.springframework.org/schema/context

http://www.springframework.Org/schema/context/spring-context-4.3.xsd">

<!-使用context命名空间，在配置文件中开启相应的注解处理器->

<context:annotation-config/>

<!--分别定义3个Bean实例

<beanid="userDao"class="com.unknown.AnnotationTest.UserDaolmpl7>

<beanid="userService"

class="com.unknown.AnnotationTest.UserServicelmpr7>

<beanid="userController"

class="com.unknown.AnnotationTest.UserController7>

<!--使用context命名空间，通知Spring扫描指定包下所有Bean类，进行注解解析

<context:component-scanbase-package="com.unknown.AnnotationTest"/>

</beans>

步骤7：创建测试类，测试程序。

importcom.unknown.AnnotationTest.UserController;

importorg.springframework.context.ApplicationContext;

importorg.springframework.context.support.ClassPathXmlApplicationContext;

publicclassAnnotationAssembleTest{

publicstaticvoidniain(String[]args){

//加载配置文件

Applicationcontextapplicationcontext=

newClassPathXmlApplicationContext("applicationContext.xmr,);

//获取UserController实例

UserControllerusercontroller=

(UserController)applicationContext.getBean("userController");

//调用UserController中的save。方法

userController.save();

)

)

2.5.3自动装配

所谓自动装配，就是将一个Bean自动的注入到到其他Bean的Property中。Spring的＜bean＞元

素中包含一个autowire属性，我们可以通过设置autowire的属性值来自动装配Beanoautowire属性有

5个值，其值及说明下表所示：

属性值，说明一

由＜bean〉的上级标签＜beans＞的default-autowire属性值确定。例如〈beans

defaults

default-autowire="byName，》则该＜1）6111＞兀素中的autowire属性对应的属

(默认值)/

性值就为bvName。/

根据属性的名称自动装配。容器将根据名称查找与属性完全一致的Bean,

byNamep

并将其属性自动装配。一

根据属性的数据类型（Type）自动装配，如果一个Bean的数据类型，兼

byTyper

容另一个Bean中属性的数据类型，则自动装配。一

constructors根据构造函数参数的数据类型，进行byiype模式的自动装配。。

no3默认情况下，不使用自动装配，Bean依赖必须通过ref元素定义。/

步骤1：修改上一节UserServicelmpI,添加setter方法

packagecom.unknown.AnnotationTest;

importorg.springframework.stereotype.Service;

importjavax.annotation.Resource;

@Service("userServicel")

publicclassUserServicelmpIimplementsUserService{

@Resource(name="userDao")

privateUserDaouserDao;

publicvoidsave(){

〃调用userDao中的save方法

this.userDao.save();

System.out.println("userservice....save...");

)

publicvoidsetUserDao(UserDaouserDao){