目录

三，Spring核心AOP

1，介绍

2，代理&静态代理

2.1 原有方式：核心业务和服务方法都编写在一起

2.2 基于类的静态代理

2.3 基于接口的静态代理

2.4 提取出切面代码，作为AOP接口

2.5 总结

3，动态代理

3.1 基于JDK代理

结构化

3.2 基于CGLIB代理

结构化

3.3 使用细节对比

4，SpringAOP介绍

4.1 AOP介绍

4.2  AspectJ 对 AOP 的实现

5，SpringAOP的实现——注解方式

5.1 测试项目的基本结构

5.2 前置通知@Before

5.3 连接点JoinPoint

5.4 后置通知@AfterReturning

5.5 异常通知@AfterThrowing

5.6 最终通知@After

5.7 环绕通知@Around

5.8 切入点表达式@Pointcut

6，SpringAOP的实现——XML方式

三，Spring核心AOP

1，介绍

AOP为Aspect Oriented Programming的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP的作用：不修改源码的情况下，程序运行期间对方法进行功能增强

好处：

1. 减少代码的重复，提高开发效率，便于维护。
2. 专注核心业务的开发（比如业务开发过程中往往需要考虑事务、日志等的处理）。

核心业务和服务性代码（日志、事务、权限等）混合在一起。开发时各自做自己擅长的事情，运行的时候将服务性代码织入到核心业务中。

通过spring工厂自动实现将服务性代码以切面的方式加入到核心业务代码中。

2，代理&静态代理

代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

2.1 原有方式：核心业务和服务方法都编写在一起

public class TeamService { 
    public void add(){ 
        try {
            System.out.println("开始事务"); 
            System.out.println("TeamService---- add----");// 核心业务 
            System.out.println("提交事务"); 
        } catch (Exception e) { 
            e.printStackTrace(); 
            System.out.println("回滚事务"); 
        } 
    } 
}

2.2 基于类的静态代理

可以将服务性代码分离出来。但是代理类只能代理一个类。

---

被代理类

public class TeamService { 
    public void add(){ 
        System.out.println("TeamService---- add----");// 核心业务 
    } 
}

代理类 

 
public class ProxyTeamService extends TeamService { 
    public void add(){ 
        try {
            System.out.println("开始事务"); 
            super.add();//核心业务就是由被代理对象完成 ；其他服务功能由代理类完成 
            System.out.println("提交事务"); 
        }catch (Exception e){ 
            System.out.println("回滚事务"); 
        } 
    } 
}

2.3 基于接口的静态代理

为核心业务（保存add）创建一个接口，通过接口暴露被代理的方法。

要求：代理类和被代理类都实现了同一个接口。

优势：

• 代理类与被代理类解耦。相比基于类的静态代理，一个代理类只要传入不同的参数，就可以代理不同的类；
• 由于代理类与被代理类松耦合，因此可以方便的实现多级代理；

---

接口

 
public interface IService { 
    void add(); 
}

被代理类

// 被代理类1
public class TeamService implements IService{ 
    @Override 
    public void add(){ 
        System.out.println("TeamService---- add----");// 核心业务 
    } 
}

// 被代理类2
public class UserService implements IService{ 
    @Override 
    public void add() { 
        System.out.println("UserService---- add-----"); 
    } 
}

代理类

 
public class ProxyTranService implements IService { 
    private IService service;//被代理的对象 
    public ProxyTranService(IService service) { 
        this.service = service; 
    }

    @Override 
    public void add() { 
        try {
            System.out.println("开始事务"); 
            service.add();//核心业务就是由被代理对象完成 ；其他服务功能由代理类完成 
            System.out.println("提交事务"); 
        }catch (Exception e){ 
            System.out.println("回滚事务"); 
        } 
    } 
}

public class ProxyLogService implements IService { 
    private IService service;//被代理对象 
    public ProxyLogService(IService service) { 
        this.service = service; 
    }

    @Override 
    public void add() { 
        try {
            System.out.println("开始日志"); 
            service.add();//核心业务就是由被代理对象完成 ；其他服务功能由代理类完成 
            System.out.println("结束日志"); 
        }catch (Exception e){ 
            System.out.println("异常日志"); 
        } 
    } 
}

测试类 

