Spring基础之——控制反转（IOC）、依赖注入（DI）与切面编程（AOP）概念详解（适合小白，初学者必看）

前言

        本篇博客讲详细介绍Spring框架中的两个最核心且最基础的概念：控制反转（IOC）和面向切面编程（AOP）。以及如何通过IDEA来构建一个Spring项目，通过实战和理论结合的方式来让大家真的学会Spring这个最流行的Java框架。

一、认识Spring（是什么）

1. Spring框架的概述

        Spring是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

        它是为了解决企业应用开发的复杂性而创建的。

Spring的核心是控制反转（IOC）和面向切面（AOP）：

• IOC:控制反转，将创建对象的过程交给spring进行管理.
• AOP:面向切面，在不修改源代码的情况之下进行代码功能的增强.

2. Spring框架的优点

• 方便解耦，简化开发，Spring就像一个大工厂，将所有对象的创建和依赖关系维护，交给Spring管理，这也是IOC的作用。
• AOP编程的支持，Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。
• 声明式事务的支持，只需要通过配置就可以完成对事务的管理，而无需手动编程。
• 方便程序的测试，Spring支持Junit4，可以通过注解方便的测试Spring程序。
• 方便集成各种优秀框架，Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts2、Hibernate、MyBatis等）的直接支持。
• 降低JavaEE API的使用难度，Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低。

二、Spring项目的创建

如今IDEA比较主流，下面我来演示如何使用IDEA来创建一个Spring项目。

1. 首先我们创建一个Maven工程

不知道如何创建Maven工程的小伙伴，请参考我的这篇博客：

Maven学习—如何在IDEA中配置Maven？又如何创建Maven工程？(详细攻略)_idea创建maven项目-CSDN博客

2. 引入Spring相关的依赖坐标

Spring框架基础依赖:

<dependencies>
<!--    Spring框架基础依赖    --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.2.RELEASE</version></dependency><dependency><groupId>commons-logging</groupId><artifactId>commons-logging</artifactId><version>1.2</version></dependency><!-- 日志 --><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.12</version></dependency><!-- 单元测试 --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency></dependencies>

AOP面相切面编程的依赖: 

<!--  AOP面相切面编程的依赖 --><!--AOP联盟--><dependency><groupId>aopalliance</groupId><artifactId>aopalliance</artifactId><version>1.0</version></dependency><!--Spring Aspects--><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>5.0.2.RELEASE</version></dependency><!--aspectj--><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.8.3</version></dependency>

3. 创建Spring核心的配置文件 

在resources目录下创建applicationContext.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:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"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 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"></beans>

以上内容，就是一个最基础的Spring项目的创建方法。

三、Spring IOC容器

1. 什么是IOC

IOC （Inverse of Control），控制反转，将对象的创建权力交给给Spring框架去管理，实现控制权的反转。

2. IOC实现的底层原理

IOC的实现，依赖于以下3种技术

• ① dom4j解析xml文档；
• ② Java对象的一种创建方式：工厂模式；
• ③ 采用Java中反射技术来创建对象

想要了解对底层原理深入了解的小伙伴，可以去Spring官网下载Spring底层源码。

Spring官方网站  Spring | HomeLevel up your Java code and explore what Spring can do for you.https://spring.io/

ioc底层有用到反射，面试时如果可以扯一扯Java基础反射相关的东西； 

3、IOC的具体使用

常规情况下，类A中使用类C示意图：

当有了IoC/DI的容器后，A类不再主动去创建C了，
而是被动等待，等待IoC/DI的容器获取一个C的实例，然后反向的注入到A类中，如下图所示：

                                               有IoC/DI容器后程序结构示意图

      

1. 控制反转（IOC）：是从容器的角度出发，既：容器控制应用程序，由容器反向的向应用程序注入其所需要的外部资源。

2. 依赖注入（DI）：是从应用程序的角度在描述，既：应用程序依赖容器创建并注入它所需要的外部资源；

         根据上面的讲述，应该能看出来，DI和IOC是对同一件事情的不同描述，从某个方面讲，他们就是同一概念，只是描述的角度不同。

        当然对于我们初学者，我们首先去掌握spring IOC的使用方法即可；下面我来用基础代码为大家演示：Spring的控制反转和依赖注入两大设计理念的含义：

代码演示：

（1）通过IOC来创建Java类

①首先我先定义几个普通的Java类:

