Spring Bean装配详解(五)
装配 Bean 的概述
前面已经介绍了 Spring IoC 的理念和设计,这一篇文章将介绍的是如何将自己开发的 Bean 装配到 Spring IoC 容器中。
大部分场景下,我们都会使用 ApplicationContext 的具体实现类,因为对应的 Spring IoC 容器功能相对强大。
而在 Spring 中提供了 3 种方法进行配置:
- 在 XML 文件中显式配置
- 在 Java 的接口和类中实现配置
- 隐式 Bean 的发现机制和自动装配原则
方式选择的原则
在现实的工作中,这 3 种方式都会被用到,并且在学习和工作之中常常混合使用,所以这里给出一些关于这 3 种优先级的建议:
1.最优先:通过隐式 Bean 的发现机制和自动装配的原则。
基于约定由于配置的原则,这种方式应该是最优先的
- 好处:减少程序开发者的决定权,简单又不失灵活。
2.其次:Java 接口和类中配置实现配置
在没有办法使用自动装配原则的情况下应该优先考虑此类方法
- 好处:避免 XML 配置的泛滥,也更为容易。
- 典型场景:一个父类有多个子类,比如学生类有两个子类,一个男学生类和女学生类,通过 IoC 容器初始化一个学生类,容器将无法知道使用哪个子类去初始化,这个时候可以使用 Java 的注解配置去指定。
3.最后:XML 方式配置
在上述方法都无法使用的情况下,那么也只能选择 XML 配置的方式。
- 好处:简单易懂(当然,特别是对于初学者)
- 典型场景:当使用第三方类的时候,有些类并不是我们开发的,我们无法修改里面的代码,这个时候就通过 XML 的方式配置使用了。
通过 XML 配置装配 Bean
使用 XML 装配 Bean 需要定义对应的 XML,这里需要引入对应的 XML 模式(XSD)文件,这些文件会定义配置 Spring Bean 的一些元素,当我们在 IDEA 中创建 XML 文件时,会有友好的提示:
一个简单的 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.xsd">
</beans>
这就只是一个格式文件,引入了一个 beans 的定义,引入了 xsd 文件,它是一个根元素,这样它所定义的元素将可以定义对应的 Spring Bean
装配简易值
先来一个最简单的装配:
<bean id="c" class="pojo.Category">
<property name="name" value="测试" />
</bean>
简单解释一下:
id
属性是 Spring 能找到当前 Bean 的一个依赖的编号,遵守 XML 语法的 ID 唯一性约束。必须以字母开头,可以使用字母、数字、连字符、下划线、句号、冒号,不能以/
开头。
不过id
属性不是一个必需的属性,name
属性也可以定义 bean 元素的名称,能以逗号或空格隔开起多个别名,并且可以使用很多的特殊字符,比如在 Spring 和 Spring MVC 的整合中,就得使用name
属性来定义 bean 的名称,并且使用/
开头。
注意: 从 Spring 3.1 开始,id
属性也可以是 String 类型了,也就是说id
属性也可以使用/
开头,而 bean 元素的 id 的唯一性由容器负责检查。
如果id
和name
属性都没有声明的话,那么 Spring 将会采用 “全限定名#{number}” 的格式生成编号。 例如这里,如果没有声明 “id="c"
” 的话,那么 Spring 为其生成的编号就是 “pojo.Category#0
”,当它第二次声明没有id
属性的 Bean 时,编号就是 “pojo.Category#1
”,以此类推。class
属性显然就是一个类的全限定名property
元素是定义类的属性,其中的name
属性定义的是属性的名称,而value
是它的值。
这样的定义很简单,但是有时候需要注入一些自定义的类,比如之前饮品店的例子,JuickMaker 需要用户提供原料信息才能完成 juice 的制作:
<!-- 配置 srouce 原料 -->
<bean name="source" class="pojo.Source">
<property name="fruit" value="橙子"/>
<property name="sugar" value="多糖"/>
<property name="size" value="超大杯"/>
</bean>
<bean name="juickMaker" class="pojo.JuiceMaker">
<!-- 注入上面配置的id为srouce的Srouce对象 -->
<property name="source" ref="source"/>
</bean>
这里先定义了一个 name
为 source 的 Bean,然后再制造器中通过 ref
属性去引用对应的 Bean,而 source 正是之前定义的 Bean 的 name
,这样就可以相互引用了。
- 注入对象:使用
ref
属性
装配集合
有些时候我们需要装配一些复杂的东西,比如 Set、Map、List、Array 和 Properties 等,为此我们在 Packge【pojo】下新建一个 ComplexAssembly 类:
package pojo;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class ComplexAssembly {
private Long id;
private List<String> list;
private Map<String, String> map;
private Properties properties;
private Set<String> set;
private String[] array;
/* setter and getter */
}
这个 Bean 没有任何的实际意义,知识为了介绍如何装配这些常用的集合类:
<bean id="complexAssembly" class="pojo.ComplexAssembly">
<!-- 装配Long类型的id -->
<property name="id" value="1"/>
<!-- 装配List类型的list -->
<property name="list">
<list>
<value>value-list-1</value>
<value>value-list-2</value>
<value>value-list-3</value>
</list>
</property>
<!-- 装配Map类型的map -->
<property name="map">
<map>
<entry key="key1" value="value-key-1"/>
<entry key="key2" value="value-key-2"/>
<entry key="key3" value="value-key-2"/>
</map>
</property>
<!-- 装配Properties类型的properties -->
<property name="properties">
<props>
<prop key="prop1">value-prop-1</prop>
<prop key="prop2">value-prop-2</prop>
<prop key="prop3">value-prop-3</prop>
</props>
</property>
<!-- 装配Set类型的set -->
<property name="set">
<set>
<value>value-set-1</value>
<value>value-set-2</value>
<value>value-set-3</value>
</set>
</property>
<!-- 装配String[]类型的array -->
<property name="array">
<array>
<value>value-array-1</value>
<value>value-array-2</value>
<value>value-array-3</value>
</array>
</property>
</bean>
- 总结:
- List 属性为对应的
<list>
元素进行装配,然后通过多个<value>
元素设值 - Map 属性为对应的
<map>
元素进行装配,然后通过多个<entry>
元素设值,只是entry
包含一个键值对(key-value)的设置 - Properties 属性为对应的
<properties>
元素进行装配,通过多个<property>
元素设值,只是properties
元素有一个必填属性key
,然后可以设置值 - Set 属性为对应的
<set>
元素进行装配,然后通过多个<value>
元素设值 - 对于数组而言,可以使用
<array>
设置值,然后通过多个<value>
元素设值。
上面看到了对简单 String 类型的各个集合的装载,但是有些时候可能需要更为复杂的装载,比如一个 List 可以是一个系列类的对象,为此需要定义注入的相关信息,其实跟上面的配置没什么两样,只不过加入了 ref
这一个属性而已:
- 集合注入总结:
- List 属性使用
<list>
元素定义注入,使用多个<ref>
元素的 Bean 属性去引用之前定义好的 Bean
<property name="list">
<list>
<ref bean="bean1"/>
<ref bean="bean2"/>
</list>
</property>
- Map 属性使用
<map>
元素定义注入,使用多个<entry>
元素的key-ref
属性去引用之前定义好的 Bean 作为键,而用value-ref
属性引用之前定义好的 Bean 作为值
<property name="map">
<map>
<entry key-ref="keyBean" value-ref="valueBean"/>
</map>
</property>
- Set 属性使用
<set>
元素定义注入,使用多个<ref>
元素的bean
去引用之前定义好的 Bean
<property name="set">
<set>
<ref bean="bean"/>
</set>
</property>
命名空间装配
除了上述的配置之外, Spring 还提供了对应的命名空间的定义,只是在使用命名空间的时候要先引入对应的命名空间和 XML 模式(XSD)文件。
——【① c-命名空间】——
c-命名空间是在 Spring 3.0 中引入的,它是在 XML 中更为简洁地描述构造器参数的方式,要使用它的话,必须要在 XML 的顶部声明其模式:
- 注意:是通过构造器参数的方式
现在假设我们现在有这么一个类:
package pojo;
public class Student {
int id;
String name;
public Student(int id, String name) {
this.id = id;
this.name = name;
}
// setter and getter
}
在 c-命名空间和模式声明之后,我们就可以使用它来声明构造器参数了:
<!-- 引入 c-命名空间之前 -->
<bean name="student1" class="pojo.Student">
<constructor-arg name="id" value="1" />
<constructor-arg name="name" value="学生1"/>
</bean>
<!-- 引入 c-命名空间之后 -->
<bean name="student2" class="pojo.Student"
c:id="2" c:name="学生2"/>
c-命名空间属性名以 “c:
” 开头,也就是命名空间的前缀。接下来就是要装配的构造器参数名,在此之后如果需要注入对象的话则要跟上 -ref
(如c:card-ref="idCard1"
,则对 card 这个构造器参数注入之前配置的名为 idCard1 的 bean)
很显然,使用 c-命名空间属性要比使用 <constructor-arg>
元素精简,并且会直接引用构造器之中参数的名称,这有利于我们使用的安全性。
我们有另外一种替代方式:
<bean name="student2" class="pojo.Student"
c:_0="3" c:_1="学生3"/>
我们将参数的名称替换成了 “0” 和 “1” ,也就是参数的索引。因为在 XML 中不允许数字作为属性的第一个字符,因此必须要添加一个下划线来作为前缀。
——【② p-命名空间】——
c-命名空间通过构造器注入的方式来配置 bean,p-命名空间则是用setter的注入方式来配置 bean ,同样的,我们需要引入声明:
然后我们就可以通过 p-命名空间来设置属性:
<!-- 引入p-命名空间之前 -->
<bean name="student1" class="pojo.Student">
<property name="id" value="1" />
<property name="name" value="学生1"/>
</bean>
<!-- 引入p-命名空间之后 -->
<bean name="student2" class="pojo.Student"
p:id="2" p:name="学生2"/>
我们需要先删掉 Student 类中的构造函数,不然 XML 约束会提示我们配置 <constructor-arg>
元素。
同样的,如果属性需要注入其他 Bean 的话也可以在后面跟上 -ref
:
<bean name="student2" class="pojo.Student"
p:id="2" p:name="学生2" p:cdCard-ref="cdCard1"/>
——【③ util-命名空间】——
工具类的命名空间,可以简化集合类元素的配置,同样的我们需要引入其声明(无需担心怎么声明的问题,IDEA会有很友好的提示):
我们来看看引入前后的变化:
<!-- 引入util-命名空间之前 -->
<property name="list">
<list>
<ref bean="bean1"/>
<ref bean="bean2"/>
</list>
</property>
<!-- 引入util-命名空间之后 -->
<util:list id="list">
<ref bean="bean1"/>
<ref bean="bean2"/>
</util:list>
<util:list>
只是 util-命名空间中的多个元素之一,下表提供了 util-命名空间提供的所有元素:
元素 | 描述 |
---|---|
<util:constant> |
引用某个类型的 public static 域,并将其暴露为 bean |
<util:list> |
创建一个 java.util.List 类型的 bean,其中包含值或引用 |
<util:map> |
创建一个 java.util.map 类型的 bean,其中包含值或引用 |
<util:properties> |
创建一个 java.util.Properties 类型的 bean |
<util:property-path> |
引用一个 bean 的属性(或内嵌属性),并将其暴露为 bean |
<util:set> |
创建一个 java.util.Set 类型的 bean,其中包含值或引用 |
引入其他配置文件
在实际开发中,随着应用程序规模的增加,系统中 <bean>
元素配置的数量也会大大增加,导致 applicationContext.xml 配置文件变得非常臃肿难以维护。
- 解决方案:让 applicationContext.xml 文件包含其他配置文件即可
使用<import>
元素引入其他配置文件
1.在【src】文件下新建一个 bean.xml 文件,写好基础的约束,把 applicationContext.xml 文件中配置的 <bean>
元素复制进去
2.在 applicationContext.xml 文件中写入:
<import resource="bean.xml" />
3.运行测试代码,仍然能正确获取到 bean:
通过注解装配 Bean
上面,我们已经了解了如何使用 XML 的方式去装配 Bean,但是更多的时候已经不再推荐使用 XML 的方式去装配 Bean,更多的时候回考虑使用注解(annotation) 的方式去装配 Bean。
- 优势:
1.可以减少 XML 的配置,当配置项多的时候,臃肿难以维护
2.功能更加强大,既能实现 XML 的功能,也提供了自动装配的功能,采用了自动装配后,程序猿所需要做的决断就少了,更加有利于对程序的开发,这就是“约定由于配置”的开发原则
在 Spring 中,它提供了两种方式来让 Spring IoC 容器发现 bean:
- 组件扫描:通过定义资源的方式,让 Spring IoC 容器扫描对应的包,从而把 bean 装配进来。
- 自动装配:通过注解定义,使得一些依赖关系可以通过注解完成。
使用@Compoent 装配 Bean
我们把之前创建的 Student 类改一下:
package pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component(value = "student1")
public class Student {
@Value("1")
int id;
@Value("student_name_1")
String name;
// getter and setter
}
解释一下:
- @Component注解:
表示 Spring IoC 会把这个类扫描成一个 bean 实例,而其中的value
属性代表这个类在 Spring 中的id
,这就相当于在 XML 中定义的 Bean 的 id:<bean id="student1" class="pojo.Student" />
,也可以简写成@Component("student1")
,甚至直接写成@Component
,对于不写的,Spring IoC 容器就默认以类名来命名作为id
,只不过首字母小写,配置到容器中。 - @Value注解:
表示值的注入,跟在 XML 中写value
属性是一样的。
这样我们就声明好了我们要创建的一个 Bean,就像在 XML 中写下了这样一句话:
<bean name="student1" class="pojo.Student">
<property name="id" value="1" />
<property name="name" value="student_name_1"/>
</bean>
但是现在我们声明了这个类,并不能进行任何的测试,因为 Spring IoC 并不知道这个 Bean 的存在,这个时候我们可以使用一个 StudentConfig 类去告诉 Spring IoC :
package pojo;
import org.springframework.context.annotation.ComponentScan;
@ComponentScan
public class StudentConfig {
}
这个类十分简单,没有任何逻辑,但是需要说明两点:
- 该类和 Student 类位于同一包名下
- @ComponentScan注解:
代表进行扫描,默认是扫描当前包的路径,扫描所有带有@Component
注解的 POJO。
这样一来,我们就可以通过 Spring 定义好的 Spring IoC 容器的实现类——AnnotationConfigApplicationContext 去生成 IoC 容器了:
ApplicationContext context = new AnnotationConfigApplicationContext(StudentConfig.class);
Student student = (Student) context.getBean("student1", Student.class);
student.printInformation();
这里可以看到使用了 AnnotationConfigApplicationContext 类去初始化 Spring IoC 容器,它的配置项是 StudentConfig 类,这样 Spring IoC 就会根据注解的配置去解析对应的资源,来生成 IoC 容器了。
- 明显的弊端:
- 对于
@ComponentScan
注解,它只是扫描所在包的 Java 类,但是更多的时候我们希望的是可以扫描我们指定的类 - 上面的例子只是注入了一些简单的值,测试发现,通过
@Value
注解并不能注入对象
@Component
注解存在着两个配置项:
- basePackages:它是由 base 和 package 两个单词组成的,而 package 还是用了复数,意味着它可以配置一个 Java 包的数组,Spring 会根据它的配置扫描对应的包和子包,将配置好的 Bean 装配进来
- basePackageClasses:它由 base、package 和 class 三个单词组成,采用复数,意味着它可以配置多个类, Spring 会根据配置的类所在的包,为包和子包进行扫描装配对应配置的 Bean
我们来试着重构之前写的 StudentConfig 类来验证上面两个配置项:
package pojo;
import org.springframework.context.annotation.ComponentScan;
@ComponentScan(basePackages = "pojo")
public class StudentConfig {
}
// —————————————————— 【 宇宙超级无敌分割线】——————————————————
package pojo;
import org.springframework.context.annotation.ComponentScan;
@ComponentScan(basePackageClasses = pojo.Student.class)
public class StudentConfig {
}
验证都能通过,bingo!
- 对于 【basePackages】 和 【basePackageClasses】 的选择问题:
【basePackages】 的可读性会更好一些,所以在项目中会优先选择使用它,但是在需要大量重构的工程中,尽量不要使用【basePackages】,因为很多时候重构修改包名需要反复地配置,而 IDE 不会给你任何的提示,而采用【basePackageClasses】会有错误提示。
自动装配——@Autowired
上面提到的两个弊端之一就是没有办法注入对象,通过自动装配我们将解决这个问题。
所谓自动装配技术是一种由 Spring 自己发现对应的 Bean,自动完成装配工作的方式,它会应用到一个十分常用的注解 @Autowired
上,这个时候 Spring 会根据类型去寻找定义的 Bean 然后将其注入,听起来很神奇,让我们实际来看一看:
1.先在 Package【service】下创建一个 StudentService 接口:
package service;
public interface StudentService {
public void printStudentInfo();
}
使用接口是 Spring 推荐的方式,这样可以更为灵活,可以将定义和实现分离
2.为上面的接口创建一个 StudentServiceImp 实现类:
package service;
import org.springframework.beans.factory.annotation.Autowired;
import pojo.Student;
@Component("studentService")
public class StudentServiceImp implements StudentService {
@Autowired
private Student student = null;
// getter and setter
public void printStudentInfo() {
System.out.println("学生的 id 为:" + student.getName());
System.out.println("学生的 name 为:" + student.getName());
}
}
该实现类实现了接口的 printStudentInfo() 方法,打印出成员对象 student 的相关信息,这里的 @Autowired
注解,表示在 Spring IoC 定位所有的 Bean 后,这个字段需要按类型注入,这样 IoC 容器就会寻找资源,然后将其注入。
3.编写测试类:
// 第一步:修改 StudentConfig 类,告诉 Spring IoC 在哪里去扫描它:
package pojo;
import org.springframework.context.annotation.ComponentScan;
@ComponentScan(basePackages = {"pojo", "service"})
public class StudentConfig {
}
// 或者也可以在 XML 文件中声明去哪里做扫描
<context:component-scan base-package="pojo" />
<context:component-scan base-package="service" />
// 第二步:编写测试类:
package test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import pojo.StudentConfig;
import service.StudentService;
import service.StudentServiceImp;
public class TestSpring {
public static void main(String[] args) {
// 通过注解的方式初始化 Spring IoC 容器
ApplicationContext context = new AnnotationConfigApplicationContext(StudentConfig.class);
StudentService studentService = context.getBean("studentService", StudentServiceImp.class);
studentService.printStudentInfo();
}
}
运行代码:
- 再次理解:
@Autowired
注解表示在 Spring IoC 定位所有的 Bean 后,再根据类型寻找资源,然后将其注入。 - 过程: 定义 Bean ——》 初始化 Bean(扫描) ——》 根据属性需要从 Spring IoC 容器中搜寻满足要求的 Bean ——》 满足要求则注入
- 问题: IoC 容器可能会寻找失败,此时会抛出异常(默认情况下,Spring IoC 容器会认为一定要找到对应的 Bean 来注入到这个字段,但有些时候并不是一定需要,比如日志)
- 解决: 通过配置项
required
来改变,比如@Autowired(required = false)
@Autowired
注解不仅仅能配置在属性之上,还允许方法配置,常见的 Bean 的 setter 方法也可以使用它来完成注入,总之一切需要 Spring IoC 去寻找 Bean 资源的地方都可以用到,例如:
/* 包名和import */
public class JuiceMaker {
......
@Autowired
public void setSource(Source source) {
this.source = source;
}
}
在大部分的配置中都推荐使用这样的自动注入来完成,这是 Spring IoC 帮助我们自动装配完成的,这样使得配置大幅度减少,满足约定优于配置的原则,增强程序的健壮性。
自动装配的歧义性(@Primary和@Qualifier)
在上面的例子中我们使用 @Autowired
注解来自动注入一个 Source 类型的 Bean 资源,但如果我们现在有两个 Srouce 类型的资源,Spring IoC 就会不知所措,不知道究竟该引入哪一个 Bean:
<bean name="source1" class="pojo.Source">
<property name="fruit" value="橙子"/>
<property name="sugar" value="多糖"/>
<property name="size" value="超大杯"/>
</bean>
<bean name="source2" class="pojo.Source">
<property name="fruit" value="橙子"/>
<property name="sugar" value="少糖"/>
<property name="size" value="小杯"/>
</bean>
我们可以会想到 Spring IoC 最底层的容器接口——BeanFactory 的定义,它存在一个按照类型获取 Bean 的方法,显然通过 Source.class 作为参数无法判断使用哪个类实例进行返回,这就是自动装配的歧义性。
为了消除歧义性,Spring 提供了两个注解:
- @Primary 注解:
代表首要的,当 Spring IoC 检测到有多个相同类型的 Bean 资源的时候,会优先注入使用该注解的类。 - 问题:该注解只是解决了首要的问题,但是并没有选择性的问题
- @Qualifier 注解:
上面所谈及的歧义性,一个重要的原因是 Spring 在寻找依赖注入的时候是按照类型注入引起的。除了按类型查找 Bean,Spring IoC 容器最底层的接口 BeanFactory 还提供了按名字查找的方法,如果按照名字来查找和注入不就能消除歧义性了吗? - 使用方法: 指定注入名称为 "source1" 的 Bean 资源
/* 包名和import */
public class JuiceMaker {
......
@Autowired
@Qualifier("source1")
public void setSource(Source source) {
this.source = source;
}
}
使用@Bean 装配 Bean
- 问题: 以上都是通过
@Component
注解来装配 Bean ,并且只能注解在类上,当你需要引用第三方包的(jar 文件),而且往往并没有这些包的源码,这时候将无法为这些包的类加入@Component
注解,让它们变成开发环境中的 Bean 资源。 - 解决方案:
1.自己创建一个新的类来扩展包里的类,然后再新类上使用@Component
注解,但这样很 low
2.使用@Bean
注解,注解到方法之上,使其成为 Spring 中返回对象为 Spring 的 Bean 资源。
我们在 Package【pojo】 下新建一个用来测试 @Bean
注解的类:
package pojo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class BeanTester {
@Bean(name = "testBean")
public String test() {
String str = "测试@Bean注解";
return str;
}
}
- 注意:
@Configuration
注解相当于 XML 文件的根元素,必须要,有了才能解析其中的@Bean
注解
然后我们在测试类中编写代码,从 Spring IoC 容器中获取到这个 Bean :
// 在 pojo 包下扫描
ApplicationContext context = new AnnotationConfigApplicationContext("pojo");
// 因为这里获取到的 Bean 就是 String 类型所以直接输出
System.out.println(context.getBean("testBean"));
@Bean
的配置项中包含 4 个配置项:
- name: 是一个字符串数组,允许配置多个 BeanName
- autowire: 标志是否是一个引用的 Bean 对象,默认值是 Autowire.NO
- initMethod: 自定义初始化方法
- destroyMethod: 自定义销毁方法
使用 @Bean
注解的好处就是能够动态获取一个 Bean 对象,能够根据环境不同得到不同的 Bean 对象。或者说将 Spring 和其他组件分离(其他组件不依赖 Spring,但是又想 Spring 管理生成的 Bean)
Bean 的作用域
在默认的情况下,Spring IoC 容器只会对一个 Bean 创建一个实例,但有时候,我们希望能够通过 Spring IoC 容器获取多个实例,我们可以通过 @Scope
注解或者 <bean>
元素中的 scope
属性来设置,例如:
// XML 中设置作用域
<bean id="" class="" scope="prototype" />
// 使用注解设置作用域
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
Spring 提供了 5 种作用域,它会根据情况来决定是否生成新的对象:
作用域类别 | 描述 |
---|---|
singleton(单例) | 在Spring IoC容器中仅存在一个Bean实例 (默认的scope) |
prototype(多例) | 每次从容器中调用Bean时,都返回一个新的实例,即每次调用getBean()时 ,相当于执行new XxxBean():不会在容器启动时创建对象 |
request(请求) | 用于web开发,将Bean放入request范围 ,request.setAttribute("xxx") , 在同一个request 获得同一个Bean |
session(会话) | 用于web开发,将Bean 放入Session范围,在同一个Session 获得同一个Bean |
globalSession(全局会话) | 一般用于 Porlet 应用环境 , 分布式系统存在全局 session 概念(单点登录),如果不是 porlet 环境,globalSession 等同于 Session |
在开发中主要使用 scope="singleton"
、scope="prototype"
,对于MVC中的Action使用prototype类型,其他使用singleton,Spring容器会管理 Action 对象的创建,此时把 Action 的作用域设置为 prototype.
扩展阅读:@Profile 注解 、 条件化装配 Bean
Spring 表达式语言简要说明
Spring 还提供了更灵活的注入方式,那就是 Spring 表达式,实际上 Spring EL 远比以上注入方式都要强大,它拥有很多功能:
- 使用 Bean 的 id 来引用 Bean
- 调用指定对象的方法和访问对象的属性
- 进行运算
- 提供正则表达式进行匹配
- 集合配置
我们来看一个简单的使用 Spring 表达式的例子:
package pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component("elBean")
public class ElBean {
// 通过 beanName 获取 bean,然后注入
@Value("#{role}")
private Role role;
// 获取 bean 的属性 id
@Value("#{role.id}")
private Long id;
// 调用 bean 的 getNote 方法
@Value("#{role.getNote().toString()}")
private String note;
/* getter and setter */
}
与属性文件中读取使用的 “$
” 不同,在 Spring EL 中则使用 “#
”
Spring Bean装配详解(五)的更多相关文章
- Spring学习(五)bean装配详解之 【XML方式配置】
一.配置Bean的方式及选择 配置方式 在 XML 文件中显式配置 在 Java 的接口和类中实现配置 隐式 Bean 的发现机制和自动装配原则 方式选择的原则 最优先:通过隐式 Bean 的发现机制 ...
- Spring对Bean装配详解
1.Spring提供了三种装配bean的方式: 2.自动装配bean: 3.通过Java代码装配bean 4.通过XML装配bean 前言:创建对象的协作关系称为装配,也就是DI(依赖注入)的本质.而 ...
- Spring学习(七)bean装配详解之 【通过注解装配 Bean】【自动装配的歧义解决】
自动装配 1.歧义性 我们知道用@Autowired可以对bean进行注入(按照type注入),但如果有两个相同类型的bean在IOC容器中注册了,要怎么去区分对哪一个Bean进行注入呢? 如下情况, ...
- Spring学习(六)bean装配详解之 【通过注解装配 Bean】【基础配置方式】
通过注解装配 Bean 1.前言 优势 1.可以减少 XML 的配置,当配置项多的时候,XML配置过多会导致项目臃肿难以维护 2.功能更加强大,既能实现 XML 的功能,也提供了自动装配的功能,采用了 ...
- Spring框架学习03——Spring Bean 的详解
1.Bean 的配置 Spring可以看做一个大型工厂,用于生产和管理Spring容器中的Bean,Spring框架支持XML和Properties两种格式的配置文件,在实际开发中常用XML格式的配置 ...
- Spring bean - scope详解
Scope是定义Spring如何创建bean的实例的. 在创建bean的时候可以带上scope属性,scope有下面几种类型. Singleton 这也是Spring默认的scope,表示Spring ...
- spring事务管理(详解和实例)
原文地址: 参考地址:https://blog.csdn.net/yuanlaishini2010/article/details/45792069 写这篇博客之前我首先读了<Spring in ...
- spring事务配置详解
一.前言 好几天没有在对spring进行学习了,由于这几天在赶项目,没有什么时间闲下来继续学习,导致spring核心架构详解没有继续下去,在接下来的时间里面,会继续对spring的核心架构在继续进行学 ...
- (转)Spring事务管理详解
背景:之前一直在学习数据库中的相关事务,而忽略了spring中的事务配置,在阿里面试时候基本是惨败,这里做一个总结. 可能是最漂亮的Spring事务管理详解 https://github.com/Sn ...
随机推荐
- CF2B The least round way(贪心+动规)
题目 CF2B The least round way 做法 后面\(0\)的个数,\(2\)和\(5\)是\(10\)分解质因数 则把方格中的每个数分解成\(2\)和\(5\),对\(2\)和\(5 ...
- [APIO2017]商旅——分数优化+floyd+SPFA判负环+二分答案
题目链接: [APIO2017]商旅 枚举任意两个点$(s,t)$,求出在$s$买入一个物品并在$t$卖出的最大收益. 新建一条从$s$到$t$的边,边权为最大收益,长度为原图从$s$到$t$的最短路 ...
- 实现Runnable接口方式
package com.roocon.thread.t2; public class Demo2 implements Runnable { @Override public void run() { ...
- Wireshark 用户指南(3.1.0)
目 录 Preface 序 1. Foreword 前言 2. Who should read this document? 谁适合读该文档? 3. Acknowledgements 致谢 4. Ab ...
- JAVA基础知识|Executors提供的四种线程池
一.Thread与Executors 开启新的线程,我们经常会采用如下方法: Thread thread =new Thread(new Runnable() { @Override public v ...
- 如何在vue-cli 3.x中使用jquery
由于项目需求要使用jquery,结果各种引用都不济于事. 最后在网上找到了答案,现把它记录一下,给有需要者. 首先下载 jquery. cnpm install jquery --save-dev 方 ...
- Python Re 模块超全解读
re模块下的函数 compile(pattern):创建模式对象 import re pat=re.compile('A') m=pat.search('CBA') #等价于 re.search('A ...
- 阶段5 3.微服务项目【学成在线】_day17 用户认证 Zuul_16-网关-过虑器
4.5 过虑器 Zuul的核心就是过虑器,通过过虑器实现请求过虑,身份校验等. 4.5.1 ZuulFilter 自定义过虑器需要继承 ZuulFilter,ZuulFilter是一个抽象类,需要覆盖 ...
- 123467123456#1#-----com.twoapp.DaDiShuGame01--前拼后广--现实打地鼠游戏jiemei
com.twoapp.DaDiShuGame01--前拼后广--现实打地鼠游戏jiemei
- 123456---com.twoapp.xiaoxiaozuqiujiang---小小足球将
com.twoapp.xiaoxiaozuqiujiang---小小足球将