1.4 Spring基础知识

---

---

1.概述

我们要从其历史背景的发展中了解Spring，最初的开发工作中，并没有什么框架的存在，大家都是在使用一种语言单纯的开发自己的业务，当开发大型项目时，前端，后端，服务器等代码全都堆积到一起，深度耦合，在后期基本没有可维护性和拓展性。

等到MVC框架出现后，开始将代码开发过程中代码大致分为三块区域，Model层封装数据，View视图层页面展现，Controller控制层访问转发。代码之间的耦合度降低。概念有了，需要实际干活的。于是随着mvc分层概念的深入人心，业界涌现出很多实现框架，最著名的莫过于struts1和struts2。随着前端框架的成熟，后端框架也应运而生如：dbutils、jdbcTemplate、hibernate、ibatis、mybatis。

随着前端框架与后端框架的完善，Spring作为前后端连接的框架也出现在了大家的视野中。

Spring的目的是将全球最好的技术组合到一起，为企业提供高质量的企业级的应用程序框架，减轻开发者开发的难度，减少重复的代码。

起初，struts2作为WEB框架深受企业爱戴，它会自己管理action，来创建其实例，这样在程序中就可以访问action的资源。hibernate作为持久层优秀的框架，它也自己管理持久对象。可以看到，此时已经有框架出现，并能自己管理对象，而要想让它们对象复用，那真是繁琐。前面就有失败者WebService，为了管理不同的开发语言的对象而层层包装转换，辛苦制定的规则，还借着J2EE规范之名，也推广不开。

但是在java的世界里最重要的无疑就是对象的生命周期管理。于是spring以此为切入点，实现自己的统治。官宣所有对象由我来管理，struts2你不再管理对象，由我来管理，你要用从我这拿。hibernate你也不再管理对象，由我来管理，你要用从我这拿。你说管就能管的吗？这两个征战数年战功赫赫的大将军会听一个初出茅庐乳臭未干野小子的话？他们当然不会听，spring的话可以不听，但他们都要听开发者的。开发一个完整的系统有四个核心，WEB层支持、业务逻辑层、持久层支持、事务支持。而这就是它们的软肋，这就是它们的命门所在，它们只能完成一部分工作，不是一个整体解决方案。而spring并没有抹杀它们，而是依然给它们高官厚禄，承认它们的市场地位，还赠与一个事务管理。一边打压一边拉拢，它们两位看看大势已去，只能俯首称臣。于是兵不血刃，一场变革悄然兴起，一个经典的三层框架诞生SSH （Strut2+Spring+Hibernate）。

故事很传奇，听的人很开心。可spring真就这么简单吗？如果这样想，你就大错特错了。例如：spring怎么来实现对象的管辖？怎么让不同技术之间能简单的互相配合？这才是spring的决胜之处。

更多介绍和原理何以到其官网进行了解，官网提供完整的技术文档，但对英语有一定要求：https://spring.io/

1.1 框架组成

为实现这些spring可是绞尽脑汁、煞费苦心。它创新的形成了一套新的理论体系，可谓前无古人后无来者。其中最核心的是：IOC控制反转、DI依赖注入、Bean工厂、SpringAOP面向切面编程、事务控制。

并且spring并没有停止不前，这只是统治地球的第一步，随着spring占领市场后，开始对有功之臣进行清洗，struts2不再优秀，致命bug层出不穷，刚好落井下石，spring推出了springmvc，最终终结了struts2。hibernate想用jdbcTemplate和jdo替代，却被mybatis超越，目前还未统一。世界又达到新的平衡，经典的新三大框架诞生，SSM（SpringMVC+Spring+MyBatis）。Spring并没有放弃，而是另辟蹊径，推出新的产品SpringBoot+SpringCloud 微服务，目前新的趋势已经尘埃落定，一统江湖！

Spring是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。Spring框架的不光是技术牛，而是它的核心思想更牛，它不重复发明轮子，而是"拿来主义"，把业界做的最好的技术黏合起来形成一个强大的企业级的应用框架。

Spring 框架是一个分层架构，由7个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如下图所示：

模块	说明
核心容器Spring Core	核心容器提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式，将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring上下文Spring Context	Spring上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP	通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。可以很容易地使 Spring框架管理的任何对象支持AOP。Spring AOP模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO	JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM	Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括JDO、Hibernate和iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web	Web上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以Spring 框架支持与 Jakarta Struts的集成。Web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC	MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

