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