Spring学习(五)——Spring注解(一)
---恢复内容开始---
概述
注释配置相对于 XML 配置具有很多的优势:
- 它可以充分利用 Java 的反射机制获取类结构信息,这些信息可以有效减少配置的工作。如使用 JPA 注释配置 ORM 映射时,我们就不需要指定 PO 的属性名、类型等信息,如果关系表字段和 PO 属性名、类型都一致,您甚至无需编写任务属性映射信息——因为这些信息都可以通过 Java 反射机制获取。
- 注释和 Java 代码位于一个文件中,而 XML 配置采用独立的配置文件,大多数配置信息在程序开发完成后都不会调整,如果配置信息和 Java 代码放在一起,有助于增强程序的内聚性。而采用独立的 XML 配置文件,程序员在编写一个功能时,往往需要在程序文件和配置文件中不停切换,这种思维上的不连贯会降低开发效率。
因此在很多情况下,注释配置比 XML 配置更受欢迎,注释配置有进一步流行的趋势。Spring 2.5 的一大增强就是引入了很多注释类,现在您已经可以使用注释配置完成大部分 XML 配置的功能。在这篇文章里,我们将向您讲述使用注释进行 Bean 定义和依赖注入的内容。
原来我们是怎么做的
在使用注释配置之前,先来回顾一下传统上是如何配置 Bean 并完成 Bean 之间依赖关系的建立。下面是 3 个类,它们分别是 Office、Car 和 Boss,这 3 个类需要在 Spring 容器中配置为 Bean:
Office 仅有一个属性:
清单 1. Office.java
package com.baobaotao; public class Office {private String officeNo =”001”;//省略 get/setter@Overridepublic String toString() {return "officeNo:" + officeNo;} } |
Car 拥有两个属性:
清单 2. Car.java
package com.baobaotao;public class Car {private String brand;private double price;// 省略 get/setter@Overridepublic String toString() {return "brand:" + brand + "," + "price:" + price;} } |
Boss 拥有 Office 和 Car 类型的两个属性:
清单 3. Boss.java
package com.baobaotao;public class Boss {private Car car;private Office office;// 省略 get/setter@Overridepublic String toString() {return "car:" + car + "\n" + "office:" + office;} } |
我们在 Spring 容器中将 Office 和 Car 声明为 Bean,并注入到 Boss Bean 中:下面是使用传统 XML 完成这个工作的配置文件 beans.xml:
清单 4. beans.xml 将以上三个类配置成 Bean
<?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-2.5.xsd"><bean id="boss" class="com.baobaotao.Boss"><property name="car" ref="car"/><property name="office" ref="office" /></bean><bean id="office" class="com.baobaotao.Office"><property name="officeNo" value="002"/></bean><bean id="car" class="com.baobaotao.Car" scope="singleton"><property name="brand" value=" 红旗 CA72"/><property name="price" value="2000"/></bean> </beans> |
当我们运行以下代码时,控制台将正确打出 boss 的信息:
清单 5. 测试类:AnnoIoCTest.java
import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class AnnoIoCTest {public static void main(String[] args) {String[] locations = {"beans.xml"};ApplicationContext ctx = new ClassPathXmlApplicationContext(locations);Boss boss = (Boss) ctx.getBean("boss");System.out.println(boss);} } |
这说明 Spring 容器已经正确完成了 Bean 创建和装配的工作。
使用 @Autowired 注释
Spring 2.5 引入了 @Autowired
注释,它可以对类成员变量、方法及构造函数进行标注,完成自动装配的工作。来看一下使用@Autowired
进行成员变量自动注入的代码:
清单 6. 使用 @Autowired 注释的 Boss.java
package com.baobaotao; import org.springframework.beans.factory.annotation.Autowired;public class Boss {@Autowiredprivate Car car;@Autowiredprivate Office office;… } |
Spring 通过一个 BeanPostProcessor
对 @Autowired
进行解析,所以要让@Autowired
起作用必须事先在 Spring 容器中声明AutowiredAnnotationBeanPostProcessor
Bean。
清单 7. 让 @Autowired 注释工作起来
<?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-2.5.xsd"><!-- 该 BeanPostProcessor 将自动起作用,对标注 @Autowired 的 Bean 进行自动注入 --><bean class="org.springframework.beans.factory.annotation. AutowiredAnnotationBeanPostProcessor"/><!-- 移除 boss Bean 的属性注入配置的信息 --><bean id="boss" class="com.baobaotao.Boss"/><bean id="office" class="com.baobaotao.Office"><property name="officeNo" value="001"/></bean><bean id="car" class="com.baobaotao.Car" scope="singleton"><property name="brand" value=" 红旗 CA72"/><property name="price" value="2000"/></bean> </beans> |
这样,当 Spring 容器启动时,AutowiredAnnotationBeanPostProcessor
将扫描 Spring 容器中所有 Bean,当发现 Bean 中拥有@Autowired
注释时就找到和其匹配(默认按类型匹配)的 Bean,并注入到对应的地方中去。
按照上面的配置,Spring 将直接采用 Java 反射机制对 Boss 中的 car
和 office
这两个私有成员变量进行自动注入。所以对成员变量使用@Autowired
后,您大可将它们的 setter 方法(setCar()
和 setOffice()
)从 Boss 中删除。
当然,您也可以通过 @Autowired
对方法或构造函数进行标注,来看下面的代码:
清单 8. 将 @Autowired 注释标注在 Setter 方法上
package com.baobaotao;public class Boss {private Car car;private Office office;@Autowiredpublic void setCar(Car car) {this.car = car;}@Autowiredpublic void setOffice(Office office) {this.office = office;}… } |
这时,@Autowired
将查找被标注的方法的入参类型的 Bean,并调用方法自动注入这些 Bean。而下面的使用方法则对构造函数进行标注:
清单 9. 将 @Autowired 注释标注在构造函数上
package com.baobaotao;public class Boss {private Car car;private Office office;@Autowiredpublic Boss(Car car ,Office office){this.car = car;this.office = office ;}… } |
由于 Boss()
构造函数有两个入参,分别是 car
和 office
,@Autowired
将分别寻找和它们类型匹配的 Bean,将它们作为Boss(Car car ,Office office)
的入参来创建 Boss
Bean。
当候选 Bean 数目不为 1 时的应对方法
在默认情况下使用 @Autowired
注释进行自动注入时,Spring 容器中匹配的候选 Bean 数目必须有且仅有一个。当找不到一个匹配的 Bean 时,Spring 容器将抛出BeanCreationException
异常,并指出必须至少拥有一个匹配的 Bean。我们可以来做一个实验:
清单 10. 候选 Bean 数目为 0 时
<?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-2.5.xsd "><bean class="org.springframework.beans.factory.annotation. AutowiredAnnotationBeanPostProcessor"/> <bean id="boss" class="com.baobaotao.Boss"/><!-- 将 office Bean 注释掉 --><!-- <bean id="office" class="com.baobaotao.Office"><property name="officeNo" value="001"/></bean>--><bean id="car" class="com.baobaotao.Car" scope="singleton"><property name="brand" value=" 红旗 CA72"/><property name="price" value="2000"/></bean> </beans> |
由于 office
Bean 被注释掉了,所以 Spring 容器中将没有类型为 Office
的 Bean 了,而 Boss 的office
属性标注了 @Autowired
,当启动 Spring 容器时,异常就产生了。
当不能确定 Spring 容器中一定拥有某个类的 Bean 时,可以在需要自动注入该类 Bean 的地方可以使用 @Autowired(required = false)
,这等于告诉 Spring:在找不到匹配 Bean 时也不报错。来看一下具体的例子:
清单 11. 使用 @Autowired(required = false)
package com.baobaotao;import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Required;public class Boss {private Car car;private Office office;@Autowiredpublic void setCar(Car car) {this.car = car;}@Autowired(required = false)public void setOffice(Office office) {this.office = office;}… } |
当然,一般情况下,使用 @Autowired
的地方都是需要注入 Bean 的,使用了自动注入而又允许不注入的情况一般仅会在开发期或测试期碰到(如为了快速启动 Spring 容器,仅引入一些模块的 Spring 配置文件),所以@Autowired(required = false)
会很少用到。
和找不到一个类型匹配 Bean 相反的一个错误是:如果 Spring 容器中拥有多个候选 Bean,Spring 容器在启动时也会抛出 BeanCreationException
异常。来看下面的例子:
清单 12. 在 beans.xml 中配置两个 Office 类型的 Bean
… <bean id="office" class="com.baobaotao.Office"><property name="officeNo" value="001"/> </bean> <bean id="office2" class="com.baobaotao.Office"><property name="officeNo" value="001"/> </bean> … |
我们在 Spring 容器中配置了两个类型为 Office
类型的 Bean,当对 Boss 的 office
成员变量进行自动注入时,Spring 容器将无法确定到底要用哪一个 Bean,因此异常发生了。
Spring 允许我们通过 @Qualifier
注释指定注入 Bean 的名称,这样歧义就消除了,可以通过下面的方法解决异常:
清单 13. 使用 @Qualifier 注释指定注入 Bean 的名称
@Autowired public void setOffice(@Qualifier("office")Office office) {this.office = office; } |
@Qualifier("office")
中的 office
是 Bean 的名称,所以 @Autowired
和@Qualifier
结合使用时,自动注入的策略就从 byType 转变成 byName 了。@Autowired
可以对成员变量、方法以及构造函数进行注释,而@Qualifier
的标注对象是成员变量、方法入参、构造函数入参。正是由于注释对象的不同,所以 Spring 不将 @Autowired
和@Qualifier
统一成一个注释类。下面是对成员变量和构造函数入参进行注释的代码:
对成员变量进行注释:
清单 14. 对成员变量使用 @Qualifier 注释
public class Boss {@Autowiredprivate Car car;@Autowired@Qualifier("office")private Office office;… } |
对构造函数入参进行注释:
清单 15. 对构造函数变量使用 @Qualifier 注释
public class Boss {private Car car;private Office office;@Autowiredpublic Boss(Car car , @Qualifier("office")Office office){this.car = car;this.office = office ;} } |
@Qualifier
只能和 @Autowired
结合使用,是对 @Autowired
有益的补充。一般来讲,@Qualifier
对方法签名中入参进行注释会降低代码的可读性,而对成员变量注释则相对好一些。
使用 JSR-250 的注释
Spring 不但支持自己定义的 @Autowired
的注释,还支持几个由 JSR-250 规范定义的注释,它们分别是 @Resource
、@PostConstruct
以及 @PreDestroy
。
@Resource
@Resource
的作用相当于 @Autowired
,只不过 @Autowired
按 byType 自动注入,面@Resource
默认按 byName 自动注入罢了。@Resource
有两个属性是比较重要的,分别是 name 和 type,Spring 将@Resource
注释的 name 属性解析为 Bean 的名字,而 type 属性则解析为 Bean 的类型。所以如果使用 name 属性,则使用 byName 的自动注入策略,而使用 type 属性时则使用 byType 自动注入策略。如果既不指定 name 也不指定 type 属性,这时将通过反射机制使用 byName 自动注入策略。
Resource 注释类位于 Spring 发布包的 lib/j2ee/common-annotations.jar 类包中,因此在使用之前必须将其加入到项目的类库中。来看一个使用@Resource
的例子:
清单 16. 使用 @Resource 注释的 Boss.java
package com.baobaotao;import javax.annotation.Resource;public class Boss {// 自动注入类型为 Car 的 Bean@Resourceprivate Car car;// 自动注入 bean 名称为 office 的 Bean@Resource(name = "office")private Office office; } |
一般情况下,我们无需使用类似于 @Resource(type=Car.class)
的注释方式,因为 Bean 的类型信息可以通过 Java 反射从代码中获取。
要让 JSR-250 的注释生效,除了在 Bean 类中标注这些注释外,还需要在 Spring 容器中注册一个负责处理这些注释的 BeanPostProcessor
:
<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/> |
CommonAnnotationBeanPostProcessor
实现了 BeanPostProcessor
接口,它负责扫描使用了 JSR-250 注释的 Bean,并对它们进行相应的操作。
@PostConstruct 和 @PreDestroy
Spring 容器中的 Bean 是有生命周期的,Spring 允许在 Bean 在初始化完成后以及 Bean 销毁前执行特定的操作,您既可以通过实现 InitializingBean/DisposableBean 接口来定制初始化之后 / 销毁之前的操作方法,也可以通过 <bean> 元素的 init-method/destroy-method 属性指定初始化之后 / 销毁之前调用的操作方法。关于 Spring 的生命周期,笔者在《精通 Spring 2.x—企业应用开发精解》第 3 章进行了详细的描述,有兴趣的读者可以查阅。
JSR-250 为初始化之后/销毁之前方法的指定定义了两个注释类,分别是 @PostConstruct 和 @PreDestroy,这两个注释只能应用于方法上。标注了 @PostConstruct 注释的方法将在类实例化后调用,而标注了 @PreDestroy 的方法将在类销毁之前调用。
清单 17. 使用 @PostConstruct 和 @PreDestroy 注释的 Boss.java
package com.baobaotao;import javax.annotation.Resource; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy;public class Boss {@Resourceprivate Car car;@Resource(name = "office")private Office office;@PostConstructpublic void postConstruct1(){System.out.println("postConstruct1");}@PreDestroypublic void preDestroy1(){System.out.println("preDestroy1"); }… }
您只需要在方法前标注 @PostConstruct
或 @PreDestroy
,这些方法就会在 Bean 初始化后或销毁之前被 Spring 容器执行了。
我们知道,不管是通过实现 InitializingBean
/DisposableBean
接口,还是通过 <bean> 元素的init-method/destroy-method
属性进行配置,都只能为 Bean 指定一个初始化 / 销毁的方法。但是使用 @PostConstruct
和 @PreDestroy
注释却可以指定多个初始化 / 销毁方法,那些被标注 @PostConstruct
或@PreDestroy
注释的方法都会在初始化 / 销毁时被执行。
通过以下的测试代码,您将可以看到 Bean 的初始化 / 销毁方法是如何被执行的:
清单 18. 测试类代码
package com.baobaotao;import org.springframework.context.support.ClassPathXmlApplicationContext;public class AnnoIoCTest {public static void main(String[] args) {String[] locations = {"beans.xml"};ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(locations);Boss boss = (Boss) ctx.getBean("boss");System.out.println(boss);ctx.destroy();// 关闭 Spring 容器,以触发 Bean 销毁方法的执行 } }
这时,您将看到标注了 @PostConstruct
的 postConstruct1()
方法将在 Spring 容器启动时,创建Boss
Bean 的时候被触发执行,而标注了 @PreDestroy
注释的 preDestroy1()
方法将在 Spring 容器关闭前销毁Boss
Bean 的时候被触发执行。
使用 <context:annotation-config/> 简化配置
Spring 2.1 添加了一个新的 context 的 Schema 命名空间,该命名空间对注释驱动、属性文件引入、加载期织入等功能提供了便捷的配置。我们知道注释本身是不会做任何事情的,它仅提供元数据信息。要使元数据信息真正起作用,必须让负责处理这些元数据的处理器工作起来。
而我们前面所介绍的 AutowiredAnnotationBeanPostProcessor
和 CommonAnnotationBeanPostProcessor
就是处理这些注释元数据的处理器。但是直接在 Spring 配置文件中定义这些 Bean 显得比较笨拙。Spring 为我们提供了一种方便的注册这些BeanPostProcessor
的方式,这就是 <context:annotation-config/>。请看下面的配置:
清单 19. 调整 beans.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"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"><context:annotation-config/> <bean id="boss" class="com.baobaotao.Boss"/><bean id="office" class="com.baobaotao.Office"><property name="officeNo" value="001"/></bean><bean id="car" class="com.baobaotao.Car" scope="singleton"><property name="brand" value=" 红旗 CA72"/><property name="price" value="2000"/></bean> </beans>
<context:annotationconfig/> 将隐式地向 Spring 容器注册AutowiredAnnotationBeanPostProcessor
、CommonAnnotationBeanPostProcessor
、PersistenceAnnotationBeanPostProcessor
以及equiredAnnotationBeanPostProcessor
这 4 个 BeanPostProcessor。
在配置文件中使用 context 命名空间之前,必须在 <beans> 元素中声明 context 命名空间。
使用 @Component
虽然我们可以通过 @Autowired
或 @Resource
在 Bean 类中使用自动注入功能,但是 Bean 还是在 XML 文件中通过 <bean> 进行定义 —— 也就是说,在 XML 配置文件中定义 Bean,通过@Autowired
或 @Resource
为 Bean 的成员变量、方法入参或构造函数入参提供自动注入的功能。能否也通过注释定义 Bean,从 XML 配置文件中完全移除 Bean 定义的配置呢?答案是肯定的,我们通过 Spring 2.5 提供的@Component
注释就可以达到这个目标了。
为什么 @Repository 只能标注在 DAO 类上呢?这是因为该注解的作用不只是将类识别为 Bean,同时它还能将所标注的类中抛出的数据访问异常封装为 Spring 的数据访问异常类型。 Spring 本身提供了一个丰富的并且是与具体的数据访问技术无关的数据访问异常结构,用于封装不同的持久层框架抛出的异常,使得异常独立于底层的框架。
Spring 2.5 在 @Repository 的基础上增加了功能类似的额外三个注解:@Component、@Service、@Constroller,它们分别用于软件系统的不同层次:
- @Component 是一个泛化的概念,仅仅表示一个组件 (Bean) ,可以作用在任何层次。
- @Service 通常作用在业务层,但是目前该功能与 @Component 相同。
- @Constroller 通常作用在控制层,但是目前该功能与 @Component 相同。
通过在类上使用 @Repository、@Component、@Service 和 @Constroller 注解,Spring 会自动创建相应的 BeanDefinition 对象,并注册到 ApplicationContext 中。这些类就成了 Spring 受管组件。这三个注解除了作用于不同软件层次的类,其使用方式与 @Repository 是完全相同的。
下面,我们完全使用注释定义 Bean 并完成 Bean 之间装配:
清单 20. 使用 @Component 注释的 Car.java
package com.baobaotao;import org.springframework.stereotype.Component;@Component public class Car {… }
仅需要在类定义处,使用 @Component
注释就可以将一个类定义了 Spring 容器中的 Bean。下面的代码将 Office
定义为一个 Bean:
清单 21. 使用 @Component 注释的 Office.java
package com.baobaotao;import org.springframework.stereotype.Component;@Component public class Office {private String officeNo = "001";… }
这样,我们就可以在 Boss 类中通过 @Autowired
注入前面定义的 Car
和 Office Bean
了。
清单 22. 使用 @Component 注释的 Boss.java
package com.baobaotao;import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Required; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Component;@Component("boss") public class Boss {@Autowiredprivate Car car;@Autowiredprivate Office office;… }
@Component
有一个可选的入参,用于指定 Bean 的名称,在 Boss 中,我们就将 Bean 名称定义为“boss
”。一般情况下,Bean 都是 singleton 的,需要注入 Bean 的地方仅需要通过 byType 策略就可以自动注入了,所以大可不必指定 Bean 的名称。
在使用 @Component
注释后,Spring 容器必须启用类扫描机制以启用注释驱动 Bean 定义和注释驱动 Bean 自动注入的策略。Spring 2.5 对 context 命名空间进行了扩展,提供了这一功能,请看下面的配置:
清单 23. 简化版的 beans.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"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"><context:component-scan base-package="com.baobaotao"/> </beans> |
这里,所有通过 <bean> 元素定义 Bean 的配置内容已经被移除,仅需要添加一行 <context:component-scan/> 配置就解决所有问题了——Spring XML 配置文件得到了极致的简化(当然配置元数据还是需要的,只不过以注释形式存在罢了)。<context:component-scan/> 的 base-package 属性指定了需要扫描的类包,类包及其递归子包中所有的类都会被处理。
<context:component-scan/> 还允许定义过滤器将基包下的某些类纳入或排除。Spring 支持以下 4 种类型的过滤方式,通过下表说明:
表 1. 扫描过滤方式
过滤器类型 | 说明 |
---|---|
注释 | 假如 com.baobaotao.SomeAnnotation 是一个注释类,我们可以将使用该注释的类过滤出来。 |
类名指定 | 通过全限定类名进行过滤,如您可以指定将 com.baobaotao.Boss 纳入扫描,而将 com.baobaotao.Car 排除在外。 |
正则表达式 | 通过正则表达式定义过滤的类,如下所示: com\.baobaotao\.Default.* |
AspectJ 表达式 | 通过 AspectJ 表达式定义过滤的类,如下所示: com. baobaotao..*Service+ |
下面是一个简单的例子:
<context:component-scan base-package="com.baobaotao"><context:include-filter type="regex" expression="com\.baobaotao\.service\..*"/><context:exclude-filter type="aspectj" expression="com.baobaotao.util..*"/> </context:component-scan> |
值得注意的是 <context:component-scan/> 配置项不但启用了对类包进行扫描以实施注释驱动 Bean 定义的功能,同时还启用了注释驱动自动注入的功能(即还隐式地在内部注册了AutowiredAnnotationBeanPostProcessor
和 CommonAnnotationBeanPostProcessor
),因此当使用 <context:component-scan/> 后,就可以将 <context:annotation-config/> 移除了。
默认情况下通过 @Component
定义的 Bean 都是 singleton 的,如果需要使用其它作用范围的 Bean,可以通过@Scope
注释来达到目标,如以下代码所示:
@scope
清单 24. 通过 @Scope 指定 Bean 的作用范围
package com.baobaotao; import org.springframework.context.annotation.Scope; … @Scope("prototype") @Component("boss") public class Boss {… } |
单个scope详解
1)singleton (单一实例)
此取值时表明容器中创建时只存在一个实例,所有引用此bean都是单一实例。如同每个国家都有一个总统,国家的所有人共用此总统,而这个国家就是一个spring容器,总统就是spring创建的类的bean,国家中的人就是其它调用者,总统是一个表明其在spring中的scope为singleton,也就是单例模型。
此外,singleton类型的bean定义从容器启动到第一次被请求而实例化开始,只要容器不销毁或退出,该类型的bean的单一实例就会一直存活,典型单例模式,如同servlet在web容器中的生命周期。
2)prototype
spring容器在进行输出 prototype的bean 对象时,会每次都重新生成一个新的对象给请求方,虽然这种类型的对象的实例化以及属性设置等工作都是由容器负责的,但是只要准备完毕,并且对象实例返回给请求方之后,容器就不在拥有当前对象的引用,请求方需要自己负责当前对象后继生命周期的管理工作,包括该对象的销毁。也就是说,容器每次返回请求方该对象的一个新的实例之后,就由这个对象“自生自灭”,最典型的体现就是spring与struts2进行整合时,要把action的scope改为prototype。
如同分苹果,将苹果的bean的scope属性声明为prototype,在每个人领取苹果的时候,我们都是发一个新的苹果给他,发完之后,别人爱怎么吃就怎么吃,爱什么时候吃什么时候吃,但是注意吃完要把苹果核扔到垃圾箱!对于那些不能共享使用的对象类型,应该将其定义的scope设为prototype。
3)request
再次说明 request,session和global session类型只实用于 web程序,通常是和XmlWebApplicationContext共同使用。
<bean id ="requestPrecessor" class="...RequestPrecessor" scope="request" />
Spring容器,即XmlWebApplicationContext 会为每个HTTP请求创建一个全新的RequestPrecessor对象,当请求结束后,该对象的生命周期即告结束, 如同java web中request的生命周期 。 当同时有10个HTTP请求进来的时候,容器会分别针对这10个请求创建10个全新的RequestPrecessor实例,且他们相互之间互不干扰, 简单来讲, request可以看做prototype的一种特例 ,除了场景更加具体之外,语意上差不多。
4)session
对于web应用来说,放到session中最普遍的就是用户的登录信息,对于这种放到session中的信息,我们可以使用如下形式的制定scope为session:
<bean id ="userPreferences" class="...UserPreferences" scope="session" />
Spring容器会为每个独立的session创建属于自己的全新的UserPreferences实例,比request scope的bean会存活更长的时间,其他的方面没区别, 如果java web中session的生命周期。
5)global session
<bean id ="userPreferences" class="...UserPreferences" scope="globalsession" />
global session只有应用在基于porlet的web应用程序中才有意义,它映射到porlet的global范围的session,如果普通的servlet的web 应用中使用了这个scope,容器会把它作为普通的session的scope对待。
scope配置
1)xml方式
进行bean的配置时,指定scope。
2)注解方式
提前为配置spring为注解配置
这样,当从 Spring 容器中获取 boss
Bean 时,每次返回的都是新的实例了。
@RequestMapping
RequestMapping是一个用来处理请求地址映射的注解,可用于类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。
RequestMapping注解有六个属性,下面我们把她分成三类进行说明。
1、 value, method;
value: 指定请求的实际地址,指定的地址可以是URI Template 模式(后面将会说明);
method: 指定请求的method类型, GET、POST、PUT、DELETE等;
2、 consumes,produces;
consumes: 指定处理请求的提交内容类型(Content-Type),例如application/json, text/html;
produces: 指定返回的内容类型,仅当request请求头中的(Accept)类型中包含该指定类型才返回;
3、 params,headers;
params: 指定request中必须包含某些参数值是,才让该方法处理。
headers: 指定request中必须包含某些指定的header值,才能让该方法处理请求。
value的uri值为以下三类:
A) 可以指定为普通的具体值;
B) 可以指定为含有某变量的一类值(URI Template Patterns with Path Variables);
C) 可以指定为含正则表达式的一类值( URI Template Patterns with Regular Expressions);
example B)
@RequestMapping(value="/owners/{ownerId}", method=RequestMethod.GET) public String findOwner(@PathVariable String ownerId, Model model) {Owner owner = ownerService.findOwner(ownerId); model.addAttribute("owner", owner); return "displayOwner"; }
example C)
@RequestMapping("/spring-web/{symbolicName:[a-z-]+}-{version:\d\.\d\.\d}.{extension:\.[a-z]}")public void handle(@PathVariable String version, @PathVariable String extension) { // ...} }
2 consumes、produces 示例
cousumes的样例:
@Controller @RequestMapping(value = "/pets", method = RequestMethod.POST, consumes="application/json") public void addPet(@RequestBody Pet pet, Model model) { // implementation omitted }
方法仅处理request Content-Type为“application/json”类型的请求。
produces的样例:
@Controller @RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET, produces="application/json") @ResponseBody public Pet getPet(@PathVariable String petId, Model model) { // implementation omitted }
方法仅处理request请求中Accept头中包含了"application/json"的请求,同时暗示了返回的内容类型为application/json;
3 params、headers 示例
params的样例:
@Controller @RequestMapping("/owners/{ownerId}") public class RelativePathUriTemplateController {@RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET, params="myParam=myValue")public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) { // implementation omitted} }
仅处理请求中包含了名为“myParam”,值为“myValue”的请求;
headers的样例:
@Controller @RequestMapping("/owners/{ownerId}") public class RelativePathUriTemplateController {@RequestMapping(value = "/pets", method = RequestMethod.GET, headers="Referer=http://www.ifeng.com/")public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) { // implementation omitted} }
采用具有特殊语义的注释
Spring 2.5 中除了提供 @Component
注释外,还定义了几个拥有特殊语义的注释,它们分别是:@Repository
、@Service
和@Controller
。在目前的 Spring 版本中,这 3 个注释和 @Component
是等效的,但是从注释类的命名上,很容易看出这 3 个注释分别和持久层、业务层和控制层(Web 层)相对应。虽然目前这 3 个注释和@Component
相比没有什么新意,但 Spring 将在以后的版本中为它们添加特殊的功能。所以,如果 Web 应用程序采用了经典的三层分层结构的话,最好在持久层、业务层和控制层分别采用@Repository
、@Service
和 @Controller
对分层中的类进行注释,而用@Component
对那些比较中立的类进行注释。
注释配置和 XML 配置的适用场合
是否有了这些 IOC 注释,我们就可以完全摒除原来 XML 配置的方式呢?答案是否定的。有以下几点原因:
- 注释配置不一定在先天上优于 XML 配置。如果 Bean 的依赖关系是固定的,(如 Service 使用了哪几个 DAO 类),这种配置信息不会在部署时发生调整,那么注释配置优于 XML 配置;反之如果这种依赖关系会在部署时发生调整,XML 配置显然又优于注释配置,因为注释是对 Java 源代码的调整,您需要重新改写源代码并重新编译才可以实施调整。
- 如果 Bean 不是自己编写的类(如
JdbcTemplate
、SessionFactoryBean
等),注释配置将无法实施,此时 XML 配置是唯一可用的方式。 - 注释配置往往是类级别的,而 XML 配置则可以表现得更加灵活。比如相比于
@Transaction
事务注释,使用 aop/tx 命名空间的事务配置更加灵活和简单。
所以在实现应用中,我们往往需要同时使用注释配置和 XML 配置,对于类级别且不会发生变动的配置可以优先考虑注释配置;而对于那些第三方类以及容易发生调整的配置则应优先考虑使用 XML 配置。Spring 会在具体实施 Bean 创建和 Bean 注入之前将这两种配置方式的元信息融合在一起。
---恢复内容结束---
转载于:https://www.cnblogs.com/ChrisMurphy/p/5069509.html
Spring学习(五)——Spring注解(一)相关推荐
- spring学习12 -Spring 框架模块以及面试常见问题注解等
以下为spring常见面试问题: 1.Spring 框架中都用到了哪些设计模式? Spring框架中使用到了大量的设计模式,下面列举了比较有代表性的: 代理模式-在AOP和remoting中被用的比较 ...
- Spring学习总结——Spring实现AOP的多种方式
目录 一.基于XML配置的Spring AOP 二.使用注解配置AOP 三.AspectJ切点函数 四.AspectJ通知注解 五.零配置实现Spring IoC与AOP 六.示例下载 AOP(Asp ...
- Spring学习笔记--spring+mybatis集成
前言: 技术的发展, 真的是日新月异. 作为javaer, 都不约而同地抛弃裸写jdbc代码, 而用各种持久化框架. 从hibernate, Spring的JDBCTemplate, 到ibatis, ...
- 【Spring学习】spring定时任务的实现方式
近日项目开发中需要执行一些定时任务,比如需要在每天凌晨时候,分析一次前一天的日志信息,借此机会整理了一下定时任务的几种实现方式,由于项目采用spring框架,所以我都将结合spring框架来介绍. 一 ...
- 【Spring学习】Spring简介
Spring 是一个开源框架,是为了解决企业应用程序开发复杂性而创建的.框架的主要优势之一就是其分层架构,分层架构允许您选择使用哪一个组件,同时为 J2EE 应用程序开发提供集成的框架. 一.Spri ...
- 【Spring学习】spring开发包介绍
spring.jar是包含有完整发布的单个jar包,spring.jar中包含除了 spring-mock.jar里所包含的内容外其它所有jar包的内容,因为只有在开发环境下才会用到spring-mo ...
- 【Spring学习】Spring自定义标签详细步骤
目录标题 前言 一.自定义标签步骤 1.定义属性POJO 2.定义XSD文件描述组件内容 3.定义标签解析器 4.注册标签解析器 5.定义spring.handlers和spring.schemas文 ...
- Spring学习:Spring的IOC注解
文章目录 一.简介 二.IOC注解 (一)常用的注解 (二)扫描包 (三)数据装配 三.生命周期 四.Bean实例化的时机 五.Bean在IOC容器中单例和多例 六.SpringIOC注解完整示例代码 ...
- 【Spring学习】spring注解自动注入bean
Spring mvc注解用到的配置: <!-- 启用spring mvc 注解 --> <context:annotation-config /> <context:co ...
- 【spring学习】Spring bean生命周期及注解
Spring Spring是分层的javaSE/EE轻量级开源框架,以IOC(控制翻转)和AOP(面向切面编程)为内核 分层:web层:SpringMvc持久层:JDBC Template业务层:Sp ...
最新文章
- 【译】Withdrawal symptoms
- 导入依赖和加上注释后,lombok gettersetter识别不到
- 启动SecureCRT出现ImportError: No module named _sysconfigdata_nd
- [初级]Java中的switch对整型、字符型、字符串的具体实现细节
- Spring Bean的生命周期以及IOC源码解析
- 使用Spring Boot开发者工具进行自动重启和页面自动刷新
- 力扣剑指 Offer 17. 打印从1到最大的n位数
- bst java_图解:二叉搜索树算法(BST)
- 无显示仍然发挥树莓派——VNCserver设定
- ‘python3\r’: No such file or directory
- 读jquery 权威指南[4]-Ajax
- Unity Contrib Project和资料
- dubbo服务RpcException异常:Tried 3 times of the providers 或com.alibaba.dubbo.remoting.TimeoutException
- Hibernate的单向1-1关联(二)
- hdu 1099 Lottery
- 【优化选址】基于matlab蚁群算法求解电动汽车充电站与换电站选址优化问题【含Matlab源码 1182期】
- sp2 xp 英文版序列号_64位 Windows XP SP2 VOL+简体中文语言包+序列号
- win8修复计算机u盘,Win8系统U盘里的文件不见了怎么办?
- JavaScript设计模式----策略模式
- 《太上感应篇》告诉我们,人的起心动念都得小心啊,哈哈。