AOP(Aspect Oriented Programming):即我们常说的面向切面编程。

什么是AOP?AOP是在我们原来写的代码的基础上,进行一定的包装,比如在方法执行前、方法返回后、方法抛出异常后等地方进行一定的拦截处理或者增强处理。我们需要实现一个代理来创建实例,实际运行的实例其实是生成的代理类的实例。

Spring的AOP和AspectJ?

springaop的底层实现有两种,一种是jdk的动态代理,另一种是cglib,springaop没有用到aspectj,只是借鉴了它并添加了aspectj风格的注解,使用aspectj必须用到它自己特殊的编译器和运行环境的插件。

spring aop只是用到了aspectj的配置而已,没有用它的编译器、也没有用它的类加载器。spring aop对于没有实现接口的类,会用cglib来动态生成子类,否则使用jdk自带的动态代理。

Spring AOP:首先要说明的是,这里的Spring AOP 是纯的 Spring 代码,和 AspectJ 没什么关系,但是 Spring 延用了 AspectJ 中的概念,包括使用了 AspectJ 提供的 jar 包中的注解,但是不依赖于其实现功能。@Aspect、@Pointcut、@Before、@After 等注解都是来自于 AspectJ,但是功能的实现是纯 Spring AOP 自己实现的。

基于@AspectJ注解的AOP配置

本文只介绍关于注解的方式,配置文件的方式来实现AOP不作分析

1. 首先引入AOP所依赖的jar包

<!-- AOP -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.0.8.RELEASE</version>
</dependency>

其中包含2个必须的包

<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.0.8.RELEASE</version>
<scope>compile</scope>
<optional>true</optional>
</dependency>

如果使用了SpringBoot的话,直接添加如下依赖:

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

2. 在 @AspectJ 的配置方式中,之所以要引入 aspectjweaver 并不是因为需要使用 AspectJ 的处理功能,而是因为 Spring 使用了 AspectJ 提供的一些注解,实际上还是纯的 Spring AOP 代码。明确一点,@AspectJ 采用注解的方式来配置使用 Spring AOP。

开启 @AspectJ 的注解配置方式,有两种方式:

一、使用xml方式:

<aop:aspectj-autoproxy/>

二、使用@EnableAspectJAutoProxy

/**
* @author 70KG
* @Title: Config
* @Description: 配置类
* @date 2018/7/29下午2:01
* @From www.nmyswls.com
*/
@Configuration
// 手动开启Aspect注解
@EnableAspectJAutoProxy
public class Config { }

3. 采用@Configuration配置文件的方式来模拟spring上下文环境

/**
* @author 70KG
* @Title: MainTest
* @Description:
* @date 2018/7/29下午2:01
* @From www.nmyswls.com
*/
public class MainTest { public static void main(String[] args) {
// 加载配置文件
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
BusinessCalculate businessCalculate = ac.getBean(BusinessCalculate.class);
int result1 = businessCalculate.calculate(10, 5);
System.out.println("===================================================");
RandomCalculate randomCalculate = ac.getBean(RandomCalculate.class);
int result2 = randomCalculate.calculate(10, 5);
} }

4.一旦开启了上面的配置,那么所有使用 @Aspect 注解的 bean 都会被 Spring 当做用来实现 AOP 的配置类,称之为一个 Aspect。

/**
* description
*
* @author 70KG
* @date 2018/7/30
*/
@Aspect
public class BeforeAdvice { }

Demo介绍:

1. 编写两个业务类(目的是为了测试不同的切入点)

/**
* @author 70KG
* @Title: BusinessCalculate
* @Description: 业务计算类
* @date 2018/7/29下午2:01
* @From www.nmyswls.com
*/
public class BusinessCalculate { public int calculate(int i, int j) {
int result = i / j;
System.out.println("BusinessCalculate-业务方法执行。。。。。。");
return result;
} }
/**
* description
*
* @author 70KG
* @date 2018/7/30
*/
public class RandomCalculate { public int calculate(int i, int j) {
int result = i / j;
System.out.println("RandomCalculate-业务方法执行。。。。。。");
return result;
} }

