1. Spring

1.1 Spring的历史与概述

原始时代我们用一个jsp搞定一切，但在开发大型项目时，前端美化的代码和后端的代码交织，代码中又有html、js、css样式，又有业务逻辑和数据库访问代码，使得杂乱不清晰，美工和开发打架。于是MVC分层架构出现，把代码分成了3部分，Model层封装数据，View视图层页面展现，Controller控制层访问转发，使得代码之间的耦合度降低。随着前端框架的成熟，后端框架也应运而生如：dbutils、jdbcTemplate、hibernate、ibatis、mybatis。
一个前端WEB层框架有了，一个后端数据库层访问框架也有了，现在需要一个中间的框架层，即：Spring破石而出。

Spring的野心：
它想把全球最好的技术组合到一起，为企业提供高质量的企业级的应用程序框架，减轻开发者开发的难度，减少重复的代码。
我们拿经典的框架来举例子：
struts2作为WEB框架深受企业爱戴，它会自己管理action，来创建其实例，这样在程序中就可以访问action的资源。hibernate作为持久层优秀的框架，它也自己管理持久对象。可以看到，各个诸侯都自己管理对象，而要想让它们对象复用，那真是繁琐。前面就有失败者WebService，为了管理不同的开发语言的对象而层层包装转换，辛苦制定的规则，还借着J2EE规范之名，也推广不开。

如何破局呢？想发号施令，想让人听从，最好的解决办法就是扼住他们的咽喉。在java的世界里最重要的无疑就是对象的生命周期管理。于是spring以此为切入点，实现自己的统治。官宣所有对象由我来管理，struts2你不再管理对象，由我来管理，你要用从我这拿。hibernate你也不再管理对象，由我来管理，你要用从我这拿。开发一个完整的系统有四个核心，WEB层支持、业务逻辑层、持久层支持、事务支持。而这就是它们的软肋，这就是它们的命门所在，它们只能完成一部分工作，不是一个整体解决方案。而spring并没有抹杀它们，而是依然给它们高官厚禄，承认它们的市场地位，还赠与一个事务管理。一边打压一边拉拢，它们两位看看大势已去，只能俯首称臣。于是兵不血刃，一场变革悄然兴起，一个经典的三层框架诞生SSH （Strut2+Spring+Hibernate）。

那么，Spring怎么来实现对象的管辖并且让不同技术之间能简单的互相配合：
为实现这些spring它创新的形成了一套新的理论体系，可谓前无古人后无来者。其中最核心的是：IoC控制反转、DI依赖注入、Bean工厂、SpringAOP面向切面编程、事务控制。
并且Spring并没有停止不前，这只是统治地球的第一步，随着Spring占领市场后，开始对有功之臣进行清洗，struts2不再优秀，致命bug层出不穷，刚好落井下石，Spring推出了Springmvc，最终终结了struts2。hibernate想用jdbcTemplate和jdo替代，却被mybatis超越，目前还未统一。世界又达到新的平衡，经典的新三大框架诞生，SSM（SpringMVC+Spring+MyBatis）。Spring并没有放弃，而是另辟蹊径，推出新的产品SpringBoot+SpringCloud 微服务，目前新的趋势已经尘埃落定，一统江湖！

1.2 Spring官网

http://spring.io

1.3 框架结构

Spring是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。
Spring 框架是一个分层架构，由7个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如下图所示：

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

模块	说明
Spring Core	核心容器提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式，将应用程序的配置和依赖性规范与实际的应用程序代码分开。
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）、独立应用程序、测试环境之间重用。

1.4 核心概念

模块	说明
BeanFactory	Spring内部使用，创建bean的工厂
ApplicationContext	外部应用程序调用，也成为spring容器
IoC控制反转Inversion of Control	开发者在无需自己new对象，无需关心对象的创建过程User user = new User(); 手动创建对象User user = context.getBean(user); 容器创建对象
DI依赖注入Dependency Injection	松耦合方式实现对象直接的依赖
AOP面向切面编程	补充java面向对象的不足,在不做修改源代码的情况下，新增新的业务方法

1.5 三大核心组件的关系

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

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

1.6 主要jar组成

