1.背景

2.AOP的概念

AOP:用鸟语解释就是 面向切面编程，详细的解释大家可以看百度百科，
百度百科：https://baike.baidu.com/item/AOP/1332219?fr=aladdin
不过估计看了后还是一头雾水…
通俗的理解是：假设有方法M1、M2、M3….，现在需要在这些方法中增加新的业务逻辑（如：打印方法名称、方法参数、执行结果），但是不把这些新的业务逻辑写到这些方法（M1、M2、M3….）中，这就是AOP的思想；
简单一句话说就是：在方法中增加新的业务逻辑，但是不修改方法中的代码。

3.AOP的底层原理

实现方式一：有接口的情况下，使用JDK动态代理
实现方式二：没有接口情况，使用 CGLIB 动态代理

3.1.JDK动态代理实现AOP思想

需求：假设有方法M1、M2、M3….，现在需要在这些方法中增加新的业务逻辑（如：打印方法名称、方法参数、执行结果），但是不把这些新的业务逻辑写到这些方法（M1、M2、M3….）中，这就是AOP的思想；

步骤一：准备一个dao接口、dao实现、测试

dao接口

  1. package com.ldp.dao;
  3. /**
  4.  * @Copyright (C) XXXXXXXXXXX科技股份技有限公司
  5.  * @Author: lidongping
  6.  * @Date: 2021-01-12 10:44
  7.  * @Description:
  8.  */
  9. public interface IProductDao {
  10.     /**
  11.      * 保存产品
  12.      *
  13.      * @param name
  14.      * @param price
  15.      * @return
  16.      */
  17.     int saveProduct(String name, Integer price);
  19.     /**
  20.      * 根据id删除产品
  21.      *
  22.      * @param id
  23.      * @return
  24.      */
  25.     int deleteProduct(Integer id);
  27.     /**
  28.      * 根据id修改产品
  29.      *
  30.      * @param id
  31.      * @param name
  32.      * @param price
  33.      * @return
  34.      */
  35.     int updateProduct(Integer id, String name, Integer price);
  37.     /**
  38.      * 根据id查询产品
  39.      *
  40.      * @return
  41.      */
  42.     String queryProduct(Integer id);
  43. }

dao实现

  1. package com.ldp.dao.impl;
  3. import com.ldp.dao.IProductDao;
  5. /**
  6.  * @Copyright (C) XXXXXXXXXXX科技股份技有限公司
  7.  * @Author: lidongping
  8.  * @Date: 2021-01-12 10:51
  9.  * @Description:
  10.  */
  11. public class ProductDaoImpl implements IProductDao {
  12.     @Override
  13.     public int saveProduct(String name, Integer price) {
  14.         System.out.println("模拟 saveProduct---------------");
  15.         return 1;
  16.     }
  18.     @Override
  19.     public int deleteProduct(Integer id) {
  20.         System.out.println("模拟 deleteProduct---------------");
  21.         return 1;
  22.     }
  24.     @Override
  25.     public int updateProduct(Integer id, String name, Integer price) {
  26.         System.out.println("模拟 updateProduct---------------");
  27.         return 1;
  28.     }
  30.     @Override
  31.     public String queryProduct(Integer id) {
  32.         System.out.println("模拟 queryProduct---------------");
  33.         return "模拟返回产品数据";
  34.     }
  35. }

dao测试

  1. /**
  2.      * 没有代理的测试
  3.      */
  4.     @Test
  5.     public void test01() {
  6.         // 创建到dao实例对象
  7.         IProductDao productDao = new ProductDaoImpl();
  9.         // 测试增加
  10.         int saveProduct = productDao.saveProduct("苹果", 3);
  11.         System.out.println(saveProduct);
  13.         // 测试删除
  14.         int deleteProduct = productDao.deleteProduct(12);
  15.         System.out.println(deleteProduct);
  17.         // 测试修改
  18.         int updateProduct = productDao.updateProduct(11, "修改苹果", 4);
  19.         System.out.println(updateProduct);
  21.         // 测试查询
  22.         String queryProduct = productDao.queryProduct(11);
  23.         System.out.println(queryProduct);
  24.     }

