Spring Bean 初步

通过前一章内容我们看到，Bean 本质上就是我们通过配置文件，去指导 Spring 进行初始化产生的对象。实际上，Bean 在 Spring 中还有很多属性，在这一章我们主要关注和对象创建有关的内容，其中很重要的一点，就是对象的依赖。

在真正的业务中，对象之间会形成复杂的依赖关系。在 Spring 的 Bean 配置中，我们可以描述出这种依赖关系，Spring 会根据依赖关系，正确地进行 Bean 的初始化。

Constructor 注入

首先第一种依赖注入的方式，就是通过 Constructor 进行注入。下面通过一个例子展示一下。我们将上一章的 Service 拆分出一个 model 类 Person：

  1. package com.skyline.model;
  3. public class Person {
  5.     private String name;
  7.     public String getName() {
  8.         return name;
  9.     }
  11.     public void setName(String name) {
  12.         this.name = name;
  13.     }
  15. }

和一个依赖 Person 的 Service 类：

  1. package com.skyline.service;
  3. import com.skyline.model.Person;
  5. public class MyServiceImpl implements MyService {
  7.     private Person person;
  9.     public MyServiceImpl(Person person)
  10.     {
  11.         this.person = person;
  12.     }
  14.     @Override
  15.     public String sayHello() {
  16.         return "Hello " + this.person.getName();
  17.     }
  18. }

可以看到，Service 初始化时，在 Constructor 中需要一个 Person 的实例。为了让代码正常工作，我们需要更改 Bean 的配置：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2.   <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.     http://www.springframework.org/schema/beans/spring-beans.xsd">
  7.     <bean id="aPerson" class="com.skyline.model.Person">
  8.       <property name="name" value="Chester"/>
  9.     </bean>
  11.     <bean id="myService" class="com.skyline.service.MyServiceImpl">
  12.       <constructor-arg ref="aPerson"/>
  13.     </bean>
  15. </beans>

通过这样的方式，Spring 会先初始化 aPerson，然后使用它初始化 myService。运行代码，结果和之前是一样的。

此外，对于不是自定义类的普通参数，也可以使用 XML 进行注入，例如我们更改 Serivce 类，加入 greeting 参数：

  1. public class MyServiceImpl implements MyService {
  3.     private Person person;
  5.     private String greeting;
  7.     public MyServiceImpl(Person person, String greeting)
  8.     {
  9.         this.person = person;
  10.         this.greeting = greeting;
  11.     }
  13.     @Override
  14.     public String sayHello() {
  15.         return this.greeting + " " + this.person.getName();
  16.     }
  17. }

修改 XML 配置如下：

  1. <bean id="myService" class="com.skyline.service.MyServiceImpl">
  2.   <constructor-arg ref="aPerson"/>
  3.   <constructor-arg type="java.lang.String" value="Hello"/>
  4. </bean>

运行程序，仍然可以打印出预期结果。

Setter 注入

另一种依赖注入方式，是通过 Setter，这种方式类似于初始化 Bean 的参数。仍然用一个例子，我们把 Service 改成下面这样：

  1. public class MyServiceImpl implements MyService {
  3.     private Person person;
  5.     private String greeting;
  7.     public Person getPerson() {
  8.         return person;
  9.     }
  11.     public void setPerson(Person person) {
  12.         this.person = person;
  13.     }
  15.     public String getGreeting() {
  16.         return greeting;
  17.     }
  19.     public void setGreeting(String greeting) {
  20.         this.greeting = greeting;
  21.     }
  23.     @Override
  24.     public String sayHello() {
  25.         return this.greeting + " " + this.person.getName();
  26.     }
  27. }

与之对应的，修改 XML 配置文件：

  1. <bean id="aPerson" class="com.skyline.model.Person">
  2.   <property name="name" value="Chester"/>
  3. </bean>
  5. <bean id="myService" class="com.skyline.service.MyServiceImpl">
  6.   <property name="person" ref="aPerson"/>
  7.   <property name="greeting" value="Hello"/>
  8. </bean>

运行程序，结果保持不变。