模块	说明
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.jms	为简化jms api的使用而做的简单封装
org.springframework.orm	整合第三方orm，如hibernate/mybatis
org.springframework.web.servlet	增强servlet

1.7 Spring容器的启动流程：

详细内容可以阅读这篇文章：https://blog.csdn.net/a745233700/article/details/113761271

（1）初始化Spring容器，注册内置的BeanPostProcessor的BeanDefinition到容器中：

① 实例化BeanFactory【DefaultListableBeanFactory】工厂，用于生成Bean对象
② 实例化BeanDefinitionReader注解配置读取器，用于对特定注解（如@Service、@Repository）的类进行读取转化成 BeanDefinition 对象，（BeanDefinition 是 Spring 中极其重要的一个概念，它存储了 bean 对象的所有特征信息，如是否单例，是否懒加载，factoryBeanName 等）
③ 实例化ClassPathBeanDefinitionScanner路径扫描器，用于对指定的包目录进行扫描查找 bean 对象
（2）将配置类的BeanDefinition注册到容器中：

（3）调用refresh()方法刷新容器：

① prepareRefresh()刷新前的预处理：
② obtainFreshBeanFactory()：获取在容器初始化时创建的BeanFactory：
③ prepareBeanFactory(beanFactory)：BeanFactory的预处理工作，向容器中添加一些组件：
④ postProcessBeanFactory(beanFactory)：子类重写该方法，可以实现在BeanFactory创建并预处理完成以后做进一步的设置
⑤ invokeBeanFactoryPostProcessors(beanFactory)：在BeanFactory标准初始化之后执行BeanFactoryPostProcessor的方法，即BeanFactory的后置处理器：
⑥ registerBeanPostProcessors(beanFactory)：向容器中注册Bean的后置处理器BeanPostProcessor，它的主要作用是干预Spring初始化bean的流程，从而完成代理、自动注入、循环依赖等功能
⑦ initMessageSource()：初始化MessageSource组件，主要用于做国际化功能，消息绑定与消息解析：
⑧ initApplicationEventMulticaster()：初始化事件派发器，在注册监听器时会用到：
⑨ onRefresh()：留给子容器、子类重写这个方法，在容器刷新的时候可以自定义逻辑
⑩ registerListeners()：注册监听器：将容器中所有的ApplicationListener注册到事件派发器中，并派发之前步骤产生的事件：
⑪ finishBeanFactoryInitialization(beanFactory)：初始化所有剩下的单实例bean，核心方法是preInstantiateSingletons()，会调用getBean()方法创建对象；
⑫ finishRefresh()：发布BeanFactory容器刷新完成事件：

2. Spring框架的核心：IoC 与 DI

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

2.1 IOC

IOC（Inversion of Control）—— 控制反转。
就是指将对象的创建，对象的存储(map)，对象的管理(依赖查找,依赖注入)交给了Spring容器。

2.1.1 IOC的XML方式

第一步：创建SpringBoot工程

第二步：创建Hello类

public class Hello {public void show(){System.out.println("hello springIOC");}
}

第三步：创建spring核心配置文件——spring-config.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"><!-- 在框架里开始了ioc ，会把每个类创建对象，并存起来 Map<id的值,对象>.Map<String,Object> 存的是 {"Hello" = new Hello()},框架只会拿到class文件，需要反射创建对象：{"Hello" = Class.forName("cn.tedu.pojo.Hello").newInstance() }这个文件是spring框架的核心配置文件，主要用来配置各种bean.class属性用来指定类的全路径(包名.类名),id属性用来作为bean的唯一标记。IOC：由spring框架创建Hello类，实际上，在spring容器中的bean，相当放着于一个map(key:hello,value:new hello)--><bean class="cn.tedu.spring.Hello" id="Hello"></bean></beans>

第四步：创建测试类 TestIoC

