Spring基础篇之Bean装配

0x00 参考

本笔记直接参考或引自如下链接文章：

https://www.w3cschool.cn/wkspring/

http://c.biancheng.net/spring/

0x01 Spring Bean装配

Bean的装配可以理解为依赖关系注入，Bean的装配方式也就是Bean的依赖注入方式。Spring容器支持多种形式的Bean的装配方式，如基于XML的Bean装配、基于Annotation的Bean装配和自动装配等。

0x02 基于XML装配Bean

Spring基于XML的装配通常采用两种实现方式，即setter方法注入（Setter Injection）和构造函数注入（Constructor Injection），这两种方式在前面也讲过。

在Spring实例化Bean的过程中，首先会调用默认的构造方法实例化Bean对象，然后通过Java的反射机制调用setXxx()方法进行属性的注入。因此，setter方法注入要求一个Bean的对应类必须满足以下两点要求：

• 必须提供一个默认的无参构造方法；
• 必须为需要注入的属性提供对应的setter方法；

使用setter方法注入时，在Spring配置文件中，需要使用<bean>元素的子元素<property>元素为每个属性注入值。而使用构造函数注入时，在配置文件中，主要使用<constructor-arg>标签定义构造方法的参数，可以使用其value属性（或子元素）设置该参数的值。

示例可参考前面的Spring DI文章：Spring基础篇之DI（依赖注入）

0x03 基于Annotation装配Bean

在Spring中，尽管使用XML配置文件可以实现Bean的装配工作，但如果应用中Bean的数量较多，会导致XML配置文件过于臃肿，从而给维护和升级带来一定的困难。

Java从JDK 5.0以后，提供了Annotation（注解）功能，Spring也提供了对Annotation技术的全面支持。Spring3中定义了一系列的Annotation（注解），常用的注解如下：

@Required

@Required注释应用于bean属性的setter方法，它表明受影响的bean属性在配置时必须放在XML配置文件中，否则容器就会抛出一个BeanInitializationException异常。

@Component

可以使用此注解描述Spring中的Bean，但它是一个泛化的概念，仅仅表示一个组件（Bean），并且可以作用在任何层次。使用时只需将该注解标注在相应类上即可。

@Repository

用于将数据访问层（DAO层）的类标识为Spring中的Bean，其功能与@Component 相同。

@Service

通常作用在业务层（Service 层），用于将业务层的类标识为Spring中的Bean，其功能与@Component相同。

@Controller

通常作用在控制层（如Struts2的Action），用于将控制层的类标识为Spring中的Bean，其功能与@Component相同。

@Autowired

用于对Bean的属性变量、属性的Set方法及构造函数进行标注，配合对应的注解处理器完成Bean的自动配置工作。默认按照Bean的类型进行装配。

@Resource

其作用与Autowired一样。其区别在于@Autowired默认按照Bean类型装配，而@Resource默认按照Bean实例名称进行装配。

@Resource中有两个重要属性：name 和 type。如果都不指定，则先按Bean实例名称装配，如果不能匹配，则再按照Bean类型进行装配；如果都无法匹配，则抛出NoSuchBeanDefinitionException异常。

@Qualifier

与@Autowired注解配合使用，会将默认的按Bean类型装配修改为按Bean的实例名称装配，Bean的实例名称由@Qualifier注解的参数指定。

@PostConstruct和@PreDestroy

为了定义一个bean的安装和卸载，我们使用 init-method 和 destroy-method 参数简单的声明一下 。init-method属性指定了一个方法，该方法在bean的实例化阶段会立即被调用。同样地，destroy-method指定了一个方法，该方法只在一个bean从容器中删除之前被调用。

作用和前面说到的Bean后置处理器一样，只不过换了注释的形式来实现。

@Configuration和@Bean

带有@Configuration的注解类表示这个类可以使用Spring IoC容器作为bean定义的来源。@Bean注解告诉Spring，一个带有@Bean的注解方法将返回一个对象，该对象应该被注册为在Spring应用程序上下文中的bean。

最简单可行的@Configuration类如下所示：

package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class HelloWorldConfig {
   @Bean 
   public HelloWorld helloWorld(){
      return new HelloWorld();
   }
}

上面的代码将等同于下面的 XML 配置：

<beans>
   <bean id="helloWorld" class="com.mi1k7ea.HelloWorld" />
</beans>

在这里，带有@Bean注解的方法名称作为bean的ID，它创建并返回实际的bean。你的配置类可以声明多个@Bean。一旦定义了配置类，你就可以使用AnnotationConfigApplicationContext来加载并把它们提供给Spring容器，如下所示：

public static void main(String[] args) {
   ApplicationContext ctx = new AnnotationConfigApplicationContext(HelloWorldConfig.class); 
   HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
   helloWorld.setMessage("Hello World!");
   helloWorld.getMessage();
}