Spring 框架的功能可以用在任何J2EE服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定J2EE服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同J2EE环境（Web或EJB）、独立应用程序、测试环境之间重用。

Spring以一种非侵入式的方式来管理你的代码，Spring提倡"最少侵入"，这也就意味着你可以适当的时候安装或卸载Spring ，但这点越来越模糊。

1.2 核心概念

模块	说明
BeanFactory	Spring内部使用，创建bean的工厂
ApplicationContext	外部应用程序调用，也成为spring容器
IOC控制反转Inversion of Control	开发者在无需自己new对象，无需关心对象的创建过程User user = new User(); 手动创建对象User user = context.getBean(user); 容器创建对象
DI依赖注入Dependency Injection	松耦合方式实现对象直接的依赖
AOP面向切面编程	对java的面向对象编程进一步优化，补充java面向对象的不足

1.3 三大核心组件的关系

Bean、Context、Core三大核心组件的关系：

Bean 包装的是 Object，而 Object 必然有数据，如何给这些数据提供生存环境就是 Context要解决的问题，对 Context 来说它就是要发现每个 Bean 之间的关系，为它们建立这种关系并且要维护好这种关系。所以 Context 就是一个Bean关系的集合，这个关系集合又叫 Ioc 容器，一旦建立起这个 Ioc 容器后 Spring 就可以为你工作了。那 Core 组件又有什么用武之地呢？其实Core 就是发现、建立和维护每个 Bean 之间的关系所需要的一些类的工具，从这个角度看来，Core 这个组件叫 Util 更能让你理解。

把Bean 比作一场演出中的演员的话，那 Context 就是这场演出的舞台背景，而 Core应该就是演出的道具了。只有他们在一起才能具备能演出一场好戏的最基本的条件。当然有最基本的条件还不能使这场演出脱颖而出，还要他表演的节目足够的精彩，这些节目就是 Spring 能提供的特色功能了。

模块	说明
org.springframework.core	核心工具包，其他包依赖此包
org.springframework.beans	核心，包括：配置文件，创建和管理bean等
org.springframework.aop	面向切面编程，提供AOP的实现
org.springframework.context	提供IoC功能上的扩展服务，此外还提供许多企业级服务的支持，邮件、任务调度、JNDI定位、EJB集成、
org.springframework.web.mvc	包含SpringMVC应用开发时所需的核心类
org.springframework.transaction	为JDBC、Hibernate、JDO、JPA提供一致的声明式和编程式事务管理
org.springframework.web	包含Web应用开发时所需支持类
org.springframework.aspects	提供对AspectJ框架的支持
org.springframework.test	对junit等测试框架的简单封装
org.springframework.asm	3.0后提供自己独立的，反编译
org.springframework.context.support	Context的扩展支持，用于mvc方面
org.springframework.expression	Spring表达式语言
org.springframework.instument	对服务器的代理接口
org.springframework.jdbc	对jdbc的简单封装
org.springframework.jms	为简化jms api的使用而做的简单封装
org.springframework.orm	整合第三方orm，如hibernate/mybatis
org.springframework.web.servlet	增强servlet

2.Spring框架两大核心：IOC和DI

2.1 概念

• IOC（Inversion of Control）简单来说就是将对象Object的创建的权力及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不在需要关注对象的创建和生命周期的管理，而是在需要的时候由Spring框架提供，这个由Spring框架管理对象创建和生命周期的机制称之为控制反转。
• 在创建对象的过程中Spring可以依据对象的关系，自动把其它对象注入（无需创建对象，直接拿着使用）进来，这个过程称之为DI（Dependency Injection）依赖注入。

总结来说，其核心帮助我们完成了俩件事情：创建对象，并设置对象之间的关联关系。

这俩件事情在实际开发中，可以大大帮助减少工作负担，面对对象复杂的创建，生命周期管理，调用过程，直接由Spring进行完成即可，我们只需要使用就可以了。

2.2 IOC

IOC（Inversion of Control），控制反转。

就是指将对象的创建，对象的存储(map)，对象的管理(依赖查找,依赖注入)交给了spring容器。

2.3 DI

DI（Dependency Injection）依赖注入 。

