彻底整垮Aop面向切面编程的原理和使用

傷城~ 2024-04-06 13:00 14阅读 0赞

#### AOP面向切面 ####

*  一、AOP面向切面
 *   *  1、概念
     *  2、怎么理解面向切面
     *  3、切面关键三要素
     *  4、术语
     *  5、Aop基于动态代理
 *  二、Aop的实现
 *  三、aspectj框架的使用
 *  四、开发过程
 *  五、JoinPoint说明
 *  六、 @AfterReturning后置通知
 *  七、环绕通知@Around （重点）
 *  八、aop知识点总结

## 一、AOP面向切面 ##

### 1、概念 ###

简单的讲就是：
    1、给你的目标类增加功能，就是切面，比如日志，事务
    2、他独立于业务逻辑之外，独立使用的，非业务功能

### 2、怎么理解面向切面 ###

1、分析项目功能时，找出切面
    2、合理安排切面的执行时间（在目标方法前，还是后）
    3、合理安排切面的位置，在哪个类，哪个方法增加增强功能

### 3、切面关键三要素 ###

1、切面的功能代码，切面干什么  
2、切面执行的位置，使用Pointcut表示切面执行的位置  
3、切面执行的时间，使用advice表示时间，在目标方法之前，还是之后执行

### 4、术语 ###

1、Aspect ：切面，表示增强的功能，就是一堆代理 ，完成一个功能，非业务功能，常见的有日志，事务  
2、JoinPoint 连接点，连接业务方法和切面的位置，就是某个类中的业务方法  
3、Pointcut 切入点，指多个连接点方法的集合，多个方法  
4、目标对象：给哪个类的方法增加功能，这个类就是目标对象  
5、Advice通知，表示切面功能执行的时间

### 5、Aop基于动态代理 ###

AOP 是基于动态代理技术的，主要有两种方式
    1、JDK动态代理，使用jdk提供的Proxy，method，invocationhandle来创建代理对象，
    目标类必须要实现接口
    2、CGLIB动态代理，主要原理是通过继承来实现
    
    好处：
    1、在不改变目标类源代码情况下，增加概念
    2、减少代码的重复
    3、专注于业务逻辑代码
    4、解耦合，业务功能和日志，事务分离

## 二、Aop的实现 ##

aop技术实现框架：
    1、spring，内部实现了aop规范，

![在这里插入图片描述][4e9083a258514c4f9b073b31d757897c.png]

spring主要在事务处理时，使用到了aop，但是spring的aop比较笨重
    
    2、aspectj	一个开源的专门做aop的框架，spring框架中集成了aspectj框架，通过spring就能使用aspectj框架功能
    aspectj实现aop的两种方式：
    （1）使用xml配置
    （2）使用注解，aspectj主要有5个注解

## 三、aspectj框架的使用 ##

1、切面执行的时间，即 Advice ，通知或增强
    1）、@Before
    2）、@AfterReturning
    3）、@Around
    4）、@AfterThrowing
    5）、@After
    
    2、切面执行的位置，使用切入点表达式，即 ：
    execution(访问权限  方法返回值 方法声明（参数） 异常类型)

![在这里插入图片描述][c563b00dc6a941b988c92be8eed69a67.png]  
![在这里插入图片描述][1313a2a30915472a8b71a6bc7cf0cec1.png]

注意：表达式中 方法返回值 方法声明（参数）必须要有

## 四、开发过程 ##

1、步骤
    a、创建maven项目
    b、加入依赖：spring依赖和aspectj依赖
    c、加入juinit单元测试
    d、创建目标类：接口和实现类，给他的方法增强功能
    e、创建切面类，在类中定义方法，方法就是切面要执行的功能代码，
    	在方法的上面加入aspectj中的通知注解，例如@Before，有需要指定切入点表达式execution（）
    f、在spring的xml文件中进行配置

创建切面类MyAspect