public static void main(String[] args) { 
    TeamService teamService=new TeamService();//被代理对象 
    UserService userService=new UserService();//被代理对象 
    // 代理类与被代理类解耦。一个代理类，传入不同的参数，即可代理不同的类
    ProxyTranService tranService=new ProxyTranService(userService);//事务代理对象--一级代理 
//    tranService.add();//代理对象干活 
    ProxyLogService logService=new ProxyLogService(tranService);//日志的代理对象--二级代理
    logService.add(); 
}

2.4 提取出切面代码，作为AOP接口

共有4个位置可以将切面代码编织进入核心业务代码中。

代理将被代理对象和切面整合起来，形成完整的业务逻辑。

---

切面接口 

 
public interface AOP { 
    void before(); 
    void after(); 
    void exception(); 
    void myFinally(); 
}

事务切面 

public class TranAOP implements AOP { 
    @Override 
    public void before() { 
        System.out.println("事务----before"); 
    }

    @Override 
    public void after() { 
        System.out.println("事务----after"); 
    }

    @Override 
    public void exception() { 
        System.out.println("事务----exception"); 
    }

    @Override 
    public void myFinally() { 
        System.out.println("事务----myFinally"); 
    } 
}

日志切面

public class LogAop implements AOP{ 
    @Override 
    public void before() { 
        System.out.println("日志----before"); 
    }

    @Override 
    public void after() { 
        System.out.println("日志----after"); 
    }

    @Override 
    public void exception() { 
        System.out.println("日志----exception"); 
    }

    @Override 
    public void myFinally() { 
        System.out.println("日志----myFinally"); 
    } 
}

代理类

public class ProxyAOPService implements IService { 
    private IService service;//被代理对象 
    private AOP aop;//要加入切面 
    public ProxyAOPService(IService service, AOP aop) { 
        this.service = service; 
        this.aop = aop; 
    }

    @Override 
    public void add() { 
        try {
            aop.before(); 
            service.add();//被代理对象干活 
            aop.after(); 
        }catch (Exception e){ 
            aop.exception(); 
        }finally { 
            aop.myFinally();
        } 
    } 
}

测试类

@Test
public void test02(){ 
    IService teamService=new TeamService();//被代理对象--核心内容 
    AOP logAop=new LogAop();//切面-服务内容 
    AOP tranAop=new TranAOP(); 
    IService service=new ProxyAOPService(teamService,logAop); //代理对象--一级代理 
    IService service2=new ProxyAOPService(service,tranAop);//代理对象--二级代理 
    service2.add(); 
} 

2.5 总结

静态代理： 

• 优点：可以做到在不修改目标对象的功能前提下，对目标对象功能扩展。 
• 缺点： 因为代理对象，需要与目标对象实现一样的接口。所以会有很多代理类，类太多。 一旦接口增加方法，目标对象与代理对象都要维护。

3，动态代理

动态代理是指代理类对象在程序运行时由JVM根据反射机制动态生成的。动态代理不需要定义代理类。动态代理其实就是jdk运行期间，动态创建class字节码并加载到JVM。

• 静态代理：要求代理类一定存在；
• 动态代理：程序运行的时候，根据要被代理的对象动态生成代理类；

类型：1、基于JDK的动态代理，2、基于CGLIB的动态代理；

3.1 基于JDK代理

newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

• ClassLoader ：类加载器，因为动态代理类，借助别人的类加载器。一般使用被代理对象的类加载器。 
• Class[] interfaces:接口类对象的集合，针对接口的代理，针对哪个接口做代理，一般使用的就是被代理对象的接口。 
• InvocationHandler：句柄，回调函数，编写代理的规则代码 

public Object invoke(Object arg0, Method arg1, Object[] arg2) 

• Object arg0：代理对象 
• Method arg1：被代理的方法 
• Object[] arg2：被代理方法被执行的时候的参数的数组 

---

接口 

 
public interface IService { 
    void add(); 
}

被代理类

// 被代理类1
public class TeamService implements IService{ 
    @Override 
    public void add(){ 
        System.out.println("TeamService---- add----");// 核心业务 
    } 
}

// 被代理类2
public class UserService implements IService{ 
    @Override 
    public void add() { 
        System.out.println("UserService---- add-----"); 
    } 
}

 使用动态代理 

