[spring]03_装配Bean

3.1 JavaBean

3.1.1 JavaBean 是什么

JavaBean 是一种JAVA语言写成的可重用组件。

为写成JavaBean,类必须是具体的和公共的,并且具有无参数的构造器。

JavaBean 通过提供符合一致性设计模式的公共方法将内部域暴露成员属性。

以下是一个简单的JavaBean类。

定义一个Person类,有 name 和 age 两个属性,以及这两个属性的 get、set 方法。

package com.demo.web.controllers;
 
 public class Person {
 private String name = "zhangsan";
 private int age = 28;
 
 public Person() {
     }
 
 public Person(String name, int age) {
 this.name = name;
 this.age = age;
     }
 
 public String getName() {
 return name;
     }
 
 public void setName(String name) {
 this.name = name;
     }
 
 public int getAge() {
 return age;
     }
 
 public void setAge(int age) {
 this.age = age;
     }
 }

3.1.2 JavaBean 特点

  • JavaBean 是一个 public 类型的类
  • JavaBean 含无参数的构造函数
  • JavaBean 提供 set 和 get 方法

3.1.3 JavaBean的生命周期

传统JavaBean生命周期

传统的Java应用,Bean的生命周期很简单。

使用new进行实例化,然后该Bean就可以使用了。程序结束后,Java会自动进行垃圾回收。

Spring容器中的JavaBean生命周期

在Spring容器中的Bean的生命周期要复杂多了,步骤如下:

(1)Spring对Bean进行实例化。

(2)Spring将值和Bean的引用注入进Bean对应的属性中。

(3)如果 Bean 实现了 BeanNameAware 接口,Spring将 Bean 的ID传递给 setBeanName() 接口方法。

(4)如果 Bean 实现了 BeanFactoryAware 接口,Spring将调用 setBeanFactory() 接口方法,将BeanFactory 容器实例传入。

(5)如果 Bean 实现了 ApplicationContextAware 接口,Spring将调用 setApplicationContext() 接口方法,将应用上下文的引用传入。

(6)如果 Bean 实现了 BeanPostProcessor 接口,Spring将调用它们的 post-ProcessBeforeInitialization接口方法。

(7)如果 Bean 实现了 InitializingBean 接口,Spring将调用它们的 afterPropertiesSet 接口方法。类似地,如果 Bean 使用 init-method 声明了初始化方法,该方法也会被调用。

(8) 如果 Bean 实现了 BeanPostProcessor接口,Spring将调用它们的 post-ProcessAfterInitialization接口方法。

(9)此时此刻,Bean 已经准备就绪,可以被应用程序是用来,它们将一直驻留在应用上下文中,直到该应用上下文被销毁。 (10)如果 Bean 实现了 DisposableBean 接口,Spring将调用它的 destroy() 接口方法。同样,如果Bean使用 destroy-method 声明了销毁方法,该方法也会被调用。

3.2 声明Bean

创建应用对象之间协作关系的行为通常被称为装配,这也是依赖注入的本质。

Spring是一个基于容器的框架。但是如果没有配置Spring,那它就是一个空容器,当然也毫无用处。 所以需要配置Spring,以告诉容器需要加载哪些Bean和如何装配这些Bean。

从Spring3.0开始,Spring容器提供了两种配置Bean的方式。

  • 使用XML文件作为配置文件
  • 基于Java注解的配置方式

注:本文先不介绍注解的配置方式,而是重点介绍传统的XML配置方式。

3.2.1 创建Spring配置