步骤二：编写一个InvocationHandler的实例对象，编写需要增强的具体功能

  1. package com.ldp.proxy;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.util.Arrays;
  7. /**
  8.  * @Copyright (C) XXXXXXXXXXX科技股份技有限公司
  9.  * @Author: lidongping
  10.  * @Date: 2021-01-12 11:01
  11.  * @Description:
  12.  */
  13. public class MyDaoProxy implements InvocationHandler {
  14.     private Object object;
  16.     /**
  17.      * 定义一个有参数的构造方法
  18.      */
  19.     public MyDaoProxy(Object object) {
  20.         this.object = object;
  21.     }
  23.     /**
  24.      * 这里使用了反射的机制
  25.      *
  26.      * @param proxy
  27.      * @param method
  28.      * @param args
  29.      * @return
  30.      * @throws Throwable
  31.      */
  32.     @Override
  33.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  34.         // 方法执行前
  35.         System.out.println("方法执行前执行.....请求方法名：" + method.getName() + ",请求参数：" + Arrays.toString(args));
  37.         // 执行固有的方法（被增强的方法）
  38.         Object result = method.invoke(object, args);
  40.         // 方法执行后
  41.         System.out.println("方法执行后.....方法执行结果：" + result);
  43.         return result;
  44.     }
  45. }

步骤三：使用代理对象生成dao实现

  1. // 使用动态代理 创建到dao实例对象 TestProxy.class.getClassLoader()中的TestProxy为当前测试类对象
  2.         // IProductDao productDao = new ProductDaoImpl();
  3.         Class[] interfaces = {IProductDao.class};
  4.         IProductDao productDao = (IProductDao) Proxy.newProxyInstance(TestProxy.class.getClassLoader(), interfaces, new MyDaoProxy(new ProductDaoImpl()));

步骤四：测试代理对象生成的dao

  1. /**
  2.      * 代理对象的测试
  3.      * newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h)
  4.      * 返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。
  5.      */
  6.     @Test
  7.     public void test02() {
  8.         // 使用动态代理 创建到dao实例对象 TestProxy.class.getClassLoader()中的TestProxy为当前测试类对象
  9.         // IProductDao productDao = new ProductDaoImpl();
  10.         Class[] interfaces = {IProductDao.class};
  11.         IProductDao productDao = (IProductDao) Proxy.newProxyInstance(TestProxy.class.getClassLoader(), interfaces, new MyDaoProxy(new ProductDaoImpl()));
  12.         // 测增加
  13.         int saveProduct = productDao.saveProduct("苹果", 3);
  14.         System.out.println(saveProduct);
  16.         // 测试删除
  17.         int deleteProduct = productDao.deleteProduct(12);
  18.         System.out.println(deleteProduct);
  20.         // 测试修改
  21.         int updateProduct = productDao.updateProduct(11, "修改苹果", 4);
  22.         System.out.println(updateProduct);
  24.         // 测试查询
  25.         String queryProduct = productDao.queryProduct(11);
  26.         System.out.println(queryProduct);
  27.     }

参考资料
jdk8Api:https://www.matools.com/api/java8
Spring之AOP详解 - 图1

3.2.cglib动态代理实现aop思想

步骤一：引入jar包

Spring之AOP详解 - 图2

步骤二：编写一个普通的需要被增强的方法

  1. package com.ldp.controller;
  3. /**
  4.  * @Copyright (C) XXXXXXXXXXX科技股份技有限公司
  5.  * @Author: lidongping
  6.  * @Date: 2021-01-12 12:07
  7.  * @Description:
  8.  */
  9. public class ProductController {
  10.     /**
  11.      * 产品查询
  12.      *
  13.      * @param name
  14.      * @param price
  15.      * @return
  16.      */
  17.     public String queryProduct(String name, Integer price) {
  18.         System.out.println("模拟查询中............");
  19.         return "香蕉";
  20.     }
  21. }