你可以加载各种配置类，如下所示：

public static void main(String[] args) {
   AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
   ctx.register(AppConfig.class, OtherConfig.class);
   ctx.register(AdditionalConfig.class);
   ctx.refresh();
   MyService myService = ctx.getBean(MyService.class);
   myService.doStuff();
}

Demo

PersonDao.java，DAO层即接口类：

package com.mi1k7ea;

public interface PersonDao {
    void add();
}

PersonDaoImpl.java，DAO层接口类的实现类，首先使用@Repository注解将PersonDaoImpl类标识为Spring中的Bean，其写法相当于配置文件中<bean id="personDao" class="com.mi1k7ea.PersonDaoImpl"/>的书写。然后在add()方法中输出一句话，用于验证是否成功调用了该方法：

package com.mi1k7ea;

import org.springframework.stereotype.Repository;

@Repository("personDao")
public class PersonDaoImpl implements PersonDao {
    @Override
    public void add() {
        System.out.println("Dao层的add()方法执行了...");
    }
}

PersonService.java，Service层接口类：

package com.mi1k7ea;

public interface PersonService {
    void add();
}

PersonServiceImpl.java，Service层接口类的实现类， 首先使用@Service注解将PersonServiceImpl类标识为Spring中的Bean，其写法相当于配置文件中<bean id="personService" class="com.mi1k7ea.PersonServiceImpl"/>的书写。然后使用@Resource注解标注在属性personDao上（也可标注在personDao的setPersonDao()方法上），这相当于配置文件中<property name="personDao" ref="personDao"/>的写法。最后在该类的add()方法中调用personDao中的add()方法，并输出一句话 ：

package com.mi1k7ea;

import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service("personService")
public class PersonServiceImpl implements PersonService {
    @Resource(name = "personDao")
    private PersonDao personDao;
    public PersonDao getPersonDao() {
        return personDao;
    }
    @Override
    public void add() {
        personDao.add();// 调用personDao中的add()方法
        System.out.println("Service层的add()方法执行了...");
    }
}

PersonAction.java，首先使用@Controller注解标注PersonAction类，其写法相当于在配置文件中编写<bean id="personAction" class="com.mi1k7ea.PersonAction"/>。然后使用了@Resource注解标注在personService上，这相当于在配置文件内编写<property name="personService" ref="personService"/>。最后在其add()方法中调用了personService中的add()方法，并输出一句话 ：

package com.mi1k7ea;

import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

@Controller("personAction")
public class PersonAction {
    @Resource(name = "personService")
    private PersonService personService;
    public PersonService getPersonService() {
        return personService;
    }
    public void add() {
        personService.add(); // 调用personService中的add()方法
        System.out.println("Action层的add()方法执行了...");
    }
}

MainApp.java：

package com.mi1k7ea;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        // 初始化Spring容器，加载配置文件，并对bean进行实例化
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("Beans.xml");
        // 获得personAction实例
        PersonAction personAction = (PersonAction) applicationContext.getBean("personAction");
        // 调用personAction中的add()方法
        personAction.add();
    }
}

Beans.xml，使用context命名空间的component-scan元素进行注解的扫描，其base-package属性用于通知Spring所需要扫描的目录：

?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-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">

    <!--使用context命名空间，通知spring扫描指定目录，进行注解的解析-->
    <context:component-scan base-package="com.mi1k7ea"/>

</beans>

运行输出：

0x04 自动装配Bean

自动装配就是指Spring容器可以自动装配（autowire）相互协作的Bean之间的关联关系，将一个Bean注入其他Bean的Property中。

要使用自动装配，就需要配置<bean>元素的autowire属性。autowire 属性有以下五个值：

名称	说明
byName	根据 Property 的 name 自动装配，如果一个 Bean 的 name 和另一个 Bean 中的 Property 的 name 相同，则自动装配这个 Bean 到 Property 中。
byType	根据 Property 的数据类型（Type）自动装配，如果一个 Bean 的数据类型兼容另一个 Bean 中 Property 的数据类型，则自动装配。
constructor	根据构造方法的参数的数据类型，进行 byType 模式的自动装配。
autodetect	如果发现默认的构造方法，则用 constructor 模式，否则用 byType 模式。
no	默认情况下，不使用自动装配，Bean 依赖必须通过 ref 元素定义。

byName

这种模式由属性名称指定自动装配。Spring容器看作beans，在XML配置文件中beans的auto-wire属性设置为byName。然后，它尝试将它的属性与配置文件中定义为相同名称的beans进行匹配和连接。如果找到匹配项，它将注入这些beans，否则，它将抛出异常。

