一、jdk动态代理实现

1.接口

代码如下（示例）：

package com.bjtu;

public interface StudentDao {
    public int add(int a, int b);

    public String update(String id);
}

2.接口实现类

代码如下（示例）：

package com.bjtu;

public class StudentDaoImpl implements StudentDao {

    @Override
    public int add(int a, int b) {
        System.out.println("执行方法------------");
        return a+b;
    }

    @Override
    public String update(String id) {
       return id;
    }
}

3.代理类

代码如下（示例）：

package com.bjtu;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class JDKProxy {
    public static void main(String[] args) {
        Class[] interfaces = {StudentDao.class};
      /*可用匿名内部类
      Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        });*/
        StudentDaoImpl stu = new StudentDaoImpl();
        StudentDao stuDao = (StudentDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new StudentProxy(stu));
        int result = stuDao.add(1,2);
        System.out.println("result: " + result);

    }

    static class StudentProxy implements InvocationHandler {
        public Object obj;
        public StudentProxy(Object obj){
            this.obj = obj;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("方法之前执行：" + method.getName()+"传递的参数"+ Arrays.toString(args));
            Object res = method.invoke(obj,args);
            System.out.println("方法之后执行-------" + res);
            return res;
        }
    }
}

执行结果如下：

二、CGILIB动态代理实现

1.业务类

代码如下（示例）：

package com.bjtu;

public class Service {
    public Service() {
        System.out.println("=======构造方法========");
    }

    //final修饰，无法增强
    final public void finalMethod() {
        System.out.println("=========finalMethod========");
    }

    public String testMethod(String name) {
        System.out.println("========testMethod==========");
        return  "name = " + name;
    }
}

拦截器

package com.bjtu;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class MyMethodInterceptor implements MethodInterceptor {

    @Override
    public String intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("========插入前置通知=======");
        //通过代理类调用父类中的方法
        String name = (String) methodProxy.invokeSuper(o, objects);
        System.out.println("========后置通知======");
        return name;
    }
}

测试类

package com.bjtu;

import org.springframework.cglib.proxy.Enhancer;

public class Client {
    public static void main(String[] args) {


        //通过cglib动态代理获取代理对象的过程
        Enhancer enhancer = new Enhancer();
        //设置enhancer对象的父类
        enhancer.setSuperclass(Service.class);

        //设置enhancer的回调对象，拦截处理器
        enhancer.setCallback(new MyMethodInterceptor());

        //创建代理对象
        Service proxy = (Service) enhancer.create();

        //通过代理对象调用方法
       String obj = proxy.testMethod("张三");
        System.out.println(obj);
    }
}

执行结果如下：

三、两者区别

Jdk动态代理：
必须有接口。创建接口实现类的代理对象，通过代理对象来增强其中的方法。
使用Proxy类，调用newProxyInstance方法，三个参数：类加载器，接口，实例（InvocationHandler的实现类）

为什么jdk动态代理必须要有接口？

因为动态代理底层是生成字节码文件，通过修改字节码文件，从而达到动态代理的效果。字节码文件是二进制的我们看不懂，需要反编译。
问题来了，Java底层生成的$Proxy长这样。

jdk动态代理帮我们增强方法，生成代理类对象，字节码中的代理类 $Proxy 默认是继承接口Proxy的，而java是单继承的，所以必须有接口。

cglib是通过生成被代理对象的子类的方式，增强方法的，也就是拿到被代理对象的一个模板，对其进行增强。也就不需要接口了。

四、AOP使用的是哪种动态代理方式？

AOP在选择动态代理方式的逻辑如图中所示：

源码判断时候，if（ || ||）三个条件。第一个判断isOptimize，默认为假；第二个判断proxyTargetClass，默认为假；第三个判断，是否为接口。
因此，当被增强类继承接口时，都是用jdk动态代理。
当被增强类不继承接口时，需要判断proxyTargetClass，不指定的话，默认为false。
指定为true才会走CGLIB动态代理。

一、背景

今天有小伙伴面试的时候被问到：Spring AOP中JDK 和 CGLib动态代理哪个效率更高？