public class MyJDKProxy { 
    public static void main(String[] args) { 
        //目标对象--被代理对象 
        TeamService teamService=new TeamService(); 

        //返回代理对象 调用JDK中Proxy类中的静态方法newProxyInstance获取动态代理类的实例 
        IService proxyService= (IService) Proxy.newProxyInstance( 
            teamService.getClass().getClassLoader(), 
            teamService.getClass().getInterfaces(), 
            new InvocationHandler() {//回调函数 编写代理规则 
                @Override 
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    try {
                        System.out.println("开始事务"); 
                        Object invoke = method.invoke(teamService, args);//核心业务 
                        System.out.println("提交事务"); 
                        return invoke; 
                    }catch (Exception e){ 
                        System.out.println("回滚事务"); 
                        e.printStackTrace(); 
                        throw e; 
                    }finally { 
                        System.out.println("finally---------"); 
                    } 
                } 
            } 
        );

        //代理对象干活 
        proxyService.add(); 
        System.out.println(teamService.getClass()); 
        System.out.println(proxyService.getClass()+"--------"); 
    } 
}

可以看出上面并没有显式的创建代理类，代理类的创建工作交由jdk执行。

此外由于没有代理类的定义，因此代理类也不需要实现接口，所以接口变动时，只需要修改核心业务即可，动态代理对象的生成基本没有变动。

结构化

方式1

创建ProxyHandler类，实现InvocationHandler接口，重写invoke方法，不需要在newProxyInstance中重写invoke方法，看起来更简洁一些。

ProxyHandler类

public class ProxyHandler implements InvocationHandler {
    private IService service;//目标对象 
    private AOP aop;//切面 
    public ProxyHandler(IService service, AOP aop) { 
        this.service = service; 
        this.aop = aop; 
    }

    @Override 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        try {
            aop.before(); 
            Object invoke = method.invoke(service, args);//核心业务 
            aop.after(); 
            return invoke; 
        }catch (Exception e){ 
            aop.exception(); 
            e.printStackTrace(); 
            throw e; 
        }finally { 
            aop.myFinally(); 
        } 
    } 
}

测试方法

public static void main2(String[] args) { 
    //目标对象--被代理对象 
    TeamService teamService=new TeamService(); 

    //切面 
    AOP tranAop=new TranAOP(); 

    //返回代理对象 基于JDK的动态代理 
    IService proxyService= (IService) Proxy.newProxyInstance( 
        teamService.getClass().getClassLoader(), 
        teamService.getClass().getInterfaces(), 
        new ProxyHandler(teamService,tranAop) 
    );

    //代理对象干活 
    proxyService.add(); 

    System.out.println(teamService.getClass()); 
    System.out.println(proxyService.getClass()+"------"); 
}

方式2

通过ProxyFactory类获取动态代理的实例

ProxyFactory类 

public class ProxyFactory {

    private IService service;//目标对象
    private AOP aop;//切面

    public ProxyFactory(IService service, AOP aop) {
        this.service = service;
        this.aop = aop;
    }

    
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(
                service.getClass().getClassLoader(),
                service.getClass().getInterfaces(),
                new InvocationHandler() {//回调函数 编写代理规则
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        try {
                            aop.before();
                            Object invoke = method.invoke(service, args);//核心业务
                            aop.after();
                            return invoke;
                        }catch (Exception e){
                            aop.exception();
                            e.printStackTrace();
                            throw e;
                        }finally {
                            aop.myFinally();
                        }
                    }
                }
        );
    }
}

测试方法

public class MyJDKProxy {

    public static void main(String[] args) {
        //目标对象--被代理对象
        TeamService teamService=new TeamService();
        //切面
        AOP tranAop=new TranAOP();
        AOP logAop=new LogAop();
        //获取代理对象
        IService service= (IService) new ProxyFactory(teamService,tranAop).getProxyInstance();
        IService service1= (IService) new ProxyFactory(service,logAop).getProxyInstance();
        service1.add();//核心业务+服务代码混合在一起的完整的业务员方法
    }
}

代理对象不需要实现接口，但是目标对象（被代理类）一定要实现接口；否则不能用JDK动态代理。如果想要功能扩展，但目标对象没有实现接口，怎样功能扩展？

采用子类的方式实现代理CGLIB。

3.2 基于CGLIB代理

CGLIB是一个强大的、高性能的代码生成库。其被广泛应用于AOP框架（Spring、dynaop）中，用以提供方法拦截操作。Hibernate作为一个比较受欢迎的ORM框架，同样使用CGLIB来代理单端（多对一和一对一）关联（延迟提取集合使用的另一种机制）。CGLIB作为一个开源项目，其代码托管在github，地址为：https://github.com/cglib/cglib