步骤三：编写一个cglib动态代理类

  1. package com.ldp.proxy;
  3. import net.sf.cglib.proxy.Enhancer;
  4. import net.sf.cglib.proxy.MethodInterceptor;
  5. import net.sf.cglib.proxy.MethodProxy;
  7. import java.lang.reflect.Method;
  8. import java.util.Arrays;
  10. /**
  11.  * @Copyright (C) XXXXXXXXXXX科技股份技有限公司
  12.  * @Author: lidongping
  13.  * @Date: 2021-01-12 11:50
  14.  * @Description:
  15.  */
  16. public class MyDaoCglibProxy implements MethodInterceptor {
  17.     private Object target;
  19.     public Object getInstance(Object target) {
  20.         this.target = target;
  21.         Enhancer enhancer = new Enhancer();
  22.         enhancer.setSuperclass(this.target.getClass());
  23.         // 设置回调方法
  24.         enhancer.setCallback(this);
  25.         // 创建代理对象
  26.         return enhancer.create();
  27.     }
  29.     /**
  30.      * 实现MethodInterceptor接口中重写的方法
  31.      * <p>
  32.      * 回调方法
  33.      */
  34.     @Override
  35.     public Object intercept(Object object, Method method, Object[] args, MethodProxy proxy) throws Throwable {
  36.         // 方法执行前
  37.         System.out.println("方法执行前执行.....请求方法名：" + method.getName() + ",请求参数：" + Arrays.toString(args));
  39.         // 执行固有的方法（被增强的方法）
  40.         Object result = proxy.invokeSuper(object, args);
  42.         // 方法执行后
  43.         System.out.println("方法执行后.....方法执行结果：" + result);
  44.         return result;
  45.     }
  46. }

步骤四：测试

  1. /**
  2.      * CGLIB 代理对象的测试
  3.      */
  4.     @Test
  5.     public void test03() {
  6.         // 创建动态代理
  7.         MyDaoCglibProxy cglibProxy = new MyDaoCglibProxy();
  8.         // 获取代理的实例对象
  9.         ProductController productController = (ProductController) cglibProxy.getInstance(new ProductController());
  10.         System.out.println(productController.queryProduct("香蕉", 100));
  11.     }

测试结果如下:

  1. 方法执行前执行.....请求方法名：queryProduct,请求参数：[香蕉, 100]
  2. 模拟查询中............
  3. 方法执行后.....方法执行结果：香蕉
  4. 香蕉

4.AOP的几个专业术语

AOP的基本概念
1、连接点：可以被增强的方法
2、切入点：实际被增强的方法
3、通知（增强）：
3.1.实际增强的逻辑部分叫做通知
3.2.通知类型包括

  1. 前置通知（执行方法前执行，通常用作参数日志输出、权限校验等）
  2. 后置通知（逻辑代码执行完，准备执行return的代码时通知，通常用作执行结果日志输出、结果加密等）
  3. 环绕通知（是前置通知和后置通知的综合，方法执行前和方法执行后都要执行，通常用作方法性能统计、接口耗时、统一加密、解密等）
  4. 异常通知（相当于try{}catch ()中catch执行的部分,程序抛出异常时执行，通常用作告警处理、事务回滚等）
  5. 最终通知（相当于try{}catch (Exception e){}finally { }中的finally执行的部分，通常用在关闭资源、清理缓存等业务逻辑中）

4、切面：把通知(增强)应用到切入点的过程

5.AOP实现技术

1、Spring 框架一般都是基于 AspectJ 实现 AOP 操作
（1）AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使 用，进行 AOP 操作
2、基于 AspectJ 实现 AOP 操作
（1）基于 xml 配置文件实现
（2）基于注解方式实现（使用）
3、在项目工程里面引入 AOP 相关依赖
Spring之AOP详解 - 图3
4、切入点表达式
（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] 方法名称 )
说明： 号表示通配符，.. 符号表示一个或多个参数
举例 1：对 com.ldp.controller.ProductController 类里面的 queryProduct 进行增强 execution( com.ldp.controller.ProductController.queryProduct (..))
举例 2：对 com.ldp.controller.ProductController 类里面的所有的方法进行增强 execution( com.ldp.controller.ProductController . (..))
举例 3：对 com.ldp.controller 包里面所有以controller结尾的类里面所有方法进行增强 execution( com.ldp.controller.Controller .* (..))

