【AOP简述】

怼烎@ 2024-03-22 11:16 49阅读 0赞

### AOP是什么 ###

（Aspect Oriented Programming 即：面向切面编程。）它是一种程序设计范型，同时也是一种程序架构模式，也是函数式编程的衍生范型。简单地说它可以让我们将业务与非业务的代码分离，实现低耦合，即就是把我们程序重复的代码抽取出来，之后在需要用到的地方直接切入业务代码中，无需修改原有的代码。

### AOP在Spring中的作用 ###

![在这里插入图片描述][69f9de61f3754807b8c43fe03ed15bf1.png]

### 使用Spring实现AOP ###

【重点】使用AOP，需要导包

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.9.1</version>
        </dependency>

### 方式一：使用原生Spring API接口 ###

将主体作为切入点，将其他需要添加的内容另外编写类，并且连接到切入点，实现低耦合

**MethodBeforeAdvice**

package com.canso.log;
    import org.springframework.aop.MethodBeforeAdvice;
    import java.lang.reflect.Method;
    public class Log implements MethodBeforeAdvice {
        
        //method：要执行的目标对象的方法
        //args：参数
        //target：目标对象
        @Override
        public void before(Method method, Object[] args, Object target) throws Throwable {
        
            System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
        }
    }

**AfterLog**

package com.canso.log;
    import org.springframework.aop.AfterReturningAdvice;
    import java.lang.reflect.Method;
    public class AfterLog implements AfterReturningAdvice {
        
        //returnValue返回结果
        @Override
        public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        
            System.out.println("执行了"+method.getName()+"返回结果为："+returnValue);
        }
    }

<?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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/aop
            https://www.springframework.org/schema/aop/spring-aop.xsd">
    
        
        <bean id="userService" class="com.canso.service.UserServiceImpl"/>
        <bean id="log" class="com.canso.log.Log"/>
        <bean id="afterLog" class="com.canso.log.AfterLog"/>
    
        
        
        <aop:config>
            
            <aop:pointcut id="pointcut" expression="execution(* com.canso.service.UserServiceImpl.*(..))"/>
    
            
            <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
            <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
        </aop:config>
    </beans>

### 方式二：自定义实现 ###

package com.canso.diy;
    
    public class DiyPointCut {
        
        public void before(){
        
            System.out.println("==方法执行前==");
        }
        public void after(){
        
            System.out.println("==方法执行后==");
        }
    }

<bean id="diy" class="com.canso.diy.DiyPointCut"/>
    
        <aop:config>
    
            <aop:aspect ref="diy">
    
                <aop:pointcut id="point" expression="execution(* com.canso.service.UserServiceImpl.*(..))"/>
    
                <aop:before method="before" pointcut-ref="point"/>
                <aop:after method="after" pointcut-ref="point"/>
            </aop:aspect>
        </aop:config>

### 方式三：使用注解实现 ###

package com.canso.diy;
    //使用注解方式实现AOP
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    
    @Aspect//标注该类为一个切面
    public class AnnotationPointCut {
        
    
        @Before("execution(* com.canso.service.UserServiceImpl.*(..))")
        public void before(){
        
            System.out.println("方法执行前");
        }
        @After("execution(* com.canso.service.UserServiceImpl.*(..))")
        public void after(){
        
            System.out.println("方法执行后");
        }
        //在环绕增强中，可以传入参数，代表获取处理切入的点
        @Around("execution(* com.canso.service.UserServiceImpl.*(..))")
        public void around(ProceedingJoinPoint jp) throws Throwable {
        
            System.out.println("环绕前");
            //执行方法
            Object proceed = jp.proceed();
    
            System.out.println("环绕后");
        }
    }

<bean id="annotationPointCut" class="com.canso.diy.AnnotationPointCut"/>
    
        <aop:aspectj-autoproxy/>

[69f9de61f3754807b8c43fe03ed15bf1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/5805766ad5c941e8be750744c23295b8.png