package com.ba01;
    
    
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    
    import java.util.Date;
    
    /**
     * 表示当前类为切面类
     * 定义在类上面
     */
    @Aspect
    public class MyAspect {
        
    
        /**
         * 定义方法：公共无返回值，
         */
    
    //    @Before(value = "execution(public void com.ba01.SomeServiceImpl.doSome(String,Integer))")
        @Before(value = "execution(* doSome(..))")
        public void mybefore(){
        
            System.out.println("前置通知，在目标方法之前输出执行时间：" + new Date());
        }
    }

目标类接口及实现类

package com.ba01;
    
    public interface SomeService {
        
        public void doSome(String name,Integer age);
        public void doOther(String name,Integer age);
    }

package com.ba01;
    
    import com.ba01.SomeService;
    import org.springframework.stereotype.Component;
    
    @Component
    public class SomeServiceImpl implements SomeService{
        
    
        @Override
        public void doOther(String name, Integer age) {
        
            System.out.println("====doOther方法===========");
        }
        @Override
        public void doSome(String name, Integer age) {
        
            System.out.println("====dosome方法===========");
        }
    }

spring的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"
           xmlns:aop="http://www.springframework.org/schema/aop"
           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 http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    
        
        <bean id="someService" class="com.ba01.SomeServiceImpl"/>
        
        <bean id="myAspect" class="com.ba01.MyAspect"/>
    
        
        <aop:aspectj-autoproxy/>
    </beans>

测试类泡一下

public class AppTest
    {
        
        @Test
        public void shouldAnswerWithTrue()
        {
        
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
            SomeService someService =  (SomeService) context.getBean("someService");
            someService.doOther("jack",20);
        }
    }

执行结果

前置通知，在目标方法之前输出执行时间：Mon Sep 26 07:14:25 GMT+08:00 2022
    ====dosome方法===========
    
    Process finished with exit code 0

额外小知识点补充：
    （1）execution表达式的多种写法：

@Before(value = "execution(public void com.ba01.SomeServiceImpl.doSome(String,Integer))")这个为完整写法，
    	也可以这样
    	@Before(value = "execution(* doSome(..))")，
    	或者 @Before(value = "execution(public * doSome(..))")
    	或者 @Before(value = "execution(* *(..))")都可以的
    	或者 @Before(value = "execution(void *..SomeServiceImpl.doSome(..))")

（2）执行方法，我们发现程序底层使用的是jdk的动态代理

someService.getClass().getName()//com.sun.proxy.$Proxy11

（3）通过代理生成器，即 aop:aspectj-autoproxy，创建目标对象的代理对象，创建的代理对象是在内存中实现的，修改目标对象在内存中的结构

## 五、JoinPoint说明 ##

**作用是：**

JoinPoint: 业务方法，要加入切面功能的业务方法
    可以在通知方法中获取方法执行时的信息，例如方法的名称，方法的实参
    如果你的切面功能能中需要使用到方法的信息，就加入JoinPoint
    这个JoinPoint参数的值是由框架赋予的
    JoinPoint在方法参数列表里面，必须位于第一位

@Before(value = "execution(* *(..))")
        public void mybefore(JoinPoint point){
        
            System.out.println("方法的签名=" +point.getSignature());
            System.out.println("方法的名称=" +point.getSignature().getName());
            Object[] args = point.getArgs();
            for (Object arg : args) {
        
                System.out.println("参数=" + arg);
            }
            System.out.println("前置通知，在目标方法之前输出执行时间：" + new Date());
        }

方法的签名=void com.ba01.SomeService.doSome(String,Integer)
    方法的名称=doSome
    参数=jack
    参数=20
    前置通知，在目标方法之前输出执行时间：Tue Sep 27 06:28:05 GMT+08:00 2022
    前置通知，在目标方法之前输出执行时间：Tue Sep 27 06:28:05 GMT+08:00 2022
    ====dosome方法===========
    com.sun.proxy.$Proxy11
    
    Process finished with exit code 0

## 六、 @AfterReturning后置通知 ##