2. 编写切入点SystemArchitecture类(Spring建议是这个名字) (此类上面不需要加@Aspect)

/**
* description 用来定义切入点的类
*
* @author 70KG
* @date 2018/7/30
*/
public class SystemArchitecture { @Pointcut("bean(*domCalculate)")
public void definitionPointCut(){} // execution(* *(..)) 所有方法
// 抽取公共表达式
// @Pointcut("execution(public int com.nmys.story.springCore.aopdemo.BusinessCalculate.*(..))")
@Pointcut("execution(* com.nmys.story.springCore.aopdemo.BusinessCalculate.*(..))")
// @Pointcut("bean(*Calculate)")
public void pointCut() {} }

介绍一下切入点的表达式:

  • within:指定所在类或所在包下面的方法(Spring AOP 独有)如 @Pointcut("within(com.nmys.story.service..*)")。
  • @annotation:方法上具有特定的注解,如 @Subscribe 用于订阅特定的事件。如 @Pointcut("execution( .*(..)) && @annotation(com.nmys.story.Subscribe)")。
  • bean(idOrNameOfBean):匹配 bean 的名字(Spring AOP 独有)如 @Pointcut("bean(*Service)")。
  • execution 来正则匹配方法签名(根据业务需求来查阅一下表达式的具体写法)。

上面匹配中,通常 "." 代表一个包名,".." 代表包及其子包,方法参数任意匹配使用两个点 ".."。

3. 定义切面(切面最好不要都揉在一个类中,显得杂乱无章,建议分开写,如下)

/**
* description
*
* @author 70KG
* @date 2018/7/30
*/
@Aspect
public class BeforeAdvice { // 前置通知
@Before("com.nmys.story.springCore.aopdemo.SystemArchitecture.pointCut()")
public void logBefore(JoinPoint joinPoint) {
// 获取传入的参数
Object[] args = joinPoint.getArgs();
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
System.out.println("调用方法之前执行logBefore。。。。。。");
} // 前置通知
@Before("com.nmys.story.springCore.aopdemo.SystemArchitecture.definitionPointCut()")
public void randomBefore() {
System.out.println("调用方法之前执行randomBefore。。。。。。");
} }

其中如果需要拿到方法的入参,则用JoinPoint类来获得

/**
* description
*
* @author 70KG
* @date 2018/7/30
*/
@Aspect
public class AfterAdvice { // 后置通知
@After("com.nmys.story.springCore.aopdemo.SystemArchitecture.pointCut()")
public void logAfter() {
System.out.println("调用方法之后执行logAfter。。。。。。");
} // 后置通知
@After("com.nmys.story.springCore.aopdemo.SystemArchitecture.definitionPointCut()")
public void randomAfter() {
System.out.println("调用方法之后执行randomAfter。。。。。。");
} }

上面加上了@Aspect注解表明spring会将此bean当作切面来管理

介绍一下其他通知方法的写法:

/**
* @author 70KG
* @Title: LogAspect
* @Description: 定义切面
* @date 2018/7/29下午2:00
* @From www.nmyswls.com
*/
// 声明是一个切面类
@Aspect
public class LogAspect { // // 前置通知
// @Before("com.nmys.story.springCore.aopdemo.SystemArchitecture.pointCut()")
// public void logBefore() {
// System.out.println("调用方法之前执行logBefore。。。。。。");
// }
//
// // 前置通知
// @Before("com.nmys.story.springCore.aopdemo.SystemArchitecture.definitionPointCut()")
// public void randomBefore() {
// System.out.println("调用方法之前执行randomBefore。。。。。。");
// } // // 后置通知
// @After("pointCut()")
// public void logAfter() {
// System.out.println("调用方法之后执行logAfter。。。。。。");
// }
//
// // 正常返回通知(抛出异常则不会执行)
// @AfterReturning("pointCut()")
// public void logReturn() {
// System.out.println("方法正常返回结果后执行logReturn。。。。。。");
// }
//
// // 异常通知
// @AfterThrowing("pointCut()")
// public void logException() {
// System.out.println("logException。。。。。。");
// }
//
// @Around("pointCut()")
// public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
// // 比前置通知提前执行
// System.out.println("环绕通知 - around 执行目标方法之前。。。。。。");
// // 利用反射机制来调用目标方法
// Object proceed = proceedingJoinPoint.proceed();
// System.out.println("环绕通知 - around 执行目标方法之后。。。。。。");
// return proceed;
// }
}

