Spring 框架之 IOC 的基本配置 ， 前言，上一章我们学习了 Spring 的 IOC 特性以及 IOC 的实现原理：注解和反射，本章我们将学习如何在 Spring 中使用 IOC 。

Spring 的 IOC 配置

Spring 最重要的特性是 IOC 控制反转，利于 IOC 我们能降低对象之间的耦合性。

IOC 需要通过一定的配置实现，配置方法分为：

1） 使用 xml 文件配置

2）使用注解配置

使用 Spring 的基本功能，必须先导入 Spring 的依赖：

1. <dependency>
2. <groupId>org.springframework</groupId>
3. <artifactId>spring-context</artifactId>
4. <version>5.1.5.RELEASE</version>
5. </dependency>

Spring Context ：向  Spring 框架提供上下文信息。 Spring  上下文包括企业服务，例如 JNDI 、 EJB 、电子邮件、国际化、校验和调度功能。它包含 Spring Core 组件，能实现 IOC 的核心功能。

使用 xml 文件配置

1. /**
2. * CPU 接口
3. */
4. public interface Cpu {
5. void run();
6. }
7. /**
8. * AMD 的 CPU
9. */
10. public class AMDCpu implements Cpu {
11. public void run() {
12. System.out.println("AMD 的 CPU 正在运行 ....");
13. }
14. }
15. /**
16. *  内存接口
17. */
18. public interface Memory {
19. void read();
20. void write();
21. }
22. /**
23. * DDR8G 的内存
24. */
25. public class DDR8GMemory implements Memory {
26. public void read() {
27. System.out.println(" 使用 DDR8G 的内存读取数据 ....");
28. }
29. public void write() {
30. System.out.println(" 使用 DDR8G 的内存写入数据 ....");
31. }
32. }
33. 类似的 IntelCpu 和 DDR16Memory 类省略了代码
34. /**
35. *  电脑类
36. */
37. public class Computer {
38. private Cpu cpu;
39. private Memory memory;
40. private String brand;
41. ... 省略 get\set
42. public Computer() {
    }
    
            public Computer(String brand, Cpu cpu, Memory memory) {
             this.brand = brand;
         this.cpu = cpu;
         this.memory = memory;
            }
    
            public void start(){
         System.out.println(brand+" 电脑启动了 ");
         cpu.run();
         memory.read();
         memory.write();
            }
43. }

在 maven 项目的 resources 目录下，添加配置文件：

applicationContext.xml

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. xmlns:context="http://www.springframework.org/schema/context"
5. xsi:schemaLocation="http://www.springframework.org/schema/beans
6. http://www.springframework.org/schema/beans/spring-beans.xsd
7. http://www.springframework.org/schema/context
8. http://www.springframework.org/schema/context/spring-context.xsd">
9. <!-- CPU 对象 -->
10. <bean id="cpu" class="com.qianfeng.springioc.demo3.IntelCpu"/>
11. <!--Memory 对象 -->
12. <bean id="memory" class="com.qianfeng.springioc.demo3.DDR16GMemory"/>
13. <!-- 电脑对象 -->
14. <bean id="computer" class="com.qianfeng.springioc.demo3.Computer">
15. <!-- 属性的注入 -->
16. <property name="cpu" ref="cpu"></property>
17. <property name="memory" ref="memory"></property>
18. <property name="brand" value=" 小米电脑 "></property>
19. </bean>
20. </beans>

配置说明：

<beans> 是根标签，代表 Spring 的 Java 对象容器

<bean> 标签代表在容器中创建一个 Java 对象，属性 id 代表对象名， class 是对象的类型。

在配置文件中首先创建了一个 cpu 对象和一个 memory 对象，然后创建了一个 computer 对象， computer 中有 Cpu 类型的 cpu 属性和 Memory 类型 memory 属性以及 String 类型的 brand 属性，这里使用依赖注入的方式给属性赋值。

<property name="cpu" ref="cpu"></property>

property  指的是对象的属性， name 是属性名， ref 是对象引用，这里引用了前面的 cpu 对象。

<property name="brand" value=" 华硕电脑 "></property>

brand 属性注入的是数值而不是对象引用，这里使用 value 注入值。

Spring 上下文对象

Spring 容器可以看做是一个 JavaBean 的工厂 BeanFactory ， BeanFactory 负责创建并保存各个 JavaBean ， BeanFactory 的子类有：

1 ） ClassPathXMLApplicationContext

基于 XML 配置文件上下文

2 ） AnnotationConfigApplicationContext

基于注解配置的上下文

3 ） FileSystemApplicationContext

基于文件系统的上下文

使用ClassPathXMLApplicationContext的方法：

1. public class TestComputer {
2. @Test
3. public void testComputer(){
4. // 创建 XML 文件的应用程序上下文对象
5. ClassPathXmlApplicationContext cxt =
6. new ClassPathXmlApplicationContext("applicationContext.xml");
7. // 通过类型从容器获得 Java 对象
8. Computer computer = cxt.getBean(Computer.class);
9. // 还可以通过对象名获得对象
10. //        Computer computer = (Computer) cxt.getBean("computer");
11. computer.start();
12. }
13. }

使用注解配置

Spring 的 IOC 也可以不使用配置文件，完全通过 Java 代码和注解实现配置，这种配置方法代码更加简洁。

常用注解：

@Component

配置到类上面， Spring 容器会自动扫描并添加有该注解类的对象

@Autowired

配置到属性或 set 方法上，容器会将容器中同类型的对象自动注入到属性中

@Qualifier

用于给不同的组件设置标识，用于区分多个相同类型的对象

@Value

注入一般类型的值，如： @Value(20)  、  @Value(" 张三 ")

@Configuration

加在配置类上，该类作为 Spring 启动的入口

@ComponentScan

和 @Configuration 配合使用，加在配置类上，用于扫描包中所有 @Component 注解的类

1. 在 DDR8Memory 类和 IntelCpu 类上添加 @Component 注解
2. 修改 Computer 类：
3. @Component
4. public class Computer {
5. @Value(" 苹果电脑 ")
6. private String brand;
7. @Autowired
8. private Cpu cpu;
9. @Autowired
10. private Memory memory;
11. ....
12. }
13. @Configuration
14. @ComponentScan("com.qianfeng.springioc.demo4")
15. public class MyConfig {
16. public static void main(String[] args) {
17. // 创建基于注解的上下文对象
18. AnnotationConfigApplicationContext cxt = new AnnotationConfigApplicationContext(MyConfig.class);
19. // 获得 Computer 对象
20. Computer computer = cxt.getBean(Computer.class);
21. computer.start();
22. }
23. }

总结

本章我们学习了两种 Spring 的配置方法， XML 配置的好处是：和代码耦合性低，容易维护，注解配置的好处是：代码简洁。两种配置方法的优势互补，在实际开发过程中一般会使用 XML 和注解混合进行配置。