0 前言

Spring无疑是强大的Java企业级应用框架，通过容器自动化的管理Bean的生命周期以及通过依赖注入实现Bean之间的依赖关系。为了简化Java开发的复杂性，避免侵入式开发，Spring采用配置的方式实现Bean的管理。
本文主要就Spring中Bean的配置方式展开描述。

1 Bean是什么

那么首先，Bean是什么？
如果读者之前接触过Java的话，应该知道JavaBeans的概念。

JavaBeans are classes that encapsulate many objects into a single object (the bean). They are serializable, have a zero-argument constructor, and allow access to properties using getter and setter methods.
--引自维基百科JavaBeans

在Spring中，Bean的定义不像JavaBeans那么严格，只要知道一点就足够了——在Spring中，任何被容器（Container）管理的对象都是Bean。开发环境中常见的model、Dao和Service等都可以是Bean。

2 Container是什么

那容器又是什么呢？
容器，顾名思义就是容纳Bean的地方，只不过在Spring中它还有其他的功能，比如管理Bean的生命周期。

详细解释请参看官网IoC Container的相关说明。

Spring中容器有多种实现，常见的是实现ApplicationContext接口的各种应用上下文：

• AnnotationConfigApplicationContext：从一个或者多个JavaConfig类中加载应用上下文
• AnnotationConfigWebApplicationContext：从一个或者多个JavaConfig类中加载Spring Web应用上下文
• ClassPathXmlApplicationContext：从类路径下的一个或者多个xml配置文件中加载应用上下文
• FileSystemXmlApplicationContext：从文件系统下的一个或者多个xml配置文件中加载应用上下文
• XmlWebApplicationContext：从web应用下的一个或者多个xml配置中加载应用上下文

3 Bean的配置方式

Spring中Bean的配置主要分为两个步骤：

1. 创建Bean
2. 通过依赖注入解决Bean之间的依赖关系

Spring中创建的Bean默认是单例模式的，任何Bean一旦在容器中创建，后续不再重复创建该Bean。同一个类型可以创建多个Bean，这些不同的Bean通过Bean的名字进行区分，同一个名字的Bean有且仅有一个。

Spring中Bean的配置方式有如下三种：

1. XML配置
2. JavaConfig配置
3. 自动配置

下面将分别对这三种配置方式进行介绍，在结束之前，我们先设定一个简单的场景。假定现在有一个学生Student类，该学生在一个系中，系用Department类表示。也就是说Student类依赖于Department类。

public class Department {
  private String name;
}

public class Student {
  private Department department;
  public Student() {
  }
  public Student (Department department) {
    this.department = department;
  }
  public void setDepartment(Department department) {
    this.department = department;
  }
}

现在我们的任务是，分别通过三种配置方式实现以下两个目标:

1. 在容器中创建好Student类和Department类
2. 解决Student类对Department的依赖关系

3.1 XML配置

1. 实现Student类和Department类Bean的创建
   XML配置需要一个xml的配置文档，其根节点必须是beans，每个Bean定义在bean子节点中。通过下面的xml文件即可在容器中创建出单例的StudentBean和DepartmentBean。
   不难发现，XML下的Bean的并不需要修改Student类和Department类任何地方，可以实现0侵入。

<?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"> 
    <bean id="department" class="com.lianglei.springfeaturetest.bean.Department"/>
    <bean id="student" class="com.lianglei.springfeaturetest.bean.Student"/>
</beans>

• bean中的id代表的就是Bean在容器中的名字，如果不填则默认的名字为class中的字符串加上#0，例如：com.lianglei.springfeaturetest.bean.Student#0，如果有多个同类型的不同的Bean，则会以#1、#2结尾
• 如果bean需要在配置文件中别的地方用到，则必须提供id属性
• bean中的class必须为类的完全类名（包括包的部分）

2. 实现Student类对Department类Bean的依赖
   上面只是创建的Student类对Department类的Bean，调用的都是他们的默认构造函数，Department并没有注入到Student中。修改XML配置文件如下所示完成依赖注入：

• 构造函数注入

<?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">
    <bean id="department" class="com.lianglei.springfeaturetest.bean.Department"/>
    <bean id="student" class="com.lianglei.springfeaturetest.bean.Student">
        <constructor-arg ref="department" />
    </bean>
</beans>

• setter注入

<?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">
    <bean id="department" class="com.lianglei.springfeaturetest.bean.Department"/>
    <bean id="student" class="com.lianglei.springfeaturetest.bean.Student">
        <property name="department" ref="department" />
    </bean>
</beans>

• XML配置中，构造器注入需要Student类提供相应的构造方法，否则出错
• XML配置中，setter注入需要提供setter方法，否则出错
• 对于强依赖的关系，推荐采用构造器注入，其他采用setter注入

3.2 JavaConfig配置

1. 实现Student类和Department类Bean的创建
   JavaConfig实现Student类和Department类Bean创建的代码如下：

@Configuration
public class HelloConfig {
    
    @Bean
    public Department department() {
        return new Department();
    }

    @Bean
    public Student student() {
        return new Student();
    }
}