参考@danchu【CGLIB(Code Generation Library)详解】

Cglib代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。

• JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。
• CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception。
• CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

---

核心业务

public class Nbaservice { 
    public int add(String name,int id){ 
        System.out.println("Nbaservice---- add----"); 
        return id; 
    } 
}

测试类

public static void main(String[] args) { 
    //目标对象:没有接口 
    Nbaservice nbaservice=new Nbaservice(); 

    //创建代理对象：选择cglib动态代理 
    Nbaservice proxyService= (Nbaservice) Enhancer.create(nbaservice.getClass(), 
        new MethodInterceptor() {//回调函数编写代理规则 
            @Override 
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
                try {
                    System.out.println("开始事务"); 
                    Object invoke = methodProxy.invokeSuper(o, objects);//核心 
                    System.out.println("提交事务"); 
                    return invoke; 
                } catch (Exception e){ 
                    System.out.println("事务回滚"); 
                    throw e; 
                } finally { 
                    System.out.println("finally------------"); 
            } 
        } 
    }); 
    //代理对象干活 
    int res=proxyService.add("huren",1001); 
    System.out.println(res); 
}

结构化

代理对象工厂（创建代理对象）

public class CglibProxyFactory { 
    //目标对象 
    private Nbaservice nbaservice;//没有实现接口的 

    //切面 
    private AOP aop;//切面 

     
    public Object getProxyInstance(Nbaservice nbaservice,AOP aop){ 
        return Enhancer.create(nbaservice.getClass(), 
            new MethodInterceptor() { 
                @Override 
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
                    try {
                        aop.before(); 
                        Object o1 = methodProxy.invokeSuper(o, objects); 
                        aop.after(); 
                        return o1; 
                    } catch (Exception e){ 
                        aop.exception(); 
                        throw e; 
                    } finally { 
                        System.out.println("finally-----------"); 
                    } 
                } 
            }); 
    } 
}

3.3 使用细节对比

1，创建代理对象的方法

基于JDK

// 返回指定接口的代理实例，该接口将方法调用分派给指定的调用处理程序。 
Proxy.newProxyInstance​(ClassLoader loader, 类[] interfaces, InvocationHandler h);

Proxy.newProxyInstance(service.getClass().getClassLoader(),
    service.getClass().getInterfaces(),
    new InvocationHandler(){...}
);

基于CGLIB

Enhancer.create(service.getClass(), new MethodInterceptor(){...});

2，回调函数实现

基于JDK（回调函数InvocationHandler中重写invoke方法）

invoke(Object proxy, Method method, Object[] args)

new InvocationHandler() {//回调函数 编写代理规则
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            aop.before();
            Object invoke = method.invoke(service, args);//核心业务
            aop.after();
            return invoke;
        }catch (Exception e){
            aop.exception();
            e.printStackTrace();
            throw e;
        }finally {
            aop.myFinally();
        }
    }
}

基于CGLIB（回调函数MethodInterceptor中重写intercept方法）

intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) 

new MethodInterceptor() { 
    @Override 
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
        try {
            aop.before(); 
            Object o1 = methodProxy.invokeSuper(o, objects); 
            aop.after(); 
            return o1; 
        }catch (Exception e){ 
            aop.exception(); 
            throw e; 
        } finally { 
            System.out.println("finally-----------"); 
        } 
    } 
}

3，核心业务处理

基于JDK

Object invoke = method.invoke(service, args);//核心业务

基于CGLIB

Object o1 = methodProxy.invokeSuper(o, objects); 

4，SpringAOP介绍

Spring的AOP实现底层就是对上面的动态代理的代码（Proxy.newProxyInstance、Enhancer.create）进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

4.1 AOP介绍

切面的三个关键因素：

• 1、切面的功能--切面能干啥
• 2、切面的执行位置--使用Pointcut表示切面执行的位置
• 3、切面的执行时间--使用Advice表示时间，在目标方法之前还是之后执行。

先来介绍AOP的相关术语：

Target(目标对象)：

要被增强的对象，一般是业务逻辑类的对象。比如service

Proxy（代理）：

一个类被 AOP 织入增强后，就产生一个结果代理类。

Aspect(切面)：