二、基本概念

首先，我们知道Spring AOP的底层实现有两种方式：一种是JDK动态代理，另一种是CGLib的方式。

自Java 1.3以后，Java提供了动态代理技术，允许开发者在运行期创建接口的代理实例，后来这项技术被用到了Spring的很多地方。

JDK动态代理主要涉及java.lang.reflect包下边的两个类：Proxy和InvocationHandler。其中，InvocationHandler是一个接口，可以通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态地将横切逻辑和业务逻辑贬值在一起。

JDK动态代理的话，他有一个限制，就是它只能为接口创建代理实例，而对于没有通过接口定义业务方法的类，如何创建动态代理实例哪？答案就是CGLib。

CGLib采用底层的字节码技术，全称是：Code Generation Library，CGLib可以为一个类创建一个子类，在子类中采用方法拦截的技术拦截所有父类方法的调用并顺势织入横切逻辑。

三、JDK 和 CGLib动态代理区别

1、JDK动态代理具体实现原理：

• 通过实现InvocationHandlet接口创建自己的调用处理器；

• 通过为Proxy类指定ClassLoader对象和一组interface来创建动态代理；

• 通过反射机制获取动态代理类的构造函数，其唯一参数类型就是调用处理器接口类型；

• 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数参入；

JDK动态代理是面向接口的代理模式，如果被代理目标没有接口那么Spring也无能为力，Spring通过Java的反射机制生产被代理接口的新的匿名实现类，重写了其中AOP的增强方法。

2、CGLib动态代理：

CGLib是一个强大、高性能的Code生产类库，可以实现运行期动态扩展java类，Spring在运行期间通过 CGlib继承要被动态代理的类，重写父类的方法，实现AOP面向切面编程呢。

3、两者对比：

• JDK动态代理是面向接口的。

• CGLib动态代理是通过字节码底层继承要代理类来实现（如果被代理类被final关键字所修饰，那么抱歉会失败）。

4、使用注意：

• 如果要被代理的对象是个实现类，那么Spring会使用JDK动态代理来完成操作（Spirng默认采用JDK动态代理实现机制）；

• 如果要被代理的对象不是个实现类那么，Spring会强制使用CGLib来实现动态代理。

四、JDK 和 CGLib动态代理性能对比-教科书上的描述

我们不管是看书还是看文章亦或是我那个上搜索参考答案，可能很多时候，都可以找到如下的回答：

关于两者之间的性能的话，JDK动态代理所创建的代理对象，在以前的JDK版本中，性能并不是很高，虽然在高版本中JDK动态代理对象的性能得到了很大的提升，但是他也并不是适用于所有的场景。主要体现在如下的两个指标中：

1、CGLib所创建的动态代理对象在实际运行时候的性能要比JDK动态代理高不少，有研究表明，大概要高10倍；

2、但是CGLib在创建对象的时候所花费的时间却比JDK动态代理要多很多，有研究表明，大概有8倍的差距；

3、因此，对于singleton的代理对象或者具有实例池的代理，因为无需频繁的创建代理对象，所以比较适合采用CGLib动态代理，反正，则比较适用JDK动态代理。

结果是不是如上边1、2、3条描述的那样哪？下边我们做一些小实验分析一下！

五、性能测试

1、首先有几个Java类

2、Target.java

package com.java.proxy.test;

public interface Target {

    int test(int i);

}

3、TargetImpl.java

package com.java.proxy.test;

public class TargetImpl implements Target {

    @Override
    public int test(int i) {
        return i + 1;
    }
}

4、JdkDynamicProxyTest.java

package com.java.proxy.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JdkDynamicProxyTest implements InvocationHandler {

    private Target target;

    private JdkDynamicProxyTest(Target target) {
        this.target = target;
    }

    public static Target newProxyInstance(Target target) {
        return (Target) Proxy.newProxyInstance(JdkDynamicProxyTest.class.getClassLoader(),
                new Class<?>[]{Target.class},
                new JdkDynamicProxyTest(target));

    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(target, args);
    }
}

5、CglibProxyTest.java