2. 实现Student类对Department类Bean的依赖

• 构造器注入

@Configuration
public class HelloConfig {
    
    @Bean
    public Department department() {
        return new Department();
    }

    @Bean
    public Student student(Department department) {
        return new Student(department);
    }
}

• setter注入

@Configuration
public class HelloConfig {
    
    @Bean
    public Department department() {
        return new Department();
    }

    @Bean
    public Student student(Department department) {
        Student student =  new Student();
        student.setDepartment(department);
        return student;
    }
}

不难看出，JavaConfig配置的步骤主要有两个：

1. 创建一个Config类并通过@Configuration注解
2. 提供@Bean注解的方法返回对应类型的实例

可以看出，JavaConfig方式完全通过Java编程的思想完成Bean的创建和依赖注入。这种方式有个很大的优势在于，在@Bean的方法中，只要最终结果返回的是对应类型的实例，你可以通过任意方式实例化Bean。

• @Bean一方面标识该方法返回的是Bean，需要被容器管理，另一方面指名该方法只返回单例，返回一次后不再继续返回
• Bean的名字默认为方法的名字，可以在@Bean通过name属性指定Bean的名字。
• 两种注入方式同样需要提供相应的构造函数和setter方法
• 同样不需要侵入Student类对Department类

3.3 自动配置

自动配置方式的步骤如下：

1. 在要配置的Bean上添加@Component、@Service、@Repository等注解中的任意一个（根据实际场景选择不同的注解）

2. 开启Spring的自动扫描功能

3. 实现Student类和Department类Bean的创建

@Component
public class Department {
  private String name;
}

@Component
public class Student {
  private Department department;
}

2. 实现Student类对Department类Bean的依赖

@Component
public class Department {
  private String name;
}

@Component
public class Student {
  @Autowired
  private Department department;
}

等等，我们看到了什么，怎么这么简单，没有构造函数，没有setter方法，仅仅通过两个注解就解决了问题！！！
是的，这就是Spring自动扫描并注入的强大之处。但是，但是，但是，一定要开始Spring的自动扫描和注入功能，否则上面的代码Spring是识别不了的。开启方式有如下两种：

1. 在JavaConfig中添加

@Configuration
@ComponentScan
public class ApplicationConfig{

}

2. 在XML配置文件中开

<?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:util="http://www.springframework.org/schema/util"
       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/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.lianglei.springfeaturetest"/>
</beans>

可以看出，还是Java配置的方式更加的简单明了。

@ComponentScan默认只扫描Config类所在的包及其子包，可以通过basePackages属性指定扫描的顶级包
自动化配置中，bean的名字默认为类名的首字母小写，即student和department

3.4 混合配置

Spring中上诉三种配置方式并不是互斥的，相反他们是可以组合的，也就是可以混合配置。其原因在于Spring并不关系Bean的创建来自于哪里，只要其在容器中即可。

3.4.1 JavaConfig配置和自动配置混合

对于我们自己开发的组件，实际上没有必要在JavaConfig类中进行Bean的声明，可以直接在类上通过诸如@Component进行注解即可。但是当采用的是第三方库的时候，自动配置就无能为力了，因为我们不能在类库中插入@Component注解。
换句话来说，自己开发的类采用自动配置，引入的第三方库采用JavaConfig方式。

3.4.2 XML和自动配置混合

和3.4.1一样，只不过将Bean的配置代码放到了XML中， 这种方法因为不是强类型的，很容易出错，不如JavaConfig来的直观方便。

在JavaConfig中引用XML配置

我们都知道Spring一开始使用的是XML配置，如果现在想采用JavaConfig而不改变原来的配置，我们可以通过@ImportResource注解将XML导入到JavaConfig中，形式如下：

@Configuration
@ImportResource("classpath:application-context.xml")
public class ApplicationConfig{

}

XML配置中导入JavaConfig

只要在XML配置文件中将JavaConfig声明成一个bean就好了

<?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:util="http://www.springframework.org/schema/util"
       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/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
   <bean class="com.lianglei.springfeaturetest.config.ApplicationConfig"
</beans>

更多

从上面可以看出，混合装配的方式有很多，很灵活，更多的配置方式大家可以去试试看。

装配方式的选择

在传统的spring项目中，大多数使用的是XML配置的方式配置Bean，但是现在Spring官方更加推荐使用Java配置的方式。那么，究竟哪种方式好呢？
我个人认为，每种方式都有优缺点，不能一概而论肯定也不能一味否定。很多情况下，上述几种方式都可行，这时候就看个人喜好选择一种即可。个人认为，有限使用自动配置，然后JavaConfig，最后XML。
但是有时候，有些方法并不适合，这时候就应该选择其他的方式。下面列出一些不可行的场景以供参考：

• 装配第三方库
  当装配第三方库的时候，我们没有办法在库中类上添加@Component等注解，所有自动装配的方式就不可行。那么可以采用XML配置和JavaConfig配置，这两个方法的区别就在于是在XML配置文件中写Bean的配置还是在Config类中去配置。