例如，在配置文件中，如果一个bean定义设置为自动装配byName，并且它包含spellChecker属性（即它有一个 setSpellChecker(…) 方法），那么Spring就会查找定义名为spellChecker的bean，并且用它来设置这个属性。你仍然可以使用<property>标签连接其余的属性。

Demo

SpellChecker.java不变。

TextEditor.java：

package com.mi1k7ea;

public class TextEditor {
    private SpellChecker spellChecker;
    private String name;
    public void setSpellChecker( SpellChecker spellChecker ){
        this.spellChecker = spellChecker;
    }
    public SpellChecker getSpellChecker() {
        return spellChecker;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void spellCheck() {
        spellChecker.checkSpelling();
    }
}

MainApp.java：

package com.mi1k7ea;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        TextEditor te = (TextEditor) context.getBean("textEditor");
        te.spellCheck();
    }
}

Beans.xml，给textEditor这个Bean添加值为byName的autowire属性：

<?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-3.0.xsd">

    <!-- Definition for textEditor bean -->
    <bean id="textEditor" class="com.mi1k7ea.TextEditor" autowire="byName">
        <property name="name" value="mi1k7ea" />
    </bean>

    <!-- Definition for spellChecker bean -->
    <bean id="spellChecker" class="com.mi1k7ea.SpellChecker" />

</beans>

这里我们对比下，不应用自动装配的Beans.xml，需要通过bean元素的子元素property的ref属性来设置装配：

<?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-3.0.xsd">

    <!-- Definition for textEditor bean -->
   <bean id="textEditor" class="com.mi1k7ea.TextEditor">
       <property name="spellChecker" ref="spellChecker" />
       <property name="name" value="Generic Text Editor" />
   </bean>

   <!-- Definition for spellChecker bean -->
   <bean id="spellChecker" class="com.mi1k7ea.SpellChecker" />

</beans>

运行输出：

byType

这种模式由属性类型指定自动装配。Spring容器看作beans，在XML配置文件中beans的autowire属性设置为byType。然后，如果它的type恰好与配置文件中beans名称中的一个相匹配，它将尝试匹配和连接它的属性。如果找到匹配项，它将注入这些beans，否则，它将抛出异常。

例如，在配置文件中，如果一个bean定义设置为自动装配byType，并且它包含SpellChecker类型的spellChecker属性，那么Spring就会查找定义名为SpellChecker的bean，并且用它来设置这个属性。你仍然可以使用<property>标签连接其余属性。

Demo

MainApp.java，SpellChecker.java，TextEditor.java均不变。

Beans.xml，将autowire属性值改为byType：

<?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-3.0.xsd">

    <!-- Definition for textEditor bean -->
    <bean id="textEditor" class="com.mi1k7ea.TextEditor" autowire="byType">
        <property name="name" value="mi1k7ea" />
    </bean>

    <!-- Definition for spellChecker bean -->
    <bean id="spellChecker" class="com.mi1k7ea.SpellChecker" />

</beans>

运行输出同上。

constructor

这种模式与byType非常相似，但它应用于构造器参数。Spring容器看作beans，在XML配置文件中beans的autowire属性设置为constructor。然后，它尝试把它的构造函数的参数与配置文件中beans名称中的一个进行匹配和连线。如果找到匹配项，它会注入这些bean，否则，它会抛出异常。

例如，在配置文件中，如果一个bean定义设置为通过构造函数自动装配，而且它有一个带有SpellChecker类型的参数之一的构造函数，那么Spring就会查找定义名为SpellChecker的bean，并用它来设置构造函数的参数。你仍然可以使用<constructor-arg>标签连接其余属性。

Demo

MainApp.java，SpellChecker.java均不变。

TextEditor.java，添加一个有参构造函数：

package com.mi1k7ea;

public class TextEditor {
    private SpellChecker spellChecker;
    private String name;
    public TextEditor( SpellChecker spellChecker, String name ) {
        this.spellChecker = spellChecker;
        this.name = name;
    }
    public SpellChecker getSpellChecker() {
        return spellChecker;
    }
    public String getName() {
        return name;
    }
    public void spellCheck() {
        spellChecker.checkSpelling();
    }
}

Beans.xml，将autowire属性值改为constructor，其中另一个参数name通过constructor-arg子元素即构造函数的形式进行装配：

<?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-3.0.xsd">

    <!-- Definition for textEditor bean -->
    <bean id="textEditor" class="com.mi1k7ea.TextEditor" autowire="constructor">
        <constructor-arg value="Generic Text Editor"/>
    </bean>

    <!-- Definition for spellChecker bean -->
    <bean id="SpellChecker" class="com.mi1k7ea.SpellChecker" />

</beans>

运行输出同上。

TextEditor.java均不变。