Java必备干货：Spring框架之IOC的基本配置

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.  
39. private Cpu cpu;
40. private Memory memory;
41. private String brand;
42. ...省略get\set
43. 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();
            }
44. }

 

在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.  
3. @Test
4. public void testComputer(){
5. //建立XML文件的应用程序上下文对象
6. ClassPathXmlApplicationContext cxt =
7. new ClassPathXmlApplicationContext("applicationContext.xml");
8. //经过类型从容器得到Java对象
9. Computer computer = cxt.getBean(Computer.class);
10. //还能够经过对象名得到对象
11. //        Computer computer = (Computer) cxt.getBean("computer");
12. computer.start();
13. }
14. }

使用注解配置

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.  
6. @Value("苹果电脑")
7. private String brand;
8.  
9. @Autowired
10. private Cpu cpu;
11.  
12. @Autowired
13. private Memory memory;
14. ....
15. }
16.  
17. @Configuration
18. @ComponentScan("com.qianfeng.springioc.demo4")
19. public class MyConfig {
20.  
21. public static void main(String[] args) {
22. //建立基于注解的上下文对象
23. AnnotationConfigApplicationContext cxt = new AnnotationConfigApplicationContext(MyConfig.class);
24. //得到Computer对象
25. Computer computer = cxt.getBean(Computer.class);
26. computer.start();
27. }
28. }

总结

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