表示增强的功能，就是一些代码完成的某个功能，非业务功能。是切入点和通知的结合。比如事务、日志等功能；

Joinpoint(连接点)：

所谓连接点是指那些被拦截到的点。在Spring中，这些点指的是方法（一般是类中的业务方），因为Spring只支持方法类型的连接点。

Pointcut(切入点)：

切入点指声明的一个或多个连接点的集合。通过切入点指定一组方法。

被标记为 final 的方法是不能作为连接点与切入点的。因为最终的是不能被修改的，不能被增强的。

Advice(通知/增强)：

所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。

通知定义了增强代码切入到目标代码的时间点，是目标方法执行之前执行，还是之后执行等。通知类型不同，切入时间不同。

通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

切入点定义切入的位置，通知定义切入的时间

Weaving(织入).：

是指把增强应用到目标对象来创建新的代理对象的过程。 spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

4.2  AspectJ 对 AOP 的实现

对于 AOP 这种编程思想，很多框架都进行了实现。Spring 就是其中之一，可以完成面向切面编程。AspectJ 也实现了 AOP 的功能，且其实现方式更为简捷而且还支持注解式开发。所以，Spring 又将AspectJ 的对于 AOP 的实现也引入到了自己的框架中。

在 Spring 中使用 AOP 开发时，一般使用 AspectJ 的实现方式

AspectJ 是一个优秀面向切面的框架，它扩展了 Java 语言，提供了强大的切面实现。

1，AspectJ的通知类型

AspectJ 中常用的通知有5种类型：前置通知、后置通知、环绕通知、异常通知、最终通知

2，AspectJ的切入点表达式

AspectJ 定义了专门的表达式用于指定切入点。 表达式的原型如下：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

• modifiers-pattern：访问权限类型
• ret-type-pattern： 返回值类型
• declaring-type-pattern： 包名类名
• name-pattern(param-pattern) ：方法名(参数类型和参数个数)
• throws-pattern ：抛出异常类型
• ？表示可选的部分

以上表达式共 4 个部分。

execution(访问权限 方法返回值 方法声明(参数) 异常类型)

切入点表达式要匹配的对象就是目标方法的方法名。所以，execution 表达式中就是方法的签名。

PS:表达式中黑色文字表示可省略部分，各部分间用空格分开。在其中可以使用以下符号：

3，示例

execution(* com.kkb.service.*.*(..)) 
指定切入点为：定义在 service 包里的任意类的任意方法。 

execution(* com.kkb.service..*.*(..)) 
指定切入点为：定义在 service 包或者子包里的任意类的任意方法。“..”出现在类名中时，后面必须跟 “*”，表示包、子包下的所有类。 

execution(* com.kkb.service.IUserService+.*(..)) 
指定切入点为：IUserService 若为接口，则为接口中的任意方法及其所有实现类中的任意方法；若为类，则为该类及其子类中的任意方法。

5，SpringAOP的实现——注解方式

开发阶段：关注核心业务和AOP代码

运行阶段：spring框架会在运行的时候将核心业务和AOP代码通过动态代理的方式编织在一起

代理方式的选择：是否实现了接口：有接口就选择JDK动态代理；没有就选择CGLIB动态代理。

5.1 测试项目的基本结构

1，创建项目引入依赖

    
        
        
            org.springframework
            spring-context
            5.2.13.RELEASE
        
        
            org.springframework
            spring-aspects
            5.2.13.RELEASE
        

        
        
            junit
            junit
            4.12
            test
        
    
    
        
            
            
                org.apache.maven.plugins
                maven-compiler-plugin
                3.8.0
                
                    1.8
                    1.8
                
            
        
    

2，创建spring配置文件spring.xml引入约束

3，创建核心业务类

核心业务接口

public interface IService {
    void add(int id,String name);
    boolean update(int num);
}

核心业务类

public class TeamService implements IService{
    @Override
    public void add(int id, String name) {
       //int num=10/0;
        System.out.println("TeamService---- add----");
    }

    @Override
    public boolean update(int num) {
        System.out.println("TeamService---- update----");
        if(num>666){
            return true;
        }
        return false;
    }
}

4，定义切面类

public class MyAspect {
    public void before() {
        System.out.println("前置通知：在目标方法执行之前被调用的通知");
    }

    public void after() {
        System.out.println("后置通知：在目标方法执行之后被调用的通知");
    }