@Around():环绕通知在实际中不常用,proceed()方法实际是用了反射来调用目标方法,上面的具体注释很清楚。

4. 编写config类

/**
* @author 70KG
* @Title: Config
* @Description: 配置类
* @date 2018/7/29下午2:01
* @From www.nmyswls.com
*/
@Configuration
// 手动开启Aspect注解
@EnableAspectJAutoProxy
public class Config { // 将@Aspect修饰的类和业务类都交给spring来管理
@Bean
public BeforeAdvice beforeAdvice() {
return new BeforeAdvice();
} @Bean
public AfterAdvice afterAdvice() {
return new AfterAdvice();
} @Bean
public BusinessCalculate businessCalculate() {
return new BusinessCalculate();
} @Bean
public RandomCalculate randomCalculate() {
return new RandomCalculate();
} }

需要将业务类和切面类都交给spring来管理,同时需要开启Aspect(@EnableAspectJAutoProxy)

5. 编写测试类

/**
* @author 70KG
* @Title: MainTest
* @Description:
* @date 2018/7/29下午2:01
* @From www.nmyswls.com
*/
public class MainTest { public static void main(String[] args) {
// 加载配置文件
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
     // 从容器中取出bean实例
BusinessCalculate businessCalculate = ac.getBean(BusinessCalculate.class);
int result1 = businessCalculate.calculate(10, 5);
System.out.println("===================================================");
RandomCalculate randomCalculate = ac.getBean(RandomCalculate.class);
int result2 = randomCalculate.calculate(10, 5);
} }

6. 运行结果:

10
5
调用方法之前执行logBefore。。。。。。
BusinessCalculate-业务方法执行。。。。。。
调用方法之后执行logAfter。。。。。。
===================================================
调用方法之前执行randomBefore。。。。。。
RandomCalculate-业务方法执行。。。。。。
调用方法之后执行randomAfter。。。。。。

以上结果表明对目标方法进行了增强。

最后再说一下,以上使用的是Spring的AOP,和AspectJ基本没什么关系。

用惯了markdown不知道博客园如何排版了,可以访问下面的网址看排好版的。