package com.java.proxy.test;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxyTest implements MethodInterceptor {

    private CglibProxyTest() {
    }

    public static <T extends Target> Target newProxyInstance(Class<T> targetInstanceClazz) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetInstanceClazz);
        enhancer.setCallback(new CglibProxyTest());
        return (Target) enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        return proxy.invokeSuper(obj, args);
    }

}

6、ProxyPerformanceTest.java

package com.java.proxy.test;

import java.util.LinkedHashMap;
import java.util.Map;

public class ProxyPerformanceTest {

    public static void main(String[] args) {
        //创建测试对象
        Target nativeTest = new TargetImpl();
        Target dynamicProxy = JdkDynamicProxyTest.newProxyInstance(nativeTest);
        Target cglibProxy = CglibProxyTest.newProxyInstance(TargetImpl.class);

        //预热一下
        int preRunCount = 10000;
        runWithoutMonitor(nativeTest, preRunCount);
        runWithoutMonitor(cglibProxy, preRunCount);
        runWithoutMonitor(dynamicProxy, preRunCount);

        //执行测试
        Map<String, Target> tests = new LinkedHashMap<String, Target>();
        tests.put("Native   ", nativeTest);
        tests.put("Dynamic  ", dynamicProxy);
        tests.put("Cglib    ", cglibProxy);
        int repeatCount = 3;
        int runCount = 1000000;
        runTest(repeatCount, runCount, tests);
        runCount = 50000000;
        runTest(repeatCount, runCount, tests);
    }

    private static void runTest(int repeatCount, int runCount, Map<String, Target> tests) {
        System.out.println(
                String.format("\n===== run test : [repeatCount=%s] [runCount=%s] [java.version=%s] =====",
                        repeatCount, runCount, System.getProperty("java.version")));
        for (int i = 0; i < repeatCount; i++) {
            System.out.println(String.format("\n--------- test : [%s] ---------", (i + 1)));
            for (String key : tests.keySet()) {
                runWithMonitor(tests.get(key), runCount, key);
            }
        }
    }

    private static void runWithoutMonitor(Target target, int runCount) {
        for (int i = 0; i < runCount; i++) {
            target.test(i);
        }
    }

    private static void runWithMonitor(Target target, int runCount, String tag) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < runCount; i++) {
            target.test(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("[" + tag + "] Total Time:" + (end - start) + "ms");
    }
}

7、测试结果

（1）JDK 1.6

（2）JDK 1.7

（3）JDK 1.8

经过多次试验，可以看出平均情况下的话，JDK动态代理的运行速度已经逐渐提高了，在低版本的时候，运行的性能可能不如CGLib，但是在1.8版本中运行多次，基本都可以得到一致的测试结果，那就是JDK动态代理已经比CGLib动态代理快了！

但是JDK动态代理和CGLib动态代理的适用场景还是不一样的哈！

六、总结

最终的测试结果大致是这样的，在1.6和1.7的时候，JDK动态代理的速度要比CGLib动态代理的速度要慢，但是并没有教科书上的10倍差距，在JDK1.8的时候，JDK动态代理的速度已经比CGLib动态代理的速度快很多了，希望小伙伴在遇到这个问题的时候能够有的放矢！

Spring AOP中的JDK和CGLib动态代理关于这个知识点很重要，关于两者之间性能的对比经过测试实验已经有了一个初步的结果，以后再有人问你Spring AOP，不要简单的说JDK动态代理和CGLib这两个了，是时候的可以抛出来对两者之间区别的理解，是有加分的哦！

参考文章：

1、https://blog.csdn.net/qq1723205668/article/details/56481476
2、https://blog.csdn.net/xiangbq/article/details/49794335

【视频福利】2T免费学习视频，搜索或扫描上述二维码关注微信公众号：Java后端技术（ID: JavaITWork）回复：1024，即可免费获取！内含SSM、Spring全家桶、微服务、MySQL、MyCat、集群、分布式、中间件、Linux、网络、多线程，Jenkins、Nexus、Docker、ELK等等免费学习视频，持续更新！

一、AOP

1.面向切面编程（AOP）

