spring装配bean

概述

spring 的核心依赖注入:创建应用对象之间协作关系的行为称为装配(wiring),他有以下几种方式:

  • 自动装配(结合注解)
  • Java中显示的配置
  • 在xml中显示的配置

这三个方案,选哪一个都是可以的,能用自动配置的就有自动配置,对于一些框架的配置我们不能修改别人的源码,必要的xml显示配置也是必要的,而且我们也可以三个方案同时使用,一些Bean自动装配,一些Bean Java配置,一些Bean xml配置。
对于显示配置,多少有些不方便还是自动装配最简便,所以我们先讲第一个自动化配置

创建项目

我们首先新建一个meavn项目,我这里用的是idea,推荐大家使用,超爽的开发工具。
添加spring 和 test需要的依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.2.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>3.2.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>3.2.0.RELEASE</version>
<type>jar</type>
</dependency>

源码均在github上可以获取,地址会在文末给出,欢迎加Start

自动化配置

创建bean

spring实现自动装配的方式: 通过组建扫描发现应用上下文所创建的bean并通过自动装配创建bean的依赖关系。

  1. 组件扫描 component-scan
  2. 自动装配 Autowire

在当今社会中,交通工具有多种多样,比如公交车、火车、飞机等。人们可以乘坐不同的司机驾驶的不同交通工具来出行。为了演示spring的实例,我们先建立Car接口:

1
2
3
4
5
6
7
/**
* author yalunwang
* 车抽象接口
*/
public interface Car {
void notice();
}

其中notice方法代表车到站提醒。这样任意的交通工具都可实现接口Car,代码降低耦合。
这里我们先定义一个BusCar(公交车):

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* author yalunwang
* 公交车
*/
@Component
public class BusCar implements Car {
private String carName="浦东25路";
@Override
public void notice() {
System.out.println(this.carName+"南京西路到了");
}
}

@Component注解会告诉spring此类需要spring 创建该bean注册到 ioc容器中。因为组件扫描默认是不开启的,所以我们需要开启扫描,这样spring才会去寻找带有@Component的类并创建该bean。spring创建bean的时候都会给定一个ID,BusCar类的ID默认为busCar,会把类名的第一个变为小写。如果想指定ID为bus的可以这样写:@Component(value = “bus”)或@Component(“bus”)。]

告知spring开启自动扫描有两种办法:

  1. 在xml里配置
  2. 在javaconfig里配置

首先来看xml:

1
2
3
4
5
6
7
<?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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.yalunwang.autowiring"></context:component-scan>
</beans>

元素就是开启自动扫描,其中的base-package是告诉spring扫描com.yalunwang.autowiring包以及其下的所有子包中带有@Component注解的类,并为之创建。

我们再来看在java配置类里如何配置:

1
2
3
4
@Configuration
@ComponentScan(basePackages = "com.yalunwang.autowiring")
public class PeopleCarConfig {
}

@ComponentScan与xml中的 起到相同的作用。其中如果不加basePackages ,即表示以此配置类所在的包。

我们可以在单元测试里测试一下:

1
2
3
4
5
6
7
8
9
10
11
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = PeopleCarConfig.class)
public class TestCar {
@Autowired
private BusCar busCar;
@Test
public void testCar()
{
System.out.println(busCar);
}
}

结果输出: com.yalunwang.autowiring.BusCar@1c3d5104

  • @RunWith(SpringJUnit4ClassRunner.class) 会自动创建spring上下文
  • @ContextConfiguration 加载配置
  • @Autowired 注入同类型的实例

从结果中我们可以看出BusCar被spring创建。我们的自动扫描成功了。

自动装配

自动装配就是让spring自动将bean依赖的其他bean注入进去。我们可以使用@Autowired,在上文中的单元测试中我们刚刚使用了。为了演示自动装配我们再新建一个People接口用来抽象人类。

1
2
3
4
5
6
7
/**
* author yalunwang
* 人类抽象接口
*/
public interface People {
void drive();
}

drive代表驾驶。
我们再创建一个Man来实现此接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
* author yalunwang
* 男人
*/
@Component
public class Man implements People {
private String userName ="小明";
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
@Autowired
private Car car;
@Override
public void drive() {
//System.out.println("driver:");
System.out.println("男司机:" + this.userName);
car.notice();
}
}

drive:要想使车可以跑起来我们需要一个司机,司机驾驶车辆,并提醒乘客到达哪一站了。
所以我们的Man bean现在依赖于Car bean,这时我们再car字段添加注解@Autowired就会自动将Carbean注入进来。

这里注入的方式有很多种可以放到构造器,set方法,字段、其他方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Autowired
private Car car;
private Car car1;
//构造器注入
@Autowired
public Man(Car car) {
this.car1=car;
}
private Car car2;
public Car getCar2() {
return car2;
}
//set方法注入
@Autowired
public void setCar2(Car car2) {
this.car2 = car2;
}

下面我来验证一下

1
2
3
4
5
6
7
8
9
10
11
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = PeopleCarConfig.class)
public class TestPeople {
@Autowired
private People people;
@Test
public void test() {
people.drive();
}
}

输出:

1
2
男司机:小明
浦东25路南京西路到了

这里可以看出我们的自动装配是通过了。自动扫描配置Bean先告一段落。

Java代码中配置

javaconfig类需要添加@@Configuration 注解,要在显示的配置bean我们需要使用@Bean注解

1
2
3
4
5
6
7
8
9
@Configuration
public class PeopleCarConfig {
@Bean
public Car busCar()
{
return new BusCar();
}
}

@Bean注解会告诉spring这个方法将返回一个一个对象,并且要注册到spring上下文中。方法体力包含了最终产生bean实例的逻辑。Bean的ID默认是方法的名字,可以通过 @Bean(name=”busCar”)指定自定义的名字。