相对于IoC而言，依赖注入(DI)更加准确地描述了IoC的设计理念。所谓依赖注入，即组件之间的依赖关系由容器在应用系统运行期来决定，也就是由容器动态地将某种依赖关系的目标对象实例注入到应用系统中的各个关联的组件之中。

3.IOC(Inversion of Control)控制反转

3.1 xml方式使用

3.1.1 准备测试资源

xml方式相对来说比较古老，目前较新的项目大多使用注解方式使用IOC，但其更能体现IOC的核心思想，方便大家理解。

首先，我们创建新的maven Module：

然后在新的Module中的java目录下，创建一个spring目录，并在spring目录下Hello类：

我们直接输入spring.Hello点击创建，IDEA会帮我们自动创建不存在的路径。

package spring;

import com.oracle.xmlns.internal.webservices.jaxws_databinding.SoapBindingUse;

public class Hello {
    public void show (){
        System.out.println("show()被调用成功！");
    }
}

3.1.2 准备配置文件

我们先在resources目录下创建XML文件，如果没有此选项也可以直接通过上方的file文件输入.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">

</beans>

.xml文件中也使用标记语言，其第一行标记其是xml文件，版本为1.0，编码格式为UTF-8，xmlns中都是一些语法规则要求的配置文件，我们在文件中可以添加多个bean标签，其对位置，类型有严格要求，spring认为万物都是bean，只要我们的类交给spring框架，spring就能使用IOC进行管理，spring使用IOC控制反转帮助我们创建，管理，提供给我使用对象：

<?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="hello" class="spring.Hello"></bean>
</beans>

其中id属性是唯一标识，不能重复，class属性是用来指定类的，其底层本质就是一个map { "hello",Class.forname(spring.Hello").newInsTance() }。通过反射获取对象实例，并且可以通过scope="prototype设置bean对象是单例的还是多例的。

3.1.3 准备测试类

spring框架提供测试类的使用支持，我们在test包下，根据src包的相关目录创建我们的测试类：

测试类的类名一般为要测试的类+Test:

我们在类中使用@Test注解来标注当前是一个测试类，被此标签标注的类，在打包时不会被编译，所以测试类中的代码出错，不会对打包后的程序产生任何影响：

package spring;

import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloTest {
    @Test
    public void bean() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        Hello h1 = new Hello();
        System.out.println(h1);
        h1.show();
        //根据id获取bean
        //Spring就是一个大工厂（容器）专门生成bean,bean就是对象
        //这里我们需要向下转型成Hello类型，才可以使用hello对象的show（）方法
        Hello hello = (Hello)ac.getBean("hello");
        System.out.println(hello);
        hello.show();
    }
}

运行测试类：

这就是spring框架的IoC，控制反转。之前我们自己new出新类。new User();变成由一个初始化的xml配置文件来创建，也就是由spring容器来创建。遍历xml配置文件，读取到，获取到class属性的类的全路径，利用反射创建这个类。

在java范畴中万物皆Object,在Spring中万物皆Bean。Bean是Spring的核心、基础、根源。

3.2 注解方式使用

接下来我们测试使用注解方式使用ioc，首先我们创建一个新的Module：ioc_two

3.2.1 修改pom.xml文件

我们需要修改新Module的配置文件，导入需要的依赖：

<?xml version="1.0" encoding="UTF-8"?>
<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>
    <parent>
        <groupId>cn.study</groupId>
        <artifactId>studyProject</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <artifactId>ioc</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>

        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>

    </dependencies>
</project>

3.2.2 准备测试资源

接下来我们测试注解方式使用spring的IOC功能，首先在spring文件夹下创建新的测试资源HelloIoc类：

package spring;

import org.springframework.stereotype.Component;

@Component
public class HelloIoc {
    public void hi() {
        System.out.println("Hello Spring.");
    }
}

我们在类中创建hi方法，并未类添加@Component注解，其把普通pojo实例化到spring容器中，把标注的类纳入进spring容器中进行管理。

3.2.3 准备配置文件

创建applicationContext.xml：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       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-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">



    <!-- 包扫描, 用注解的方式,配置bean
            会扫描指定包下,带@Component注解的类
            并注入spring容器中,key是类名小写,value是类的对象
        -->
    <context:component-scan base-package="cn.spring" />
</beans>

我们在配置文件中，设置包扫描的限定范围，spring会根据给定的范围进行包的扫描，找到包中使用了IOC注解的类，进行bean对象，管理，对于此路径的设置要合理，范围不能太大也不能太小，太大会影响程序运行效率，太小会导致无法扫描到自己需要的包。

IOC注解包含：

• @Component
  • 作用：用于把当前类对象存入Spring容器
  • 属性：value：用于指定bean的id，默认值为首字母小写的类名
• @Service:一般用于业务层
• @Controller:一般用于表现层
• @Repository:一般用于持久层

以上三个注解的作用和属性都相同，只是为了区分其标注的位置，所以使用了不同的表达

3.2.4 准备测试类

package spring;


import cn.spring.Hello;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloIocTest {
    @Test
    public void bean() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //根据id获取bean,beanname就是类名,首字母变小写
        Hello hello = (Hello) ac.getBean("hello");
        System.out.println(hello);
        hello.hi();


    }
}