AOP全称Aspect-Orinted Programing（面向切面编程），是一种编程思想，是OOP的延伸和补充，采用横向抽取机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或运行的时候，再将这些提取出来的代码应用到需要执行的地方。
AOP术语

按照通知在目标方法中的连接点位置，通知分5种类型：
① 前置通知：在目标方法前实施增强，用于权限管理；
② 后置通知：在目标方法后实施增强，用于关闭流、上传文件、删除临时文件等；（目标方法出现异常后不会执行）
③ 环绕通知：在目标方法前后实施增强，用于日志、事务管理；
④ 异常通知：在目标方法后实施增强，用于处理异常、记录日志；（只有目标方法出现异常时才会执行）
⑤ 最终通知：在目标方法前实施增强，用于释放资源；（无论目标方法出现异常都会执行）

2.AOP底层原理

AOP的底层采用JDK动态代理，实际上动态代理具体有两种：

JDK动态代理

对于使用业务接口的类，Spring默认采用JDK动态代理实现AOP；
① JDK动态代理是通过java.lang.reflect.Proxy类实现的，可以调用Proxy类的静态方法newProxyInstance()来创建代理对象。
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces ,InvocationHandler h) //返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。
② JDK动态代理实现的需要实现InvocationHandler接口，实现invoke方法
Object invoke(Object proxy, Method method, Object[] args) //处理代理实例上的方法调用并返回结果。

JDK动态代理如下：

//接口TestDao
public interface UserDao {
    public void addUser();
    public void deleteUser();
}

//接口实现类TestDaoImpl（此时的TestDaoImpl作为目标类将被增强）
public class UserDaoImpl implements UserDao {
    @Override
    public void addUser() {
        System.out.println("添加用户");
    }
    @Override
    public void deleteUser() {
        System.out.println("删除用户");
    }
}

//切面类MyAspect
public class MyAspect {
    public void check(){
        System.out.println("模拟检查权限...");
    }
    public void log(){
        System.out.println("模拟记录日志...");
    }
}

//代理类JDKProxy（需要实现InvocationHandler ）
public class JDKProxy implements InvocationHandler {
    //声明目标类接口
    private UserDao userDao;
    //代理方法
    public Object createProxy(UserDao userDao){
        this.userDao = userDao;
        //1.类加载器
        ClassLoader classLoader = JDKProxy.class.getClassLoader();
        //2.被代理对象实现的所有接口
        Class<?>[] interfaces = userDao.getClass().getInterfaces();
        //3.使用代理类进行增强
        return Proxy.newProxyInstance(classLoader,interfaces,this);
    }
    /**
     * 所有动态代理类的方法调用，都会交由invoke()方法去处理
     * @param proxy 被代理的对象
     * @param method 将要执行的方法信息（通过反射获取）
     * @param args 执行方法需要的参数
     * @return 返回创建的代理类对象
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //声明切面
        MyAspect myAspect = new MyAspect();
        //前增强
        myAspect.check();
        //在目标类上调用方法，并传入参数
        Object obj = method.invoke(userDao, args);
        //后增强
        myAspect.log();
        //返回创建的代理类对象
        return obj;
    }
}

//测试类
public class JDKTest {
    public static void main(String[] args) {
        //创建代理对象
        JDKProxy proxy = new JDKProxy();
        //创建目标对象
        UserDao userDao = new UserDaoImpl();
        //从代理对象中获取增强后的目标对象
        UserDao userDao1 = (UserDao) proxy.createProxy(userDao);
        //执行方法
        userDao1.addUser();
        userDao1.deleteUser();
    }
}

CGLIB动态代理

JDK动态代理有局限性——使用动态代理的业务类必须实现接口，对于没有实现接口的类就需要使用CGLIB动态代理。

① CGLIB（Code Generation Library）是一个高性能的代码生成包，采用底层的字节码技术，对指定目标类生成一个子类，并对子类进行增强。
② 代理类需要实现MethodInterceptor接口，实现接口中的interceptor()方法。

//目标类（不需要实现接口，只是定义需要增强的方法即可）
public class UserDao {
    public void addUser(){
        System.out.println("添加用户");
    }
    public void deleteUser(){
        System.out.println("删除用户");
    }
}

此处的切面类依旧是上面JDK动态代理中的MyAspect.java

//代理类
//注意：import org.springframework.cglib.proxy.MethodInterceptor
public class CglibProxy implements MethodInterceptor {
    //代理方法
    public Object createProxy(Object obj){
        //创建一个动态类对象
        Enhancer enhancer = new Enhancer();
        //确定需要增强的类，设置其父类
        enhancer.setSuperclass(obj.getClass());
        //添加回调函数
        enhancer.setCallback((Callback) this);
        //返回创建的代理类
        return enhancer.create();
    }
    /**
     * @param proxy CGLIB根据指定父类生成的代理对象
     * @param method 拦截的方法
     * @param args 拦截方法的参数数组
     * @param methodProxy 方法的代理对象，用于执行父类的方法
     * @return 返回创建的代理类对象
     */
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //创建切面类对象
        MyAspect myAspect = new MyAspect();
        //前增强
        myAspect.check();
        //目标方法执行
        Object obj = methodProxy.invokeSuper(proxy, args);
        //后增强
        myAspect.log();
        return obj;
    }
}

