上一篇我们总结了Spring的发展历史，并且提到了在Spring3.x和Spring4.x、Spring Boot推荐使用Java配置方式来对Spring进行配置，本篇着重介绍如何使用Java配置方式来进行Spring的框架配置。
虽然Spring的各个版本都支持XML配置，但是在Spring4.x是推荐使用Java配置方式的，它可以完全替代XML配置。
一、核心注解
Java配置方式最重要的两个注解就是@Configuration和@Bean，它们的作用如下：
1、@Configuration作用于类上，相当于一个XML配置文件。
2、@Bean作用于方法上，相当于XML配置中的<bean>。
二、样例编写
下面我们编写一个样例工程，在其中采用Java的配置方式进行配置，来实现IOC控制反转的效果。
我们在Eclipse中新建一个名为“Spring_Configuration_Test”的Maven工程：
然后我们在POM文件中导入相关的依赖：
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.com.spring.configuration</groupId>
<artifactId>Spring_Configuration_Test</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.3.7.RELEASE</version>
</dependency>
<!-- 连接池 -->
<dependency>
<groupId>com.jolbox</groupId>
<artifactId>bonecp-spring</artifactId>
<version>0.8.0.RELEASE</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<configuration>
<version>3.1</version>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
</project>Update Project后，我们在src/main/java中创建一个名为User的类：
package cn.com.spring.config.bean;
public class User {
private String username;
private String password;
private int age;
public User(String username, String password, int age) {
super();
this.username = username;
this.password = password;
this.age = age;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}然后我们要模拟对这个User进行数据库操作，需要编写Dao数据连接层和Service业务层。
Dao层的代码如下：
package cn.com.spring.config.dao;
import java.util.ArrayList;
import java.util.List;
import cn.com.spring.config.bean.User;
public class UserDao {
private static List<User> userList;
static{
//构建List，模拟数据库查询结果集
userList = new ArrayList();
userList.add(new User("Jack","Pass1234",21));
userList.add(new User("Tom","Pass4321",35));
userList.add(new User("Jean","Pass1122",19));
userList.add(new User("Eric","Pass2211",23));
}
public List<User> queryUserList(){
return userList;
}
}在这里使用静态代码块初始化了一个List，里面是一些用户的信息，模拟查询数据库的返回结果集。
之后我们编写Service业务层，来调用Dao进行用户信息查询：
package cn.com.spring.config.service;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import cn.com.spring.config.bean.User;
import cn.com.spring.config.dao.UserDao;
@Service
public class UserService {
@Autowired//注入Spring容器中的bean对象
private UserDao userDao;
public List<User> queryUserList(){
return this.userDao.queryUserList();
}
}我们在Service类中使用@Autowired注解来注入Dao对象，然后调用其查询方法返回用户数据。最后，要在Service类上添加@Service注解，该注解表示这个Service类会被加入到Spring的容器中，可以被其它类注入。我们可以注意到，UserDao的类上并没有添加任何注解，此时我们的Service是不可能通过@Autowired注入UserDao的，此时我们需要将Dao通过Java配置的方式配置到Spring容器当中。
下面我们编写SpringConfig类，作为之前的XML配置文件：
package cn.com.spring.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import cn.com.spring.config.dao.UserDao;
@Configuration//通过该注解来表明该类是一个Spring的配置，相当于一个XML文件
@ComponentScan(basePackages = "cn.com.spring.config")//配置扫描语句
public class SpringConfig {
@Bean//该注解来表明是一个Bean对象，相当于XML中的<bean>
public UserDao getUserDao(){
return new UserDao();
}
}在该类中，@Configuration注解就表明了这个类是一个Spring的配置类，和我们之前的XML配置文件性质一样。然后配置的@ComponentScan注解表示让Spring扫描注解的包的位置在哪，相当于XML中的<context:component-scan base-package="xxx.xxx" />配置。然后@Bean注解相当于之前我们在XML中配置的<bean/>标签，@Bean注解对应的方法返回的对象就是该类的实现类的实体。配置完成后，我们来启动工程进行测试。下面是测试类：
package cn.com.spring.config.test;
import java.util.List;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import cn.com.spring.config.SpringConfig;
import cn.com.spring.config.bean.User;
import cn.com.spring.config.service.UserService;
public class TestMain {
public static void main(String[] args) {
//通过Java配置来实例化Spring容器
//初始化Spring上下文对象，即Spring容器
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
//在Spring容器中获取Bean对象
UserService userService = context.getBean(UserService.class);
//调用对象中的方法，查询用户信息
List<User> userList = userService.queryUserList();
for(User u:userList){
System.out.println(u.getUsername()+"|"+u.getPassword()+"|"+u.getAge());
}
//调用结束，销毁Spring容器
context.destroy();
}
}在该测试类中，首先初始化了Spring容器，然后从容器中获得了UserService类，并调用了queryUserList获取和打印了所有用户信息，然后调用Spring容器的destroy销毁Spring容器。
测试结果：
整个注入的流程如下：
调用context.getBean方法去获取“UserService.class”时，首先通过在SpringConfig类中配置的ComponentScan注解去扫描相应包，扫描到了带有@Service标签的名为UserService的类，并准备实例化该类；在实例化该类的时候，又检测到在UserService类中使用@Autowired注解注入了UserDao类，此时Spring会在容器中寻找该类的配置，而我们刚好在SpringConfig类中通过@Bean配置了getUserDao的方法，并标记为一个@Bean，然后返回了一个UserDao的实例。所以最终Spring容器返回了一个UserService实体对象，并且该对象中也注入了UserDao的实体类，故而最后UserService成功调用UserDao的queryUserList方法，查询到了所有用户的信息。
该过程可简化为图：
可以看到使用Java配置可以完全替代XML的配置，并且通过Java配置可以一目了然的知道各个配置的情况，无需在Java类和XML之间相互观察才能了解相互的依赖关系。总的来说，Java配置方式简洁、清晰，这也是Spring4.x和Spring Boot为什么推荐的原因。
参考：
传智播客《Spring Boot实战与原理分析》视频课程
(https://pan.baidu.com/s/1o9M2bGI 密码：jxg8)
转载请注明出处：https://blog.csdn.net/acmman/article/details/81214266