当Spring装配Bean属性时，有时候非常明确，就是需要将某个Bean的引用装配给指定属性。

先写两个类

public class UserServcie {

    private UserDao userDao;

    public UserServcie(UserDao userDao){}
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }
    public UserDao getUserDao(){
        return userDao;
    }
}

public class UserDao {
}

例如：在UserServcie中注入UserDao需要显式的手动装配

<bean id="userDao" class="com.beans.UserDao"></bean>
<bean id="userService" class="com.beans.UserServcie">
   <property name="userDao" ref="userDao"></property>
</bean>

这种写法会是开发效率变慢。

因此出现了spring的自动装配方式：五种自动装配方式 no、byName、byType、constructor、default。

1、no：当使用autowire="no"时，不使用自动装配，依然需要手动装配，需要显式指定某个bean的引用。

<bean id="userService" class="com.beans.UserServcie" autowire="no">
     <property name="userDao" ref="userDao"></property>
</bean>

2、byName：使用autowire="byName"装配方式时，就是使用名字装配，不需要显式指定某个bean的引用，此时使用的是setter方式注入。此时要注意需要被注入的bean的id和注入的bean的属性名之间的匹配，否则失败注入不成功。

 例如：UserService中需要注入UserDao， private UserDao userDao，当byName注入时，spring会在ioc容器中寻找id="userDao"的对象，找到注入成功，找不到注入失败。

public class UserServcie {

    private UserDao userDao;

    public UserServcie(UserDao userDao){}
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }
    public UserDao getUserDao(){
        return userDao;
    }
}

此时的配置文件为

<bean id="userDao" class="com.beans.UserDao"></bean>
<bean id="userService" class="com.beans.UserServcie" autowire="byName"></bean>

3、byType：使用autowire="byType"装配方式时，就是使用类型装配，不需要显式指定某个bean的引用，此时使用的是setter方式注入。此时需要注意ioc容器中不允许出现同一个类型的两个及以上个数量的实例，否则失败报异常。

此时的配置文件为

<bean id="userDao" class="com.beans.UserDao"></bean>
<bean id="userService" class="com.beans.UserServcie" autowire="byType"></bean>

 4、constructor ：使用autowire="constructor "装配方式时，默认也是使用byType方式装配，只是不同的是按照构造器参数的类型进行装配，构造器方式注入。

<bean id="userDao" class="com.beans.UserDao"></bean>
<bean id="userService" class="com.beans.UserServcie" autowire="constructor"></bean>

5、default： 使用autowire="default"装配方式时，是使用父级标签的默认装配方式，我们这里也就是指<bean/>的父级标签<beans>的默认装配方式进行装配。例如:

<beans default-autowire="byType" 
       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">

    <bean id="userDao" class="com.beans.UserDao"></bean>
    <bean id="userService1" class="com.beans.UserServcie" autowire="default"></bean>

    <bean id="userService2" class="com.beans.UserServcie" autowire="byName"></bean>
</beans>

这里beans标签使用的是byType方式，对于userService1 使用的autowire="default"，就会使用beans的byType方式装配，而 userService1的autowire="byName"则会使用byName装配。

Bean的装配可以理解为依赖关系注入，Bean的装配方式即Bean的依赖注入的方式。

Spring容器支持多种形式的Bean的装配方式，如基于XML的装配、基于注解的装配、自动装配等。其中最常用的是基于注解的装配。

基于XML的装配

Spring提供了两种基于XML的装配方式：设值注入、构造注入

Spring实例化Bean的过程中，Spring首先会调用Bean的默认构造方法来实例化Bean对象，然后通过反射的方式调用setter方法来注入属性值。

设值注入：

• Bean类必须提供一个默认的无参构造方法
• Bean类必须为需要注入的属性提供对应的setter方法
• 在配置文件中，需要使用 <property>元素为每个属性注入值

构造注入：

• Bean类必须提供有参构造方法
• 在配置文件中，需要使用<constructor-arg>元素来定义构造方法的参数，也可以使用其value属性来设置该参数的值

基于注解的装配

Spring中定义了一系列的注解，常用的注解如下：

• @Component：描述Spring中的Bean，可以作用在任何层次
• @Repository：用于将持久层（Dao层）的类标识为Spring中的Bean
• @Service：用于将业务层（Service层）的类标识为Spring中的Bean
• @Controller：用于将控制层（Controller层）的类标识为Spring中的Bean
• @Autowired：用于对Bean的属性变量、属性的setter方法以及构造方法进行标注，配合对应的注解处理器完成Bean的自动装配工作。默认按照Bean的类型进行装配
• @Resource：其作用与@Autowired一样。其区别在于@Autowired默认Bean的类型装配，而@Resource默认按照Bean的实例名称进行装配

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

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

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

}

@Service("accountService")
public class AccountServiceImpl implements AccountService {
  
     @Resource(name="accountDao")
     private AccountDao accountDao; 

}

此时，在配置文件中，Spring注解提供了另外一种高效的注解配置方式。

含义是：告知Spring在创建容器时要扫描的包（通知Spring扫描指定包下的所有Bean）

    <context:component-scan base-package="cn.itcast"></context:component-scan>

自动装配 

自动装配：将一个Bean自动地注入到其他Bean的Property中

Spring的 <bean>元素中包含一个 autowire 属性，我们可以通过设置 autowire 的属性值来自动装配Bean。

autowire属性的5个值：

• default（默认）：由<beans>的default-autowire属性值来确定。
• byName：根据属性的名称自动装配。容器将根据名称查找与属性完全一致的Bean，并将其属性自动装配
• byType：根据属性的数据类型自动装配。
• constructor：根据构造函数参数的数据类型，进行byType模式的自动装配
• no：在默认情况下，不使用自动装配，Bean依赖必须通过ref元素定义