//CGLIB测试类
public class CglibTest {
    public static void main(String[] args) {
        //创建代理对象
        CglibProxy cglibProxy = new CglibProxy();
        //创建目标对象
        UserDao userDao = new UserDao();
        //获取增强后的目标对象
        UserDao userDao1 = (UserDao) cglibProxy.createProxy(userDao);
        //执行方法
        userDao1.addUser();
        userDao1.deleteUser();
    }
}

二、AOP开发

AspectJ开发

AscpectJ是一个基于java语言的独立于Spring的AOP框架，使用AspectJ实现AOP有两种方式：基于XML的声明式AspectJ、基于注解的声明式AspectJ；
1.切入点表达式
（1）作用：指明对类中的那个方法进行增强处理；
（2）语法格式：execution([权限修饰符][返回值类型][类全路径][方法名称]([参数列表]))
（类全路径=包名+类名）
例1：对com.jd.dao.BookDao类里面的add进行增强：execution(* com.atguigu.dao.BookDao.add(..))
例2：对com.jd.dao.BookDao类里面的所有的方法进行增强：execution(* com.atquiqu.dao.BookDao.*(..))
例3：对com.jd.dao包里面所有类，类里面所有方法进行增强：execution(* com.atauiau.dao.*.*(..))

1.基于注解的声明式AspectJ

（1）需要导入的jar包

（2）具体实现：

//接口（业务逻辑的接口，aop默认是JDK动态代理（业务逻辑需要实现接口））
public interface UserDao {
    public void addUser();
    public void deleteUser();
}

//目标类，实现UserDao接口
@Repository("userDao")
public class UserDaoImpl implements UserDao{
    @Override
    public void addUser() {
        //int i = 10/0;//模拟异常
        System.out.println("添加用户");
    }
    @Override
    public void deleteUser() {
        System.out.println("删除用户");
    }
}

//切面类，在此类中编写通知
@Aspect
@Component
public class MyAspect {
    //定义切入点表达式
    @Pointcut("execution(* com.jd.aspectj.dao.*.*(..))")//此处的配置很关键
    public void myPointCut(){}
    //前置通知
    @Before("myPointCut()")
    public void myBefore(JoinPoint joinPoint){
        System.out.print("前置通知：模拟检查权限...");
        System.out.print("目标类是："+joinPoint.getTarget());
        System.out.println(",被织入增强的目标方法是："+joinPoint.getSignature().getName());
    }
    //后置通知
    @AfterReturning("myPointCut()")
    public void myAfterReturning(JoinPoint joinPoint){
        System.out.print("后置通知：模拟记录日志...");
        System.out.println("，被织入增强处理的方法是："+joinPoint.getSignature().getName());
    }
    //环绕通知
    @Around("myPointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        //开始
        System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
        //执行当前目标方法
        Object obj = proceedingJoinPoint.proceed();
        //结束
        System.out.println("环绕结束：执行目标方法之后，模拟关闭事务...");
        return obj;
    }
    //异常通知（只有当程序执行过程中出现异常时才会执行）
    @AfterThrowing(value = "myPointCut()",throwing = "e")
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("异常通知："+"出错了"+e.getMessage());
    }
    //最终通知（无论是否有异常抛出，都会执行）
    @After("myPointCut()")
    public void myAfter(){
        System.out.println("最终通知：模拟方法执行结束后的释放资源...");
    }
}