运行测试类我们可以看到以正确打印对象：

3.2.5 常见错误

如果在设置配置文件时遇到此错误：

只需要在设置中将此网址添加到OTDs中即可解决：

4.DI(Dependency Injection)依赖注入

相对于IOC而言，依赖注入(DI)更加准确地描述了IOC的设计理念。所谓依赖注入，即组件之间的依赖关系由容器在应用系统运行期来决定，也就是由容器动态地将某种依赖关系的目标对象实例注入到应用系统中的各个关联的组件之中。我们接下来测试依赖注入的具体实现。

我们在工程下新建名为springDI的Moodule：

4.1 添加依赖

在新的Moodule中的pom.xml文件中添加我们需要的相关依赖：

<?xml version="1.0" encoding="UTF-8"?>
<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>
    <parent>
        <groupId>cn.study</groupId>
        <artifactId>studyProject</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <artifactId>SpringDI</artifactId>


    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- 集中定义依赖版本号 -->
        <junit.version>4.10</junit.version>
        <spring.version>4.1.3.RELEASE</spring.version>
    </properties>

    <dependencies>
        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>

        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

    </dependencies>


</project>

4.2 准备测试资源

按照下图目录结构准备相关测试资源类：

我们首先在配置文件中添加配置：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       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-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">


    <!-- 扫描包 -->
    <context:component-scan base-package="cn.di" />
</beans>

在Dept.java中，我们添加相关数据模型：

package cn.di;

import org.springframework.stereotype.Component;

@Component
public class Dept {
 
    String name = "java开发部";

    @Override
    public String toString() {
        return "Dept{" +
                "name='" + name + '\'' +
                '}';
    }

}

然后我们在User.java中添加相关数据模型，并使用依赖注入Dept类的数据：

package cn.di;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class User {
    String name = "jack";
    @Autowired  //相当于框架完成了:new User().setDept(new Dept());
    Dept dept;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", dept=" + dept +
                '}';
    }
}

最后，我们在测试类中测试：

package cn.di;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestUser {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

        Dept d = (Dept)ac.getBean("dept");
        User u = (User)ac.getBean("user");

        System.out.println(d);
        System.out.println(u);

        System.out.println(u.dept.name);
    }

}

在控制台中，我们不仅获取到了用户信息，同时也获取到了关联的部门信息：

DI是依赖IOC的完成来实现的，所以我们在测试DI时，也需要完成IOC的相关操作。

4.3 总结

这就是依赖注入，我们在A类中像使用成员变量一样使用B类的数据，spring帮助我们管理并导入相关的数据内容。

利用注解方式，我们只需要写@Autowired注解，底层就会去容器中找对应的对象，如果有获取到，反射调用其对应的set方法，设置。而这个调用过程都是自动，我们没有手工去写set方法。所以这个过程也称为自动装配。