Spring源码窥探之:Spring AOP初步的更多相关文章

  1. Spring源码窥探之:AOP注解

    AOP也就是我们日常说的@面向切面编程,看概念比较晦涩难懂,难懂的是设计理念,以及这样设计的好处是什么.在Spring的AOP中,常用的几个注解如下:@Aspect,@Before,@After,@A ...

  2. Spring源码-IOC部分-Spring是如何解决Bean循环依赖的【6】

    实验环境:spring-framework-5.0.2.jdk8.gradle4.3.1 Spring源码-IOC部分-容器简介[1] Spring源码-IOC部分-容器初始化过程[2] Spring ...

  3. spring源码学习之路---AOP初探(六)

    作者:zuoxiaolong8810(左潇龙),转载请注明出处,特别说明:本博文来自博主原博客,为保证新博客中博文的完整性,特复制到此留存,如需转载请注明新博客地址即可. 最近工作很忙,但当初打算学习 ...

  4. 框架源码系列六:Spring源码学习之Spring IOC源码学习

    Spring 源码学习过程: 一.搞明白IOC能做什么,是怎么做的  1. 搞明白IOC能做什么? IOC是用为用户创建.管理实例对象的.用户需要实例对象时只需要向IOC容器获取就行了,不用自己去创建 ...

  5. spring源码深度解析—Spring的整体架构和环境搭建

    概述 Spring是一个开放源代码的设计层面框架,他解决的是业务逻辑层和其他各层的松耦合问题,因此它将面向接口的编程思想贯穿整个系统应用.Spring是于2003 年兴起的一个轻量级的Java 开发框 ...

  6. spring源码学习(三)--spring循环引用源码学习

    在spring中,是支持单实例bean的循环引用(循环依赖)的,循环依赖,简单而言,就是A类中注入了B类,B类中注入了A类,首先贴出我的代码示例 @Component public class Add ...

  7. Spring 源码学习(4) —— 动态AOP使用示例

    在实际工作中, 此bean可能是满足业务需要的核心逻辑, 例如test()方法中可能会封装着某个核心业务, 如果在test()方法前后加入日志来跟踪调试, 直接修改源码并不符合面向对象的设计模式, 而 ...

  8. Spring源码剖析7:AOP实现原理详解

    前言 前面写了六篇文章详细地分析了Spring Bean加载流程,这部分完了之后就要进入一个比较困难的部分了,就是AOP的实现原理分析.为了探究AOP实现原理,首先定义几个类,一个Dao接口: pub ...

  9. Spring源码分析:Spring IOC容器初始化

    概述: Spring 对于Java 开发来说,以及算得上非常基础并且核心的框架了,在有一定开发经验后,阅读源码能更好的提高我们的编码能力并且让我们对其更加理解.俗话说知己知彼,百战不殆.当你对Spri ...

  10. (转) Spring源码阅读 之 Spring整体架构

    标签(空格分隔): Spring 声明:本文系转载,原地地址:spring framework 4 源码阅读 Spring骨架 Spring的骨架,也是Spring的核心包.主要包含三个内容 cont ...

随机推荐

  1. javascript bom操作

    BOM BOM介绍 全称 Browser Object Mode 浏览器对象模式 操作浏览器的API接口.比如浏览器自动滚动 Windows对象的顶层部分是BOM的顶层(核心)对象,所有的对象都是通过 ...

  2. htm5手机端实现拖动图片

    htm5手机端实现拖动图片 <pre> <!doctype html><html><head> <title>Mobile Cookbook ...

  3. 抓包curl解析

    目录 背景 code 背景 抓包工具charles抓取的请求curl,是这样: curl -H ':method: POST' -H ':path: /client.action?functionId ...

  4. STM32之SPI时钟相位选择

    SPI的时钟模式分为四种,由SPI_CR1寄存器的两位CPOL,CPHA组合选择. CPOL 如果为1,则时钟的空闲电平为高电平:CPOL 如果为0,则时钟的空闲电平为低电平.空闲电平影响不大. CP ...

  5. 前端小tite(随笔)

    前端 自定义居中#照片 万能s居中 .second-listleft{/*固定位置*/ position: relative; float: left; width: 25%; height: 100 ...

  6. 利用Python进行数据分析 第7章 数据清洗和准备(1)

    学习时间:2019/10/25 周五晚上22点半开始. 学习目标:Page188-Page217,共30页,目标6天学完,每天5页,预期1029学完. 实际反馈:集中学习1.5小时,学习6页:集中学习 ...

  7. vue的生命周期 created mounted等

    生命周期: beforeCreate 在实例初始化之后,数据观测和event/watcher时间配置之前被调用 created 页面加载之前执行,在实例创建完成后被立即调用.执行顺序:父组件-子组件 ...

  8. typescript 入门教程四

    ts中的function和接口 interface PrintCallback{ // 匿名函數,返回类型为空 (success:boolean):void } interface Person{ / ...

  9. Dev GridControl 子集合标题

    显示效果: 设置: this.gridView3.OptionsView.ShowViewCaption = true; this.gridView3.ViewCaption = "资产明细 ...

  10. ABP 基于DDD的.NET开发框架 学习(四)时间控件采用datetimepicker注意事项

    $('#datetimepicker1').datetimepicker({ format: 'yyyy/mm/dd hh:ii:ss',//这是只能用小写的大写的与ABP中的字母识别起冲突 loca ...