6.AOP案例

6.1.AOP 操作（AspectJ 注解）

这里使用spring中的aop实现对controller里日志输出来加深对aop的理解
实现步骤:
准备工作：

步骤一：创建一个controller类并定义方法

  1. public class UserController {
  2.     /**
  3.      * 查询用户
  4.      */
  5.     public Object queryUser(String name, Integer age) {
  6.         System.out.println("数据查询中模拟...........");
  7.         return "张无忌,18岁";
  8.     }
  9. }

步骤二：创建一个增强类，编写增强逻辑，也就是说建立一个切面

  1. public class LogAop {
  2.     public void method01() {
  3.         System.out.println("method01-前置通知-增强逻辑-------------");
  4.     }
  6.     public void method02() {
  7.         System.out.println("method02-后置通知-增强逻辑-------------");
  8.     }
  10.     public void method03() {
  11.         System.out.println("method03-环绕通知-增强逻辑-------------");
  12.     }
  14.     public void method04() {
  15.         System.out.println("method04-异常通知-增强逻辑-------------");
  16.     }
  18.     public void method05() {
  19.         System.out.println("method05-最终通知-增强逻辑-------------");
  20.     }
  21. }

AOP配置
步骤一：在 spring 配置文件中，开启注解扫描

  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 http://www.springframework.org/schema/beans/spring-beans.xsd 
  6.        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  7.     <!-- 开启注解扫描 -->
  8.     <context:component-scan base-package="com.ldp.aop"></context:component-scan>
  9. </beans>

步骤二：增强类上加上注解，以及在方法加不同类型的通知
类上加注解
Spring之AOP详解 - 图4
方法上加不同类型的通知

  1. package com.ldp.aop;
  3. import org.aspectj.lang.annotation.*;
  4. import org.springframework.stereotype.Component;
  6. /**
  7.  * @Copyright (C) XXXXXXXXXXX科技股份技有限公司
  8.  * @Author: lidongping
  9.  * @Date: 2021-01-14 9:52
  10.  * @Description: <p>
  11.  * 前置通知（执行方法前执行，通常用作参数日志输出、权限校验等）
  12.  * 后置通知（逻辑代码执行完，准备执行return的代码时通知，通常用作执行结果日志输出、结果加密等）
  13.  * 环绕通知（是前置通知和后置通知的综合，方法执行前和方法执行后都要执行，通常用作方法性能统计、接口耗时、统一加密、解密等）
  14.  * 异常通知（相当于try{}catch ()中catch执行的部分,程序抛出异常时执行，通常用作告警处理、事务回滚等）
  15.  * 最终通知（相当于try{}catch (Exception e){}finally { }中的finally执行的部分，通常用在关闭资源、清理缓存等业务逻辑中）
  16.  * </p>
  17.  * 语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
  18.  */
  19. @Component
  20. @Aspect
  21. public class LogAop {
  22.     /**
  23.      * 前置通知
  24.      */
  25.     @Before(value = "execution(* com.ldp.controller.*Controller.*(..))")
  26.     public void method01() {
  27.         System.out.println("method01-前置通知-增强逻辑-------------");
  28.     }
  30.     /**
  31.      * 后置通知
  32.      */
  33.     @AfterReturning(value = "execution(* com.ldp.controller.*Controller.*(..))")
  34.     public void method02() {
  35.         System.out.println("method02-后置通知-增强逻辑-------------");
  36.     }
  38.     /**
  39.      * 环绕通知
  40.      */
  41.     @Around(value = "execution(* com.ldp.controller.*Controller.*(..))")
  42.     public void method03() {
  43.         System.out.println("method03-环绕通知-增强逻辑-------------");
  44.     }
  46.     /**
  47.      * 异常通知
  48.      */
  49.     @AfterThrowing(value = "execution(* com.ldp.controller.*Controller.*(..))")
  50.     public void method04() {
  51.         System.out.println("method04-异常通知-增强逻辑-------------");
  52.     }
  54.     /**
  55.      * 最终通知
  56.      */
  57.     @After(value = "execution(* com.ldp.controller.*Controller.*(..))")
  58.     public void method05() {
  59.         System.out.println("method05-最终通知-增强逻辑-------------");
  60.     }
  61. }