    public void exception() {
        System.out.println("异常通知：在目标方法执行出现异常被调用的通知");
    }

    public void myFinally() {
        System.out.println("最终通知：无论是否出现异常都是最后被调用的通知");
    }
}

5，定义测试方法

public class TeamServiceTest {
    @Test
    public void test01() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        TeamService teamService = (TeamService) ac.getBean("teamService");
        teamService.add(1001, "永冻队");
        System.out.println("-------------");
        boolean update = teamService.update(1002);
        System.out.println("扫描结果：" + update);
    }
}

运行

原因：没有实现依赖注入

6，通过注解+扫描包的方式实现依赖注入

运行

核心业务没问题，但是没有将切面编织在一起

7，切面对象的创建也交给spring容器处理，并且通过注解标记为切面类，同样也需要通过添加扫描包的方式实现依赖注入

运行

仍然没有将切面内容与核心业务编织在一起，因为还没有定义切面方法切入业务的位置

5.2 前置通知@Before

8，通过注解+切入点表达式指定切入点

运行，发现仍然没有（这里就不贴图了），原因：没有开启AspectJ注解的自动代理

9，开启AspectJ注解的自动代理

运行测试 

5.3 连接点JoinPoint

10，通过连接点JoinPoint，获得拦截到的方法名称及参数列表

5.4 后置通知@AfterReturning

@AfterReturning在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理）

11，在切面类中添加后置通知注解

5.5 异常通知@AfterThrowing

12，添加异常通知注解

5.6 最终通知@After

5.7 环绕通知@Around

13，添加环绕通知（注意参数）

5.8 切入点表达式@Pointcut

为方法添加@Pointcut注解，该方法就可以替代上面的切入点表达式，从而实现表达式复用的效果。

比较简单，直接上代码了

@Component  //切面对象的创建权限依然交给spring容器
@Aspect     //aspectj   框架的注解  标识当前类是一个切面类
public class MyAspect{
    
    @Pointcut("execution(* com.kkb.service..*.*(..))")
    private void pointCut(){

    }
    @Pointcut("execution(* com.kkb.service..*.add*(..))")
    private void pointCut2(){

    }

    
    @Before("pointCut()")
    public void before(JoinPoint jp){
        System.out.println("前置通知：在目标方法执行之前被调用的通知");
        String name = jp.getSignature().getName();
        System.out.println("拦截的方法名称："+name);
        Object[] args = jp.getArgs();
        System.out.println("方法的参数格式："+args.length);
        System.out.println("方法参数列表：");
        for (Object arg : args) {
            System.out.println("t"+arg);
        }
    }
}

6，SpringAOP的实现——XML方式

将上面注解实现的配置，转移到spring的配置文件（比如Spring.xml）中

1，将切面类中关于AspectJ的AOP注解全部删除（保留@AspectJ注解），其中的方法保留参数

@Component  // 切面对象的创建权限依然交给spring容器
@Aspect     // aspectj框架的注解  标识当前类是一个切面类
public class MyAspect {

    public void before(JoinPoint jp) {
        System.out.println("前置通知：在目标方法执行之前被调用的通知");
        // 获取拦截到的方法名称
        String name = jp.getSignature().getName();
        System.out.println("拦截的方法名称："+name);

        // 获取拦截到的方法的参数个数和列表
        Object[] args = jp.getArgs();
        System.out.println("方法的参数格式："+args.length);
        System.out.println("方法参数列表：");
        for (Object arg : args) {
            System.out.println("t"+arg);
        }
    }

    public boolean after(Object result) {
        if (result != null){
            boolean res = (boolean)result;
            result = false;
        }
        System.out.println("后置通知：在目标方法执行之后被调用的通知,result: " + result);
        return (boolean) result;
    }

    public void exception(JoinPoint jp, Throwable ex) {
        System.out.println("异常通知：在目标方法执行出现异常的时候才会别调用的通知，否则不执行");
        System.out.println(jp.getSignature()+"方法出现异常，异常信息是："+ex.getMessage());

    }

    public void myFinally() {
        System.out.println("最终通知：无论是否出现异常都是最后被调用的通知");
    }

    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕方法---目标方法的执行之前");
        Object proceed = pjp.proceed();
        System.out.println("环绕方法---目标方法的执行之后");
        return proceed;
    }
}

2，在spring配置文件中引入aop相关配置