<!--Spring的配置文件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:aop="http://www.springframework.org/schema/aop"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启注解扫描，使注解生效-->
    <context:component-scan base-package="com.jd.aspectj"/>
    <!--开启Aspectj生成代理对象-->
    <aop:aspectj-autoproxy/>
</beans>

//测试方法
@Test
public void annotationAspectjTest(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserDao userDao= (UserDao) context.getBean("userDao");
    userDao.addUser();
    System.out.println("---------------------------------------------------------------------");
    userDao.deleteUser();
}

没有异常时的正常通知情况：

模拟UserDaoImpl中出现异常，如下：

同样，可以使用配置类替代配置文件，具体如下：

扩展：有多个切面类（增强类）对同一个方法进行增强，可以设置切面类（增强类）的优先级，在增强类上面添加注解@Order(数字类型值)，数字类型值越小优先级越高

@component
@Aspect
@Order(1)
public class YourAspect{...}

2.基于XML的声明式AspectJ

（xml的方式了解即可）
UserDao和UserDaoImpl还是上面的，需要该变的是Spring配置文件、切面类、

//切面类
public class MyAspect2 {
    //定义切入点表达式
    public void myPointCut(){}
    //前置通知
    public void myBefore(JoinPoint joinPoint){
        System.out.print("前置通知：模拟检查权限...");
        System.out.print("目标类是："+joinPoint.getTarget());
        System.out.println(",被织入增强的目标方法是："+joinPoint.getSignature().getName());
    }
    //后置通知
    public void myAfterReturning(JoinPoint joinPoint){
        System.out.print("后置通知：模拟记录日志...");
        System.out.println("，被织入增强处理的方法是："+joinPoint.getSignature().getName());
    }
    //环绕通知
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        //开始
        System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
        //执行当前目标方法
        Object obj = proceedingJoinPoint.proceed();
        //结束
        System.out.println("环绕结束：执行目标方法之后，模拟关闭事务...");
        return obj;
    }
    //异常通知（只有当程序执行过程中出现异常时才会执行）
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("异常通知："+"出错了"+e.getMessage());
    }
    //最终通知（是否有异常抛出，都会执行）
    public void myAfter(){
        System.out.println("最终通知：模拟方法执行结束后的释放资源...");
    }
}

<!--xml方式实现aop的Spring配置文件-->
<?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:aop="http://www.springframework.org/schema/aop"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--1.目标类-->
    <bean id="userDao" class="com.jd.aspectj.dao.UserDaoImpl"/>
    <!--2.切面类-->
    <bean id="myAspect2" class="com.jd.aspectj.xml.MyAspect2"/>
    <!--3.aop编程-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect ref="myAspect2">
        <!--配置切入点，通知最后需要增强哪些方法-->
        <aop:pointcut id="myPointCut" expression="execution(* com.jd.aspectj.dao.*.*(..))"/>
            <!--前置通知-->
            <aop:before method="myBefore" pointcut-ref="myPointCut"/>
            <aop:after method="myAfterReturning" pointcut-ref="myPointCut"/>
            <aop:around method="myAround" pointcut-ref="myPointCut"/>
            <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
            <aop:after method="myAfter" pointcut-ref="myPointCut"/>
        </aop:aspect>
    </aop:config>
</beans>

//测试方法
@Test
public void xmlAspectjTest(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserDao userDao= (UserDao) context.getBean("userDao");
    userDao.addUser();
    System.out.println("---------------------------------------------------------------------");
    userDao.deleteUser();
}

没有异常时的正常通知情况：

模拟UserDaoImpl中出现异常，如下：