/*** 测试spring框架是否会IOC*/
public class TestIoc {@Testpublic void testIoc(){//1.加载spring的核心配置文件ClassPathXmlApplicationContext spring =new ClassPathXmlApplicationContext("spring-config.xml");//2.从spring容器获取bean对象-----IoCObject obj = spring.getBean("Hello");System.out.println("已获得："+obj);  // 已获得：cn.tedu.spring.Hello@6166e06f//3.再此获取bean对象Object obj2 = spring.getBean("Hello");System.out.println(obj==obj2); //true}
}

2.1.2 IOC的注解方式

第一步：创建Person类：

@Component //spring框架提供的注解，用来完成IOC控制反转，存入map{"person","new person()"}
public class Person {public String name = "易欢欢";public Integer age = 20;public String sex = "男";
}

第二步：创建spring核心配置文件——application.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"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"><!--2.让spring框架，知道哪些类上面使用了@Component注解--><!--配置包扫描器，并指定扫描哪个包里的资源--><context:component-scan base-package="cn.tedu.pojo"></context:component-scan>
</beans>

第三步：创建测试类TestAonotationIoC类

public class TestAnotatioinIoC {@Testpublic void testAnotationIoC(){//1，读取核心配置文件ClassPathXmlApplicationContext spring =new ClassPathXmlApplicationContext("application.xml");//2,获取spring框架new的对象Person p = (Person) spring.getBean("person"); //cn.tedu.pojo.Person@57cf54e1System.out.println(p);//3,调用子类的资源(向下造型的原因)System.out.println( p.name+p.age+p.sex );//易欢欢20男}
}

2.1.3 模拟IoC底层的实现

概念

Spring IoC控制反转，底层实现利用了java自身提供的反射技术来创建对象。

Class.forName(classPath).newInstance();

通过这种方式，Spring控制了对象的生命周期，可以随时自行增强对象，如DI依赖注入、AOP环绕通知在类创建前后增强功能，如Transaction事务加强等。

实现

第一步：创建Bean类，记录类名、类的全路径
抽象Bean的定义，取代java中的Object，Spring框架中万物皆可bean。

package cn.tedu.Ioc;
//指定哪些类需要spring来管理
public class Bean {private String name;//类名private String path;//类的全路径public String getName() {return name;}public void setName(String name) {this.name = name;}public String getPath() {return path;}public void setPath(String path) {this.path = path;}public Bean(String name, String path) {this.name = name;this.path = path;}public Bean(){ }
}

第二步：创建User类和Dept类
第三步：创建对象，存到Map中。

package cn.tedu.Ioc;
import java.util.*;//自己实现IOC
public class MyIOC {//1.告诉spring框架，需要管理的beanprivate List<Bean> beanfactory = new ArrayList<>();private Map<String, Object> map = new HashMap<>();//2.初始化beanfactorypublic MyIOC() throws Exception {Bean b1 = new Bean("user", "cn.tedu.Ioc.User");Bean b2 = new Bean("dept", "cn.tedu.Ioc.Dept");Collections.addAll(beanfactory, b1, b2);//一次性加入集合中//3.进行IOC(核心就是创建map,key = bean的name属性的值，value = bean的path值实例化的对象)for (Bean b : beanfactory) {String k = b.getName();Object v = Class.forName(b.getPath()).newInstance();//对象的实例化map.put(k, v);}}//4.getBean返回创建的对象。public Object getBean(String name){return map.get(name);//根据key值返回对象}
}

第四步：测试

package cn.tedu;
import cn.tedu.Ioc.MyIOC;
import org.junit.Test;public class TestMyIoC {@Testpublic void getBean() throws Exception {MyIOC ioc = new MyIOC();Object obj =  ioc.getBean("user");System.out.println(obj);//cn.tedu.Ioc.User@4926097b}
}

2.2 DI

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

2.2.1 入门案例

第一步：创建Student类和Teacher类

@Component
public class Student {@Autowired //完成对象间的依赖关系spring di,相当于底层帮你维护了两个对象间的关系:new Student().setTeacher(new Teacher())Teacher teacher;String sname = "阿富汗";@Overridepublic String toString() {return "Student{" +"sname='" + sname + '\'' +", teacher=" + teacher +'}';}
}

@Component
public class Teacher {String tname = "易欢欢";@Overridepublic String toString() {return "Teacher{" +"tname='" + tname + '\'' +'}';}
}

第二步：创建配置类application.yml

<?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"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"><!--2.让spring框架，知道哪些类上面使用了@Component注解--><!--配置包扫描器，并指定扫描哪个包里的资源--><context:component-scan base-package="cn.tedu"></context:component-scan>
</beans>

第三步：测试

@Testpublic void testDI(){//1.读取核心配置文件ClassPathXmlApplicationContext spring =new ClassPathXmlApplicationContext("application.xml");Object student = spring.getBean("student");System.out.println(student);//未使用DI注入时：Student{sname='阿富汗', teacher=null}//使用DI注入时：Student{sname='阿富汗', teacher=Teacher{tname='易欢欢'}}}
}

2.3 小结分析

面试：IoC和DI

在平时的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是设计思想，IoC有三个核心：BeanFactory、反射、DI。BeanFactory利用反射实现对象的创建，DI实现对象关系管理。

自动装配

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

3. AOP面向切面编程

3.1 概念

OOP面向对象，允许开发者定义纵向的关系，但并不适用于定义横向的关系，会导致大量代码的重复，而不利于各个模块的重用。

AOP，一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，提高系统的可维护性。可用于权限认证、日志、事务处理。

AOP实现的关键在于代理模式，AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ；动态代理则以Spring AOP为代表。

（1）AspectJ是静态代理，也称为编译时增强，AOP框架会在编译阶段生成AOP代理类，并将AspectJ(切面)织入到Java字节码中，运行的时候就是增强之后的AOP对象。
（2）Spring AOP使用的动态代理，所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。

Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理：

    ① JDK动态代理只提供接口的代理，不支持类的代理，要求被代理类实现接口。JDK动态代理的核心是InvocationHandler接口和Proxy类，在获取代理对象时，使用Proxy类来动态创建目标类的代理类（即最终真正的代理类，这个类继承自Proxy并实现了我们定义的接口），当代理对象调用真实对象的方法时， InvocationHandler 通过invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起；

InvocationHandler 的 invoke(Object proxy,Method method,Object[] args)：proxy是最终生成的代理对象; method 是被代理目标实例的某个具体方法; args 是被代理目标实例某个方法的具体入参, 在方法反射调用时使用。

    ② 如果被代理类没有实现接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成指定类的一个子类对象，并覆盖其中特定方法并添加增强代码，从而实现AOP。CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的。

（3）静态代理与动态代理区别在于生成AOP代理对象的时机不同，相对来说AspectJ的静态代理方式具有更好的性能，但是AspectJ需要特定的编译器进行处理，而Spring AOP则无需特定的编译器处理。

IoC让相互协作的组件保持松散的耦合，而AOP编程允许你把遍布于应用各层的功能分离出来形成可重用的功能组件。

Spring核心特征中除了IoC控制反转、DI依赖注入，还有一个核心就是强大的面向切面编程AOP（Aspect Oriented Programming）
的实现，在方法执行前后添加功能。使用场景：事务管理、缓存管理、权限管理、日志管理、性能测试
Spring AOP有三要素：
（1）Aspect定义切面；
（2）通过通知（Advice）来指定具体做什么事情。如方法执行前做什么，方法执行后做什么，抛出异常做什么，从而实现对象行为（方法）的增强；
（3）通过切点（PointCut）配置切点表达式（expression）来指定在哪些类的哪些方法上织入（ware）横切逻辑；被切的地方叫连接点（JoinPoint）；

3.2 通知的执行顺序

Spring框架实现了AOP面向切面，其引入了第三方AspectJ框架来具体实现。AspectJ提供了五种切入方式，术语称为通知advice。
具体五种为：
（1）前置通知before
（2）后置通知after
（3）环绕通知around
（4）返回后通知afterReturning
（5）异常通知afterThrowing。

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

3.3 组成

切面Aspect：其实就是一个类，由通知和切点组成。
切点PointCut：找到指定包里的类，类里的方法，增加功能。
通知Advice：就是类里的一个方法，分为前置通知(方法执行前要加的)，后置通知(方法执行后要加的)，环绕通知(方法执行前后都要加的)，返回后通知，异常通知。

3.4 入门案例

基于Springmvc项目，统计所有service层的方法的执行时间。
第一步：添加aop依赖

   <dependencies><!--添加aop依赖包--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency></dependencies>

第二步：在service包下新建Aspect类

package cn.tedu.service;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;//Spring的AOP功能，其实就是为了增强方法的功能，由切点和通知组成
@Component
@org.aspectj.lang.annotation.Aspect //1.标识这是一个切面
public class Aspect {//2.切点：指定包、类、方法//@Pointcut("execution(返回值 包名.类名.方法名(参数列表))")//第一个*代表返回一个值；..代表多个值；第二个*代表类，第三个*代表方法@Pointcut("execution(* cn.tedu.service..*.*(..))")public void point(){}//3.通知：本质是一个方法，增强功能@Around("point()") //标识这是环绕通知public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {long startTime = System.currentTimeMillis();Object obj =  joinPoint.proceed();//执行原来的业务方法long endTime = System.currentTimeMillis();System.out.println("aop计算的耗时为："+(endTime - startTime));return obj;}
}

第三步：测试
页面访问业务方法。

03--SSM的知识与应用之Spring相关推荐

SSM框架——详细整合教程（Spring+SpringMVC+MyBatis）
登录 | 注册收藏成功确定收藏失败,请重新收藏确定查看所有私信查看所有通知暂没有新通知想要绕过微信小程序开发中的坑吗?不妨来听这个,今晚8点,1小时帮你搞定! 14小时以前 CSDN日报 ...
❤️《集成SSM框架—图书系统》Mybatis+Spring+SpirngMVC
<集成SSM框架-图书系统>Mybatis+Spring+SpirngMVC 希望各位博友给个三连+关注,谢谢!!! 全部源码地址:链接:https://pan.baidu.com/s/1 ...
计算机毕业设计ssm古诗词知识学习系统q5697系统+程序+源码+lw+远程部署
计算机毕业设计ssm古诗词知识学习系统q5697系统+程序+源码+lw+远程部署计算机毕业设计ssm古诗词知识学习系统q5697系统+程序+源码+lw+远程部署本源码技术栈: 项目架构:B/S架构 ...
基于SSM的家校通系统(Spring+SpringMVC+Mybatis+mysql)
这是一基于SSM框架开发的家校通. 源代码: 基于SSM的家校通系统(Spring+SpringMVC+Mybatis+mysql).zip-Java文档类资源-CSDN下载这是一基于SSM(spri ...
[转]SSM框架——详细整合教程（Spring+SpringMVC+MyBatis）
使用SSM(spring.SpringMVC和Mybatis)已经有三个多月了,项目在技术上已经没有什么难点了,基于现有的技术就可以实现想要的功能,当然肯定有很多可以改进的地方.之前没有记录SSM整合 ...
SSM之一(使用idea创建一个Spring+SpringMVC的项目)
文章目录 1. 使用idea创建一个基本的maven项目(Web版本) 2. 完善目录结构 3. 相关依赖 4. 配置spring与springmvc 1. 使用idea创建一个基本的maven项目( ...
SSM框架整合一（springmvc+spring+mybatis+maven+tomcat）
一,环境说明 jdk1.7.0_07(cmd命令行输入java -version查看),点击下载 eclipse Kepler Service Release 2 apache-maven-3.3.9 ...
maven ssm框架 mysql_SSM框架（IDEA+Spring+SpringMVC+Maven+Mybatis+MySQL）
[实例简介] SSM框架(IDEA+Spring+SpringMVC+Maven+Mybatis+MySQL),搭建SSM框架,利用mybatis-plus插件自动生成数据库相关代码. [实例截图] ...
(附源码)计算机毕业设计ssm党史知识竞赛系统
项目运行环境配置: Jdk1.8 + Tomcat7.0 + Mysql + HBuilderX(Webstorm也行)+ Eclispe(IntelliJ IDEA,Eclispe,MyEclis ...
SSM框架详细整合教程（Spring+SpringMVC+MyBatis）
动机使用maven已经有一段时间了,但项目是别人搭建好的,因此一直想着自己要学习搭建一下.网上找了些资料后,结合自己实验,花了点时间就搞好,老样子,写在博客上,免得日后忘记. 本文链接:http:/ ...

03--SSM的知识与应用之Spring