Teacher类：

 User类：

 通常情况下，我们若想要去创建这两个类的对象的话，会像下面这样：

• 使用最普通New的方式
• 使用反射的方式创建对象

    public void createObjTest01() throws ClassNotFoundException {//1.使用最普通new的方式User user = new User();//2.使用反射的方式创建对象(需要在方法上抛出“找不到类”的异常)Class clazz = Class.forName("com.yzx.pojo.User");}

 ②但如果我们使用了Spring，我们创建对象的方式将发生改变，演示如下：

首先，在Spring的xml配置文件中进行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:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"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 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"><bean id="user" class="com.yzx.pojo.User"></bean><bean id="Teacher" class="com.yzx.pojo.Teacher"></bean></beans>

•  id  后面是你自定义该类的别名；
• class 后面是你要托管给Spring管理的类的全路径；

然后，我们在test目录下创建一个测试类，来验证Spring是否已经可以管理这两个类。

 测试类中的测试方法内容如下：

@Testpublic void createObjTest02() throws ClassNotFoundException {//1.首先加Spring的载配置文件ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");//2.然后通过ApplicationContext的对象来获取所需对象User user = (User)ac.getBean("user");Teacher teacher = (Teacher)ac.getBean("teacher");usr.test();teacher.test();}

   运行结果：

 

（2）通过IOC向类注入属性值

首先我们在Spring配置文件中为对象注入属性值

方法一：使用<property>标签来实现对属性的注入，

1.使用<property>标签来实现对属性的注入，使用该标签进行属性注入时，要求pojo类中必须配有setter方法，因此，该方法通常叫做使用setter方法注入2.标签属性：
name:类中的属性名称
value:向属性注入的值
ref：对象映射

代码如下：

<bean id = "usr" class="com.yzx.pojo.User"><!--  ①配置基本类型的属性值   --><property name="id" value="1"/><property name="username" value="admin"/><property name="password" value="123"/><!--  ②配置数组类型的属性值   --><property name="strs"><array><value>admin</value><value>张三</value><value>李四</value></array></property><!--  ③配置List集合类型的属性值   --><property name="list"><list><value>熊大</value><value>熊二</value></list></property><!--  ④配置map集合类型的属性值   --><property name="map"><map><entry key="aaa" value="小白"/><entry key="bbb" value="小黑"/></map></property></bean>

方法二：使用<property>标签来实现对属性的注入，

1.使用<constructor-arg>标签来实现对属性的注入，使用该标签进行属性注入时，要求pojo类中必须配有构造器，因此，该方法通常也叫做利用类的构造器注入。2.标签属性：
name:类中的属性名称
value:向属性注入的值
ref：对象映射

<bean id="teacher" class="com.yzx.pojo.Teacher"><!--  ①配置基本类型的属性值   --><constructor-arg name="id" value="1"/><constructor-arg name="tname" value="李老师"/><!--  ②配置数组类型的属性值   --><constructor-arg name="nums"><array><value>1</value><value>2</value><value>3</value><value>4</value></array></constructor-arg><!--  ③配置List集合类型的属性值   --><constructor-arg name="list"><list><value>"你好"</value><value>"spring"</value></list></constructor-arg><!--  ④配置map集合类型的属性值   --><constructor-arg name="map"><map><entry key="张三" value="12"/><entry key="李四" value="15"/></map></constructor-arg></bean>

测试代码：

@Testpublic void createObjTest02() throws ClassNotFoundException {//1.首先加Spring的载配置文件ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");//2.然后通过ApplicationContext的对象来获取所需对象User user = (User)ac.getBean("usr");Teacher teacher = (Teacher)ac.getBean("teacher");System.out.println(user.toString());System.out.println(teacher.toString());}

运行结果：

小结：

通过上述演示，相信大家对Spring框架中IOC和DI的概念有了基础的认识；

        其实IoC/DI对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本具有最大的主动权，需要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC/DI容器来创建并注入应用程序所需要的资源了。
        这样一个改变其实是编程思想的一个大进步，如此就可以有效的分离了对象和它所需要的外部资源，使得代码的耦合度降低，有利于代码复用，更重要的是使得程序的整个体系结构变得非常灵活。

四、Spring AOP面向切面编程

由于篇幅有限，AOP的具体内容请看小编下面的这篇博客

本文参考文献：

控制反转（IOC）和依赖注入（DI）的区别（详细 通俗易懂解释）_控制反转和依赖注入的理解(通俗易懂)-CSDN博客