spring 自动装配 bean 有哪些方式？

 spring 配置文件中 <bean> 节点的 autowire 参数可以控制 bean 自动装配的方式

• default - 默认的方式和 "no" 方式一样
• no - 不自动装配，需要使用 <ref />节点或参数
• byName - 根据名称进行装配
• byType - 根据类型进行装配
• constructor - 根据构造函数进行装配

文档解释

Attribute : autowire
Controls whether bean properties are "autowired". This is an 
 automagical process in which bean references don't need to 
 be coded explicitly in the XML bean definition file, but rather 
 the Spring container works out dependencies. The effective 
 default is "no". There are 4 modes: 1. "no" The traditional 
 Spring default. No automagical wiring. Bean references must 
 be defined in the XML file via the <ref/> element (or "ref" 
 attribute). We recommend this in most cases as it makes 
 documentation more explicit. Note that this default mode also 
 allows for annotation-driven autowiring, if activated. "no" 
 refers to externally driven autowiring only, not affecting any 
 autowiring demands that the bean class itself expresses. 2. 
 "byName" Autowiring by property name. If a bean of class Cat 
 exposes a "dog" property, Spring will try to set this to the 
 value of the bean "dog" in the current container. If there is no 
 matching bean by name, nothing special happens. 3. "byType" 
 Autowiring if there is exactly one bean of the property type in 
 the container. If there is more than one, a fatal error is raised, 
 and you cannot use byType autowiring for that bean. If there is 
 none, nothing special happens. 4. "constructor" Analogous to 
 "byType" for constructor arguments. If there is not exactly one 
 bean of the constructor argument type in the bean factory, a 
 fatal error is raised. Note that explicit dependencies, i.e. 
 "property" and "constructor-arg" elements, always override 
 autowiring. Note: This attribute will not be inherited by child 
 bean definitions. Hence, it needs to be specified per concrete 
 bean definition. It can be shared through the 'default-autowire' 
 attribute at the 'beans' level and potentially inherited from 
 outer 'beans' defaults in case of nested 'beans' sections (e.g. 
 with different profiles).

Data Type : string
Default Value : default
Enumerated Values : 
	- default
	- no
	- byName
	- byType
	- constructor

代码示例

1、no 方式

spring 配置文件，使用 ref 参数注入 bean，必须要有对象的 setter 方法，这里即 Person 的 setFr 方法。

没有 <property name="fr" ref="fr"></property> 因没有注入 fr 属性，会报空指针错误。

<?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">
        
	<bean id="person" class="constxiong.interview.assemble.Person" autowire="no">
		<property name="fr" ref="fr"></property>
	</bean>
	<bean id="fr" class="constxiong.interview.assemble.FishingRod"></bean>
		
</beans>

鱼竿 bean

package constxiong.interview.assemble;


/**
 * 鱼竿
 * @author ConstXiong
 * @date 2019-07-17 09:53:15
 */
public class FishingRod {

	/**
	 * 被使用
	 */
	public void used() {
		System.out.println("钓鱼...");
	}
}

人 bean

package constxiong.interview.assemble;


/**
 * 人
 * @author ConstXiong
 * @date 2019-07-17 09:54:56
 */
public class Person {

	private FishingRod fr;
	
	/**
	 * 钓鱼
	 */
	public void fish() {
		fr.used();
	}
	
	public void setFr(FishingRod fr) {
		this.fr = fr;
	}
	
}

测试代码

package constxiong.interview.assemble;

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

public class AssembleTest {

	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("spring_assemble.xml");
		Person person = (Person)context.getBean("person");
		person.fish();
	}
	
}

2、byName 也是需要相应的 setter 方法才能注入

修改 spring 配置文件 autowire="byName"

<?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">
        
	<bean id="person" class="constxiong.interview.assemble.Person" autowire="byName"></bean>
	<bean id="fr" class="constxiong.interview.assemble.FishingRod"></bean>
		
</beans>

其他不变

3、byType 也是需要相应的 setter 方法才能注入

修改 spring 配置文件 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"
	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">
        
	<bean id="person" class="constxiong.interview.assemble.Person" autowire="byType"></bean>
	<bean id="fr" class="constxiong.interview.assemble.FishingRod"></bean>
		
</beans>

其他不变

4、constructor 无需 setter 方法，需要通过 构造方法注入 bean

修改 spring 配置文件autowire="byType"

Person 类去除 setFr 方法，添加构造方法设置 fr 属性

<?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">
        
	<bean id="person" class="constxiong.interview.assemble.Person" autowire="constructor"></bean>
	<bean id="fr" class="constxiong.interview.assemble.FishingRod"></bean>
		
</beans>

package constxiong.interview.assemble;


/**
 * 人
 * @author ConstXiong
 * @date 2019-07-17 09:54:56
 */
public class Person {

	private FishingRod fr;
	
	public Person(FishingRod fr) {
		this.fr = fr;
	}
	
	/**
	 * 钓鱼
	 */
	public void fish() {
		fr.used();
	}
	
}

1、2、3、4 的测试结果一致，打印

钓鱼...

• Java 自学指南
• Java 面试题汇总PC端浏览【点这里】
• Java 面试题汇总小程序浏览，扫二维码

【Java面试题与答案】整理推荐

• 基础与语法
• 集合
• 网络编程
• 并发编程
• Web
• 安全
• 设计模式
• 框架
• 算法与数据结构
• 异常
• 文件解析与生成
• Linux
• MySQL
• Oracle
• Redis
• Dubbo