特点：
    1、在目标方法之后执行
    2、可以获取到目标方法的返回值，可以根据这个返回值做不同的处理功能
    3、可以修改返回值

切面类：

@Aspect
    public class MyAspect {
        
    
    
        @AfterReturning(value = "execution(* *(..))",returning = "res")
        public void myafterReturning(Object res){
        
            //res 就是目标方法的返回值
            System.out.println("后置通知：在目标方法之后执行的，获取返回值结果：" + res);
        }
    }

测试类：

package com.mr.lee;
    
    import com.ba01.SomeService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class AppTest
    {
        
        @Test
        public void shouldAnswerWithTrue()
        {
        
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
            SomeService someService =  (SomeService) context.getBean("someService");
            someService.doOther("jack",20);
            System.out.println(someService.getClass().getName());//com.sun.proxy.$Proxy11
        }
    }

执行结果：

====doOther方法===========
    后置通知：在目标方法之后执行的，获取返回值结果：abcd
    com.sun.proxy.$Proxy11
    
    Process finished with exit code 0

也可以加上joinPoint参数，但是必须位于第一位

@AfterReturning(value = "execution(* *(..))",returning = "res")
        public void myafterReturning(JoinPoint joinPoint, Object res){
        
            //res 就是目标方法的返回值
            System.out.println("后置通知：在目标方法之后执行的，获取返回值结果：" + res);
        }

## 七、环绕通知@Around （重点） ##

格式：

必须有返回值，推荐使用Object
    方法名自定义
    方法有参数，固定的参数

特点：

1、是功能最强的通知
    2、在目标方法前后都能增强功能
    3、控制目标方法是否调用执行
    4、修改原来目标方法执行的结果

额外补充：

环绕通知 相当于 JDK动态代理的invocationHandler接口	
    
    参数 ProceedingJoinPoint ，用来执行目标方法的，相当于JDK动态代理的Method类
    
    环绕通知经常用来做事务的处理
    
    上代码：

package com.ba01;
    
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    
    import java.util.Date;
    
    @Aspect
    public class MyAspect {
        
        @Around(value = "execution(* *(..))")
        public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
        
            Object object = null;
            System.out.println("环绕通知，在目标方法之前调用，输出时间，" + new Date());
    
            //1、可以控制目标方法的执行
            String name = "";
            Object[] args = joinPoint.getArgs();
            if(args != null && args.length > 1){
        
                name = (String) args[0];
            }
            if(!"zhangshan".equals(name)){
        
                //2、目标方法的调用
                object = joinPoint.proceed();//相当于method.invoke();
            }
            System.out.println("环绕通知，在目标方法之后调用，输出时间，" + new Date());
            //3、可以直接修改方法的返回值
            object = "1234werqwe";
            return object;
        }
    }

测试一下

package com.mr.lee;
    
    import com.ba01.SomeService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class AppTest
    {
        
        @Test
        public void shouldAnswerWithTrue()
        {
        
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
            SomeService someService =  (SomeService) context.getBean("someService");
            String res = someService.doOther("jack",20);
            System.out.println(res);
        }
    }

运行结果：

环绕通知，在目标方法之前调用，输出时间，Tue Sep 27 07:04:47 GMT+08:00 2022
    ====doOther方法===========
    环绕通知，在目标方法之后调用，输出时间，Tue Sep 27 07:04:47 GMT+08:00 2022
    1234werqwe
    
    Process finished with exit code 0

## 八、aop知识点总结 ##

![在这里插入图片描述][93247f3c124549dda40d77f024da332b.png]

[4e9083a258514c4f9b073b31d757897c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/23f0c30ea2a94c8692343a261d58b773.png
[c563b00dc6a941b988c92be8eed69a67.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/2878a238e65946608fde14bf8fd5bc13.png
[1313a2a30915472a8b71a6bc7cf0cec1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/f3fbb4a84b7a46ad94b3e3bc5d1e9d18.png
[93247f3c124549dda40d77f024da332b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/a8ffe3a204fd4adaba35b3e8e1a11ca4.png