以下是一个典型的XML配置文件(一般为<servlet名>-servlet.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-3.0.xsd">
 <!-- Bean declarations go here -->
 </beans>

在 <beans> 元素内,可以放置所有的Spring配置信息。

实际上,beans这个标签是 Spring的一种命名空间。

Spring框架自带了10个命名空间,如下表所示:

命名空间

用途

aop

为声明切面以及将@AspectJ注解的类代理为Spring切面提供了配置元素

beans

支持声明Bean和装配Bean,是Spring最核心也是最原始的命名空间

context

为配置Spring应用上下文提供了配置元素,包括自动检测盒自动装配Bean、注入非Spring直接管理的对象

jee

提供了与Java EE API的集成,例如JNDI和EJB

jms

为声明消息驱动的POJO提供了配置元素

lang

支持配置由Groovy、Jruby或BeanShell等脚本是实现的Bean

mvc

启用SpringMVC的能力,例如面向注解的控制器、试图控制器和拦截器

oxm

支持Spring的对象到XML映射配置

tx

提供声明式事务配置

util

提供各种各样的工具类元素,包括把集合配置为Bean、支持属性占位符元素

除了Spring框架自带的命名空间,Spring Portfolio的许多成员,例如Spring security、Spring Web Flow和Spring Dynamic Modules,同样提供了他们自己的命名空间配置。

3.2.2 声明JavaBean

以上文提到的Person 类为例,定义了JavaBean后,还需要在xml文件中声明,形式如下:

<bean id="person" class="com.demo.web.controllers.Person"/>

这个标签的意思就是,创建一个 com.demo.web.controllers.Person 类的对象person。

当Spring容器加载这个Bean的时候,会使用默认构造器来实例化person对象,相当于:

com.demo.web.controllers.Person person = new com.demo.web.controllers.Person();

备注实际上,Spring是使用反射机制来创建Bean的。

3.2.3 构造器注入

很多应用场景下,我们希望在初始化实例时,传入关键性的参数,这就需要带参数的构造函数了。

为了解决这个问题,在构造Bean的时候,可以使用 <constructor-arg> 元素来指定构造器参数。

<bean id="person" class="com.demo.web.controllers.Person">
 <constructor-arg value="lisi" />
 <constructor-arg value="28" />
 </bean>

如果不使用这个标签,spring将使用默认构造函数。

以上参数都是直接传入值,如果想传入对象引用,那要怎么做呢?

请参考下面的例子:

首先定义一个Car类

package com.demo.web.controllers;
 
 public class Car {
 private String model;
 
 public Car() {
     }
 
 public Car(String model) {
 this.model = model;
     }
 
 public void run() {
         System.out.println(model + " 正在行驶");
     }
 }

再定义一个Driver类

package com.demo.web.controllers;
 
 public class Driver {
 private Car car;
 
 public Driver() {
     }
 
 public Driver(Car car) {
 this.car = car;
     }
 
 public void drive() {
         car.run();
     }
 }

接下来,我们可以在XML中配置一个Car的变量

<bean id="car" class="com.demo.web.controllers.Car">
 <constructor-arg value="宝马5系" />
 </bean>
 

有了Car的变量car,我们就可以在声明Driver变量时,使用 <constructor-arg> 标签引用它。

<bean id="driver" class="com.demo.web.controllers.Driver">
 <constructor-arg ref="car" />
 </bean>

3.2.4 通过工厂方法创建Bean

有时候一个类并没有public型的构造方法(典型的如单例模式里的类),对于这种情况如何在spring中实例化呢?

这时候静态工厂方法是实例化对象的唯一方法。Spring支持通过 <bean> 元素的 factory-method 属性来装配工厂创建的Bean。

package com.demo.web.controllers;
 
 public class Singleton {
 static Singleton instance = new Singleton();
 
 private Singleton() {
     }
 
 public static Singleton getInstance() {
 return instance;
     }
 }

为了在Spring中将Singleton配置为Bean,可以按照下面的方式来配置

<bean id="instance" class="com.demo.web.controllers.Singleton"
         factory-method="getInstance" />

3.2.5 Bean的作用域

所有的Spring Bean默认都是单例。当容器分配一个Bean时,它总是返回Bean的同一个实例。

但有时我们需要每次请求时都获得唯一的Bean实例,如何做到呢?

当在Spring中配置 <bean> 元素时,我们可以为Bean声明一个作用域。为了让Spring在每次请求时都为Bean产生一个新的实例,我们只需要配置Bean的scope属性为 prototype即可。

<bean id="person" class="com.demo.web.controllers.Person" scope="prototype" />

除了prototype,Spring还提供了其他几个作用域选项,如下:

作用域

定义

singleton

在每一个Spring容器中,一个Bean定义只有一个对象实例(默认)

prototype

运行Bean的定义可以被实例化任意次(每次调用都创建一个实例)

request

在一次HTTP请求中,每个Bean定义对应一个实例,该作用域仅在基于Web的Spring上下文(例如Spring MVC)中才有效

session

在一个HTTP Session中,每个Bean定义对应一个实例,该作用域仅在基于Web的Spring上下文(例如Spring MVC)中才有效

global-session

在一个全局HTTP Session中,每个Bean定义对应一个实例,该作用域仅在Portlet上下文中才有效

注:Spring的单例Bean只能保证在每个应用上下文中只有一个Bean的实 例。 

3.2.6 初始化和销毁Bean

当实例化一个Bean时,可能需要执行一些初始化操作来确保该Bean处于可用状态。同样地,当不再需要Bean,将其从容器中移除时,我们可能还需要按 顺序执行一些清除工作。为了满足初始化和销毁Bean的需求,Spring提供了Bean生命周期的钩子方法。

为Bean定义初始化和销毁操作,只需要使用 init-method 和 destroy-method 参数来配置 <bean> 元素。 init-method 属性指定了在初始化 Bean 时要调用的方法。类似地,destroy-method 属性指定了 Bean 从容器移除之前要调用的方法。

假设,为一个灯泡的功能写一个类。

package com.demo.web.controllers;
 
 public class Light {
 public void turnOn() {
 // ...
     }
 
 public void turnOff() {
 // ...
     }
 }

接着,我们在XML中做如下配置

<bean id="light" class="com.demo.web.controllers.Light"
         init-method="turnOn" destroy-method="turnOff" />

这样,就能保证让灯泡类在点亮之前调用turnOn(),结束时调用turnOff()。

3.3 注入Bean属性

通常,JavaBean中的属性都是私有的,同时提供一组get、set方法。

(1)注入简单值

在Spring中,除了用前面介绍的构造器注入方式,还可以使用 <property> 元素配置 Bean 的属性。

还是以Person类为例

<bean id="person" class="com.demo.web.controllers.Person">
 <property name="name" value="wangwu" />
 <property name="age" value="30" />
 </bean>

(2)引用其他Bean

还记得我们在构造器注入部分提到的Driver和Car类的例子吗,如果使用property的方式,则按如下方式表达

<bean id="baoma" class="com.demo.web.controllers.Car">
 <constructor-arg value="宝马5系" />
 </bean>
 
 <bean id="driver" class="com.demo.web.controllers.Driver">
 <property name="car" ref="baoma" />
 </bean>

(3)内部注入

内部注入是通过直接声明一个 <bean> 元素作为 <property>元素的子节点而定义的。

<bean id="driver" class="com.demo.web.controllers.Driver">
 <property name="car">
 <bean class="com.demo.web.controllers.Car" />
 </property>
 </bean>

(4)使用Sping的命名空间p装配属性

Spring还提供了一个命名空间p以简化<property>元素的装配方式。

命名空间p的schema URI为 http://www.springframework.org/schema/p。

如果要使用命名空间p ,需要在Spring的XML配置中增加一段声明

<?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:p="http://www.springframework.org/schema/p" 
     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-3.0.xsd">

有了以上声明,我们就可以使用p:作为<bean>元素所有属性的前缀来装配Bean的属性。

用p:重新定义上节Driver类的配置, 如下:

<bean id="baoma" class="com.demo.web.controllers.Car">
 <constructor-arg value="宝马5系" />
 </bean>
 
 <bean id="driver" class="com.demo.web.controllers.Driver"
     p:car-ref="baoma"/>

p:car-ref="baoma" 表示要装配car 属性,-ref后缀表示这是一个引用而不是字面值。"baoma"是这个属性的引用对象。

3.3.1 装配集合

Spring不仅可以装配单个值,也可以装配集合。

Spring提供4种类型的集合配置元素。

(1)<list> 和 <set>

<list> 和 <set> 都可以用来装配类型为 java.util.Collection 的任意实现或数组的属性。

两者的区别在于:list 允许成员重复; set 必须保证成员不重复。

需要注意的是,不是说如果属性是java.util.Set 类型,则用户必须用 <set> 装配。

定义一个 instruments 属性,它是一个Collection,保存各种乐器

<property name="instruments">
 <list>
 <ref bean="guitar" />
 <ref bean="piano" />
 <ref bean="piano" />
 </list>
 </property>
 
 <property name="instruments">
 <set>
 <ref bean="guitar" />
 <ref bean="piano" />
 <ref bean="piano" /><!-- 自动忽略重复的属性 -->
 </set>
 </property>

(2)<map>

<map> 元素声明了一个 java.util.Map 类型的值。每个 <entry> 元素定义 Map 的一个成员。

<entry> 元素由一个键和一个值组成,键和值可以是简单类型,也可以是其他Bean的引用。

属性

用途

key

指定map中entry的键为String

key-ref

指定map中entry的键为Spring上下文中其他Bean的引用

value

指定map中entry的值为String

value-ref

指定map中entry的值为Spring上下文中其他Bean的引用

<property name="instruments">
 <map>
 <entry key="GUITAR" value-ref="guitar">
 <entry key="PIANO" value-ref="piano">
 </map>
 </property>

(3)<prop>

如 果 Map 的每一个 entry 的键和值都为 String 类型时,可以考虑使用 java.util.Properties 代替 Map。Properties 类提供了和 Map 大致相同的功能,但是它限定了键和值必须为 String 类型。

<props> 元素构建了一个 java.util.Properties 值,这个 Properties 的每一个成员由 <prop> 定义。

<property name="instruments">
 <props>
 <prop key="GUITAR">guitar sound</prop>
 <prop key="PIANO">piano sound</prop>
 </props>
 </property>

3.4 使用表达式装配

Spring 3引入了Spring表达式语言(Spring Expression Lanuage, SpEL)。

它通过运行期执行的表达式将值装配到 Bean 的属性或构造器参数中。

3.4.1 SpEL 的基本原理

SpEL 表达式的首要目标是通过计算获得某个值。最简单的SpEL求值或许是对字面值、Bean的属性或某个类的常量进行求值。

字面值

<property> 元素的 value 属性中使用 #{} 界定符把这个值装配到 Bean 的属性中

<property name="count" value="#{5}" />

此外,也可以与非SpEL 表达式的值混用

<property name="count" value="The value is #{5}" />

引用Bean、Properties 和方法

SpEL 表达式可以通过 ID 引用其他 Bean。

<property name="fruit" value="#{apple}" />

这和以下语句的功能等价

<property name="fruit" ref="apple" />

除了直接引用其他Bean,也可以引用 Bean 对象的属性和方法

<property name="song" value="#{singer.song}" />
 <property name="song" value="#{singer.selectSong().toUpperCase()}" />

需要注意的是,singer.selectSong().toUpperCase()存在一个问题,如果selectSong()方法返回的是null, 那么SpEL表达式求值时会抛出一个 NullPointerException 异常。

为了避免这种情况,可以使用null-safe存取器(?.)

<property name="song" value="#{singer.selectSong()?.toUpperCase()}" />

使用 ?. 代替 . 来访问 toUpperCase() 方法。?. 可以确保只有当 selectSong() 不为 null 时才去调用 toUpperCase() 方法。

操作类

现在,我们了解了在 SpE L中,如何去调用 Bean 对象,以及对象的属性和方法。

但是,如何去访问类的静态方法或常量引用呢?

在 SpEL 中,使用 T() 运算符去调用类作用域的方法和常量。

以下演示了如何调用 java.lang.Math 类中的静态方法和属性。

<property name="multiplier" value="#{T{java.lang.Math}.PI}" />
 <property name="multiplier" value="#{T{java.lang.Math}.random}" />

在 SpEL 值上执行运算操作

SpEL提供了几种运算符,这些运算符可以用在SpEL表达式中的值上。

运算符类型

运算符

算术运算

+、-、*、/、%、^

关系运算

<、>、==、<=、>=、lt、gt、eq、le、ge

逻辑运算

and、or、not、|

条件运算

?: (ternary)、?: (Elvis)

正则表达式

matches

3.4.2 在 SpEL 中筛选集合

假设针对前面的Person类,我们定义一个List集合,如下:

<util:list id="persons">
 <bean class="com.demo.web.controllers.Person" p:name="zhangsan" p:age="17"/>
 <bean class="com.demo.web.controllers.Person" p:name="lisi" p:age="24"/>
 <bean class="com.demo.web.controllers.Person" p:name="wangwu" p:age="30"/>
 <bean class="com.demo.web.controllers.Person" p:name="zhaoliu" p:age="16"/>
 <bean class="com.demo.web.controllers.Person" p:name="liuqi" p:age="23"/>
 </util:list>

访问集合成员

可以使用 [] 运算符来访问集合成员

<property name="choosePerson" value="#{persons[T{java.lang.Math}.random() * persons.size()]]}" />

以上表示,随机选取一个人。

也可以按下面方式选取

<property name="choosePerson" value="#{persons['zhangsan']}" /><!-- 选取集合中叫张三的人 -->
 <property name="choosePerson" value="#{persons[2]}" /><!-- 选取集合中第二个人 -->

查询集合成员

如果想要在persons集合中查询年龄大于18岁的人。

在SpEL中,只需使用一个查询运算符(.?[]) 就可以简单做到,如下所示:

<property name="adults" value="#{persons.?[age gt 18]}" />

查询运算符会创建一个新的集合,集合中只存放符合括号中表达式的成员。

SpEL 还提供两种运算符:.^[].$[],从集合中查询出第一个匹配项和最后一个匹配项。

投影集合

在SpEL中, 提供了投影运算符(.![])将集合中每个成员的特定属性放入一个新的集合中。

<property name="personNames" value="#{persons.![name]}" />

以上,将所有人的名字取出来,建立一个新的集合personNames。

3.5 JavaBean的一个简单应用实例

以下 以 [Spring]01_ 环境配置 中的 HelloWorld 工程为基础,演示一下 JavaBean 的简单使用方法。

打开 HelloWorld 工程。

(1)新建一个 java 文件,名为 Person.java,完整内容如下:

package com.demo.web.controllers;
 
 public class Person {
 private String name = "zhangsan";
 private int age = 28;
 
 public Person() {
     }
 
 public Person(String name, int age) {
 this.name = name;
 this.age = age;
     }
 
 public String getName() {
 return name;
     }
 
 public void setName(String name) {
 this.name = name;
     }
 
 public int getAge() {
 return age;
     }
 
 public void setAge(int age) {
 this.age = age;
     }
 }

(2)修改 index.jsp 文件,完整内容如下:

<!-- 导入要引用的类 -->
 <%@ page language="java" contentType="text/html; charset=ISO-8859-1"
     import="com.demo.web.controllers.Person" pageEncoding="UTF-8"%>
 
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Spring Hello World</title>
 </head>
 <body>
 <!-- 
     <h1>${message}</h1>
 -->
 
 <jsp:useBean id="person" class="com.demo.web.controllers.Person" scope="session" />
 
 <!-- 获取对象属性 -->
     name: <jsp:getProperty name="person" property="name" /><br>
     age: <jsp:getProperty name="person" property="age" /><br>
 
 <!-- 设置对象属性 -->
 <jsp:setProperty name="person" property="name" value="lisi" />
 <jsp:setProperty name="person" property="age" value="30" /><!-- 这里有自动的类型转换:String2int-->
 <jsp:setProperty name="person" property="age" value="<%=20 + 20%>" /><!-- value值还可以用表达式 -->
 
 
 <!-- 再次获取对象属性 -->
 <br>
     name after change: <jsp:getProperty name="person" property="name" /><br>
     age after change: <jsp:getProperty name="person" property="age" /><br>
 
 <!-- 用表达式输出对象属性 -->
 <br>
     name again: <%=person.getName()%><br>
 
 <!-- 脚本段声明对象 -->
 <br>
     another person:
 <%
         Person person2 = new Person(); //这里不能把对象叫做person,提示重复的局部变量,进一步说明这种方法和上面 的方法,本质上是一样的
         out.println(person2.getName());
     %>
 
 <!-- 再声明一个Person类对象,注意id必须和前面的不同,声明的是同一个类的不同的对 象-->
 <jsp:useBean id="person3" class="com.demo.web.controllers.Person" scope="session"/>
 </body>
 </html>

(3)运行

结果如下:

name: zhangsan
 age: 28
 
 name after change: lisi
 age after change: 40
 
 name again: lisi
 
 another person: zhangsan

参考资料

Spring实战(第3版)

http://www.cnblogs.com/mengdd/p/3151701.html

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏爱撒谎的男孩

struts2之配置拦截器

3665
来自专栏JAVA烂猪皮

Spring核心——Bean的定义与控制

在Sring核心与设计模式的文章中,分别介绍了Ioc容器和Bean的依赖关系。如果阅读过前2文就会知道,Spring的整个运转机制就是围绕着IoC容器以及Bea...

721
来自专栏lgp20151222

@Autowired的使用--Spring规范解释,推荐对构造函数进行注释

Spring Team recommends "Always use constructor based dependency injection in you...

1063
来自专栏xingoo, 一个梦想做发明家的程序员

【Spring实战】—— 8 自动装配

本篇介绍一下自动装配的知识,Spring为了简化配置文件的编写。采用自动装配方式,自动的装载需要的bean。 自动装配 有以下几种方式:   1 byN...

19610
来自专栏李家的小酒馆

AOP的具体实践-简化结果返回的处理

  以前学习Spring的时候着重学习过AOP概念,但是一直也没有用上,唯一碰到过的就是Spring内置的事务管理。现在碰到过一些结果后面的操作适合用到,所以这...

672
来自专栏coolblog.xyz技术专栏

Spring AOP 源码分析 - 筛选合适的通知器

从本篇文章开始,我将会对 Spring AOP 部分的源码进行分析。本文是 Spring AOP 源码分析系列文章的第二篇,本文主要分析 Spring AOP ...

763
来自专栏CSDN技术头条

Spring 框架之 AOP 原理剖析

前言 AOP(Aspect Oriented Programming)面向切面编程是 Spring 框架最核心的组件之一,它通过对程序结构的另一种考虑,补充了...

5894
来自专栏kalifaの日々

Intel寄存器名称解释及用途,%eax%ebx等都是什么意思

参考资料:https://www.swansontec.com/sregisters.html x86家族的CPU都有8个通用寄存器,每一个寄存器的名字都是一...

4815
来自专栏互联网大杂烩

Struts1和Struts2的区别和对比

• Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口,而struts2的Action是接口。 • St...

664
来自专栏技术墨客

Spring核心——Bean的依赖注入 原

在设计模式与IoC这篇文章中,介绍了Spring基础的三大支柱的两项内容——IoC、Bean。本篇将继续围绕着Bean的创建时的注入方式来介绍Spring的核心...

681

扫码关注云+社区