步骤三：controller类上加上注解

Spring之AOP详解 - 图5

步骤四：测试

  1. package com.ldp.test;
  3. import com.ldp.controller.UserController;
  4. import org.junit.Test;
  5. import org.junit.runner.RunWith;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.test.context.ContextConfiguration;
  8. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  10. /**
  11.  * @Copyright (C) XXXXXXXXXXX科技股份技有限公司
  12.  * @Author: lidongping
  13.  * @Date: 2021-01-14 10:19
  14.  * @Description:
  15.  */
  16. @RunWith(SpringJUnit4ClassRunner.class)
  17. @ContextConfiguration("classpath:bean01.xml")
  18. public class TestAop {
  19.     @Autowired
  20.     private UserController userController;
  22.     /**
  23.      * 测试
  24.      */
  25.     @Test
  26.     public void test01() {
  27.         Object queryUser = userController.queryUser("张无忌", 18);
  28.         System.out.println("queryUser=" + queryUser);
  29.     }
  30. }

注意：当前测试需要关闭环绕通知
当没有异常的时候，执行结果

  1. method01- @Before-前置通知-增强逻辑-------------
  2. 数据查询中模拟...........
  3. method02- @AfterReturning-后置通知-增强逻辑-------------
  4. method05- @After-最终通知-增强逻辑-------------
  5. queryUser=张无忌,18岁

当有异常的时候

  1. method01- @Before-前置通知-增强逻辑-------------
  2. 数据查询中模拟...........
  3. method04- @AfterThrowing-异常通知-增强逻辑-------------
  4. method05- @After-最终通知-增强逻辑-------------

6.2.XML实现AOP配置(现在很少使用,了解)

步骤一：创建一个普通的增强类和增强方法

  1. public class LogAop03 {
  2.     public void method01() {
  3.         System.out.println("-----xml的方式-----------");
  4.     }
  5. }

步骤二：xml中配置aop

  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.        xmlns:aop="http://www.springframework.org/schema/aop"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  7.        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
  8.     <!-- 开启注解扫描 -->
  9.     <context:component-scan base-package="com.ldp.*"></context:component-scan>
  10.     <!-- 开启 Aspect 生成代理对象-->
  11.     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  13.     <bean id="logAop03" class="com.ldp.aop.LogAop03"></bean>
  14.     <!--配置 aop 增强-->
  15.     <aop:config>
  16.         <!--切入点-->
  17.         <aop:pointcut id="p" expression="execution(* com.ldp.controller.*Controller.*(..))"/>
  18.         <!--配置切面-->
  19.         <aop:aspect ref="logAop03">
  20.             <!--增强作用在具体的方法上-->
  21.             <aop:before method="method01" pointcut-ref="p"/>
  22.         </aop:aspect>
  23.     </aop:config>
  24. </beans>

步骤三：测试
测试与之前的一样，略。

7.AOP优化与扩展

1.抽取相同的切入点

Spring之AOP详解 - 图6

2.同一个通知有多个切入点

Spring之AOP详解 - 图7

3.同一个方法有多个通知

使用@Order(数字) 排序
Spring之AOP详解 - 图8

4.使用全注解开发

删除之前的配置文件,添加一个Aop的配置对象

  1. @Configuration
  2. @ComponentScan(basePackages = {"com.ldp"})
  3. @EnableAspectJAutoProxy(proxyTargetClass = true)
  4. public class AopConfig {
  6. }

测试
Spring之AOP详解 - 图9

8.ProceedingJoinPoint 与 JoinPoint 的使用