在平时的java应用开发中，我们要实现某一个功能或者说是完成某个业务逻辑时可能需要多个对象来协作完成，在没有使用Spring的时候，每个对象在需要使用他的合作对象时，自己均要使用像new object() 这样的语法来将合作对象创建出来，这个合作对象是由自己主动创建出来的，创建合作对象的主动权在自己手上，自己需要哪个合作对象，就主动去创建，创建合作对象的主动权和创建时机是由自己把控的，而这样就会使得对象间的耦合度高了，A对象需要使用合作对象B来共同完成一件事，A要使用B，那么A就对B产生了依赖，也就是A和B之间存在一种耦合关系，并且是紧密耦合在一起，而使用了Spring之后就不一样了，创建合作对象B的工作是由Spring来做的，Spring创建好B对象，然后存储到一个容器里面，当A对象需要使用B对象时，Spring就从存放对象的那个容器里面取出A要使用的那个B对象，然后交给A对象使用，至于Spring是如何创建那个对象，以及什么时候创建好对象的，A对象不需要关心这些细节问题(你是什么时候生的，怎么生出来的我可不关心，能帮我干活就行)，A得到Spring给我们的对象之后，两个人一起协作完成要完成的工作即可。

所以控制反转IOC(Inversion of Control)是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权力转移到第三方，比如转移交给了IOC容器，它就是一个专门用来创建对象的工厂，你要什么对象，它就给你什么对象，有了 IOC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IOC容器了，通过IOC容器来建立它们之间的关系。

DI(依赖注入)其实就是IOC的另外一种说法，DI是由Martin Fowler 在2004年初的一篇论文中首次提出的。他总结：控制的什么被反转了？就是：获得依赖对象的方式反转了。

IOC有三个核心：BeanFactory、反射、DI。BeanFactory利用反射实现对象的创建，DI实现对象关系管理。

5.AOP面向切面编程

Spring核心特征中除了IoC控制反转、DI依赖注入，还有一个核心就是强大的面向切面编程AOP（Aspect Oriented Programming）的实现。

AOP 是实现程序功能统一维护的一种技术。它把众多模块涉及到的同一类问题进行了统一处理。利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合性降低，提高程序的可重用性，同时大大提高了开发效率。

将我们的代码形成切面，提供丰富的通知，让开发中更多可以关注业务本身，而不是代码。

AspectJ 作为 Java 中流行的 AOP（aspect-oriented programming） 编程扩展框架，有一些自己的语法和特点，Spring框架底层也是采用的 AspectJ来实现的面向切面编程。

AspectJ 成熟稳定,输入输出都是 .class 文件,直接处理字节码文件，这个过程并不简单，特别是针对于字节码的格式和各种指令规则，如果处理出错，就会导致程序编译或者运行过程中出现问题。使用起来非常简单，并且它的功能非常强大，我们完全不需要理解任何 Java 字节码相关的知识，就可以在很多情况下对字节码进行操控。

5.1 AOP的三要素

• 切面（Aspect）：类是对物体特征的抽象，切面就是对同一类问题（横切关注点）的抽象
• 通知（Advice）：来指定具体做什么事情。如方法执行前做什么，方法执行后做什么，抛出异常做什么，从而实现对象行为（方法）的增强
• 切点（PointCut）：配置切点表达式（expression）来指定在哪些类的哪些方法上织入（ware）横切一些逻辑
• 连接点（JoinPoint）：JPoint 是一个程序的关键执行点，也是我们关注的重点。它就是指被切点拦截到的点然后执行一些通知

5.2 通知

Spring框架实现了AOP面向切面，其引入了第三方AspectJ框架来具体实现。
AspectJ提供了五种切入方式，术语称为通知advice。
具体五种为：

1. 前置通知before：指调用业务方法前会被执行的功能（适用于权限管理，缓存管理）
2. 后置通知after：指调用业务方法后被执行的通知（适用于释放资源）
3. 环绕通知around：指调用业务方法的前，后都会被执行的通知（适用于事物管理，性能分析）
4. 返回后通知afterReturning：指调用业务方法并返回了结果后会被执行的功能（
5. 异常通知afterThrowing：指调用业务方法并返回了结果后会被执行的功能
6. 异常通知特殊：指调用业务方法并返回了异常后，会被执行的通知，这里暂不讨论

可以看到，分别在业务方法（Business Method）的执行前后进行拦截，执行指定的代码。

假设我们的类中有多个方法，我们需要统计每个方法的耗时，我们需要对每个方法写重复代码统计其时间，这时我们就可以定义一个切面，在切面中定义不同类型的通知Advice，通知Advice的执行可以根据类中方法的执行情况进行设置，例如方法执行前执行通知，在方法执行后执行通知等，可以根据不同的情况触发其通知。

简单来说，AOP就是一个类，而通知就是类中具体的方法，这些方法可以设定其执行条件。