装配

我们知道人需要开车,Man依赖Car,那么我们如何将car注入到man中呢。

1
2
3
4
5
@Bean(name="man")
public People man()
{
return new Man( busCar());
}

这样通过使用一个Car类型的实例对象BusCar的构造器构建Man实例,这里需要注意的是busCar()并非实际的方法调用,因为这个方法上加了@Bean注解,spring会拦截对他的调用并直接返回该方法所创建的bean。
我们可以做个实验:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Configuration
public class PeopleCarConfig {
private int i=1;
@Bean
public Car busCar()
{
i=i+1;
System.out.println(i);
return new BusCar();
}
@Bean(name="man")
public People man()
{
return new Man( busCar());
}
@Bean(name="woman")
public People woman()
{
return new Woman( busCar());
}
}

输出:

1
2
3
4
5
6
2
buscar构造函数
男司机:小明
浦东25路南京西路到了
女司机:小红
浦东25路南京西路到了

从这里就可以看出来 busCar()并不会真正的调用,而是直接返回spring创建的bean.
我们也可以通过另外一种方法来注入:

我们再创建一个Woman

1
2
3
4
5
6
7
8
9
10
11
12
public class Woman implements People {
private Car car;
public Woman(Car car){
this.car=car;
}
private String userName ="小红";
@Override
public void drive() {
System.out.println("女司机:" + this.userName);
car.notice();
}
}
1
2
3
4
public People woman(Car car)
{
return new Woman( car);
}

这里woman()方法加了一个Car参数,这里会自动装配一个Car类型的实现类实例。需要注意的是这里Car类型的bean可以通过xml 自动配置 javaconfig配置来进行配置。所以这种方式是最佳的注入方式。
以上我们使用的构造器的方式,其实我们也可以通过set方式等其他任意java方式去创建。

xml配置

在javaconfig中配置bean需要加@Configuration,xml配置对应的需要创建一个spring的xml规范文件。取名spring-test.xml

1
2
3
4
5
6
<?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>

我们来配置一个bean

1
<bean class="com.yalunwang.xmlconfig.BusCar" />

这个 配置相当于javaconfig中的@Bean,这时bean的id默认为完全限定名com.yalunwang.xmlconfig.BusCar#0
我们可以指定id: busCar

1
<bean id="busCar" class="com.yalunwang.xmlconfig.BusCar" />

这时spring创建busCar 的时候回自动调用busCar的默认构造函数。

下面我们来看在xml如何里装配

装配bean

  1. 构造器方式
    1
    2
    3
    <bean id="man" class="com.yalunwang.xmlconfig.Man" >
    <constructor-arg ref="busCar"/>
    </bean>

这样就会在创建man实例的时候调用有参构造器,将id为busCar的bean实例注入进去。
我们也可以注入非引用类型即字面值:

1
2
3
<bean id="busCar" class="com.yalunwang.xmlconfig.BusCar" >
<constructor-arg name="carName" value="浦东2路"></constructor-arg>
</bean>

xml还支持多种类型的注入,例如list.大家都知道公交车有很多的站点所以我们新增一个字段stationList用来存放站点列表。
我们也可以注入list类型

1
2
3
4
5
6
7
8
9
10
<bean id="busCar" class="com.yalunwang.xmlconfig.BusCar" >
<constructor-arg name="carName" value="浦东2路"></constructor-arg>
<constructor-arg name="stationList">
<list>
<value>高科中路</value>
<value>宜山路</value>
<value>桂林路</value>
</list>
</constructor-arg>
</bean>

同样的我们也可以使用 等来装配。

我们编写测试类来测试一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring-test.xml"})
public class Test {
@Autowired
private Car car;
@org.junit.Test
public void testBusCar()
{
car.notice();
car.printStationList();
}
@Autowired
private People people;
@org.junit.Test
public void testPeople()
{
people.drive();
}
}

两个方法的输出分别是

1
2
3
4
浦东2路南京西路到了
站名:高科中路
站名:宜山路
站名:桂林路

1
2
男司机:小明
浦东2路南京西路到了

下面来看属性注入

  1. 属性注入

属注入是元素

为了演示属性注入我们先把man注释掉,以避免我们再单元测试类中使用@AutoWired注解报错(因为有两个People的实例bean,后面文章会介绍这个问题)

1
2
3
4
5
6
<!--<bean id="man" class="com.yalunwang.xmlconfig.Man" >-->
<!--<constructor-arg name="car" ref="busCar"/>-->
<!--</bean>-->
<bean id="woman" class="com.yalunwang.xmlconfig.Woman" >
<property name="car" ref="busCar"></property>
</bean>

它会引用id为busCar的bean通过setCar()方法注入到car属性中。

这时我们在运行testPeople输出

1
2
女司机:小红
浦东2路南京西路到了

同样的属性也像构造函数方式注入一样可以注入字面值 等类型的值。

1
2
3
4
5
6
7
8
9
10
<bean id="woman" class="com.yalunwang.xmlconfig.Woman" >
<property name="car" ref="busCar"></property>
<property name="userName" value="韩梅梅"></property>
<property name="certificateList" >
<list>
<value>驾驶证</value>
<value>身份证</value>
</list>
</property>
</bean>

我们再次测试:

1
2
3
4
女司机:韩梅梅
浦东2路南京西路到了
证书:驾驶证
证书:身份证

总结

以上就是spring中的三种装配Bean的方式,这里只是将最核心也是最基本的内容展示出来了,关于spring中更高级的装配我们将在后面文章讲解。

博客中的源码地址

github地址:https://github.com/yalunwang/java-clump