二者的关系
Spring之AOP详解 - 图10
作用：
1、用来获取被增强方法的参数、方法名、权限命名、注解等，实际上能获取到这些在结合反射可以实现很强大的功能；
2、在环绕通知时让代理执行方法， proceedingJoinPoint.proceed();
上面的日志实际实现案例
案例一：不使用环绕通知的情况

  1. package com.ldp.aop;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.Signature;
  5. import org.aspectj.lang.annotation.*;
  6. import org.springframework.stereotype.Component;
  8. import java.util.Arrays;
  9. import java.util.List;
  11. /**
  12.  * @Copyright (C) XXXXXXXXXXX科技股份技有限公司
  13.  * @Author: lidongping
  14.  * @Date: 2021-01-14 9:52
  15.  * @Description: <p>
  16.  */
  17. @Component
  18. @Aspect
  19. public class LogAop04 {
  20.     /**
  21.      * 抽取相同的切入点
  22.      */
  23.     @Pointcut(value = "execution(* com.ldp.controller.*Controller.*(..))")
  24.     public void methodPointcut01() {
  25.     }
  27.     /**
  28.      * 前置通知
  29.      */
  30.     @Before(value = "methodPointcut01()")
  31.     public void method01(JoinPoint joinPoint) {
  32.         // 获取请求参数
  33.         Object[] args = joinPoint.getArgs();
  34.         Signature pointSignature = joinPoint.getSignature();
  35.         // 获取包+类名
  36.         String declaringTypeName = pointSignature.getDeclaringTypeName();
  37.         // 获取方法名
  38.         String name = pointSignature.getName();
  39.         System.out.println("参数:" + Arrays.toString(args));
  40.         System.out.println("类权限命名:" + declaringTypeName);
  41.         System.out.println("方法名:" + name);
  42.     }
  44.     /**
  45.      * 后置通知
  46.      */
  47.     @AfterReturning(returning = "result", value = "methodPointcut01()")
  48.     public void method02(Object result) {
  49.         System.out.println("方法执行结果:" + result);
  50.     }
  53.     /**
  54.      * 异常通知
  55.      */
  56.     @AfterThrowing(throwing = "ex", value = "methodPointcut01()")
  57.     public void method04(JoinPoint joinPoint, Exception ex) {
  58.         String methodName = joinPoint.getSignature().getName();
  59.         List<Object> args = Arrays.asList(joinPoint.getArgs());
  60.         System.out.println("连接点方法为：" + methodName + ",参数为：" + args + ",异常为：" + ex.getMessage());
  61.     }
  63.     /**
  64.      * 最终通知
  65.      */
  66.     @After(value = "methodPointcut01()")
  67.     public void method05() {
  68.         System.out.println("method05- @After-最终通知-增强逻辑-------------");
  69.     }
  70. }

案例二：使用环绕通知的情况

  1. package com.ldp.aop;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.Around;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.springframework.stereotype.Component;
  8. import java.util.Arrays;
  10. /**
  11.  * @Copyright (C) XXXXXXXXXXX科技股份技有限公司
  12.  * @Author: lidongping
  13.  * @Date: 2021-01-14 9:52
  14.  * @Description: <p>
  15.  */
  16. @Component
  17. @Aspect
  18. public class LogAop04Around {
  19.     /**
  20.      * 环绕通知
  21.      */
  22.     @Around(value = "execution(* com.ldp.controller.*Controller.*(..))")
  23.     public Object method03(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  24.         // 获取开始时间
  25.         long start = System.currentTimeMillis();
  27.         System.out.println("方法参数:" + Arrays.toString(proceedingJoinPoint.getArgs()));
  28.         //让代理方法执行
  29.         Object result = proceedingJoinPoint.proceed();
  31.         // 获取结束执行时间
  32.         long end = System.currentTimeMillis();
  34.         System.out.println("方法返回:" + result);
  35.         System.out.println("方法执行时间:" + (end - start) + " millisecond");
  36.         return result;
  37.     }
  39. }

测试与上面一样略！

完美！