5.3 多切面执行顺序

下面是 两个切面 各通知的执行顺序：

5.4 案例测试

5.4.1 使用面向对象思想

首先，我们需要在工程中添加AOP需要的jar包依赖，这次为了能让所有的Module都可以使用此依赖，我们将其添加到父工程的pom.xml中：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

假设我们需要统计目前工程中所有方法的耗时，接下来我们去实现它，首先我们在springDi的Module下创建一个新的controller包，并在包内创建一个TimeController类，目录结构如下：

我们在TimeController类中创建丰富的可供访问的方法，并先自行不适用AOP的方式完成方法性能的统计：

package cn.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RequestMapping("/time")
@RestController
public class TimeController {
    //提供丰富的方法，并统计每个方法的性能
    @RequestMapping("/get")
    public void get(){
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 5000; i++) {
            System.out.println(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("get方法共消耗" + (endTime-startTime) + "毫秒");
    }

    @RequestMapping("/find")
    public void find(){
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 8000; i++) {
            System.out.println(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("get方法共消耗" + (endTime-startTime) + "毫秒");
    }
}

然后我们在根目录下创建启动类，启动当前项目：

package cn;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RunApp {
    public static void main(String[] args) {
        SpringApplication.run(RunApp.class);
    }
}

然后启动，访问我们创建的方法：

此时控制台已打印我们的耗时：

当前代码确实还可以优化，但是优化难度大，实现多个方法的性能统计比较复杂，接下来我们使用面向切面的思想来解决此需求。

5.4.1 使用面向切面思想

首先我们新建一个aspect包，在包内创建TimeAspect类，将代码分离开，体现松耦合的思想：

然后我们在TimeAspect类中创建我们的面向切面代码：

package cn.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component//IOC的注解，标注当前是一个控制类
@Aspect//切面：由切点和通知组成，spring整合了Aspect提供了面向切面编程的方式
//切面就是一个类，由通知（方法）组成
public class TimeAspect {

    //切点表达式： *表示1个 ..表示多个 *依次代表方法返回值，类名，方法名，(..)是参数列表
    @Pointcut("execution(* cn.controller.*.*(..))")
    public void pointcut(){}

    @Before("pointcut()")//前置通知,在每一个方法开始之前被调用
    public void beforeMethod(JoinPoint joinPoint){
        System.out.println("我是前置通知");
    }
    @After("pointcut()")//后置通知,在每一个方法结束后被调用
    public void afterMethod(JoinPoint joinPoint){
        System.out.println("我是后置通知");
    }
    @Around("pointcut()")//环绕通知,方法执行前后都被调用,必须有返回值
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long time = System.currentTimeMillis();
        Object o = joinPoint.proceed();//放行,执行目标方法
        time= System.currentTimeMillis()-time;

        String methodName = joinPoint.getSignature().getName();//方法名
        System.out.print("我是环绕通知");
        System.out.println(methodName+"===耗时:"+time+"===");
        return o;
    }


}

• @Aspect注解表示这是一个切面
• @Pointcut注解表示这是一个切点
  • execution(* cn.controller.*.*(..))是切点的固定参数表达式，其中第一个*号表示任意的方法返回值，cn.controller表示包名，cn.controller.* 中的 * 表示我们的类名， * 号表示当前包下的任意类，cn.controller.*.*中的第二个 *号表示我们类中的任意方法，最后(..)表示方法中的参数列表，任意参数列表都可以。
• @Before注解表示这是一个前置通知
  • 前置通知中要添加切点，其会在切点之前执行前置通知
• @After注解表示这是一个后置通知
  • 后置通知中要添加切点，其会在切点之后执行前置通知
• @Around注解表示环绕通知
  • 环绕通知中要添加切点，其会在切点之前，之后执行前置通知

通知方法中可以包含一个 JoinPoint 类型参 数。该类型的对象本身就是切入点表达式。通过该参数，可获取切入点表达式、方法签名、 目标对象等。 不光前置通知的方法，可以包含一个 JoinPoint 类型参数，所有的通知方法均可包含该 参数。

接下来我们访问此前创建的方法，可以看到前置通知，后置通知，环绕通知都已执行：

不过方法中统计与面向切面编程统计结果不同，大家可以自行思考为什么不同，建议从方面执行顺序中进行思考。