Spring系列（七）AOP的三种实现方式

我不是女神ヾ 2022-11-19 04:26 188阅读 0赞

--------------------

**扩展：**[Spring系列学习汇总][Spring]

--------------------

### 文章目录 ###

*   *   *   *   *  前置条件
                 *  一、通过 Spring API 实现
                 *  二、自定义类来实现
                 *  三、使用注解实现

##### 前置条件 #####

①导入jar

<dependencies>
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.9.4</version>
            </dependency>
        </dependencies>

②配置文件开启aop文件头引用约束

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    </beans>

③抽象接口

public interface UserService { 
        void add();
        void delete();
        void update();
        void selete();
    }

④实现类：

public class UserServiceImpl implements UserService { 
        @Override
        public void add() { 
            System.out.println("增加用户");
        }
    
        @Override
        public void delete() { 
            System.out.println("删除用户");
        }
    
        @Override
        public void update() { 
            System.out.println("更新用户");
        }
    
        @Override
        public void selete() { 
            System.out.println("查询用户");
        }
    }

##### 一、通过 Spring API 实现 #####

①添加前置后置方法

public class AopBeforeConfigLog implements MethodBeforeAdvice { 
    
        /** * method : 要执行的目标对象的方法 * args : 被调用的方法的参数 * target : 目标对象 */
        @Override
        public void before(Method method, Object[] args, Object target) throws Throwable { 
            System.out.println(target.getClass()+"===="+method.getName()+"被执行了");
        }
    }

public class AopAfterConfigLog implements AfterReturningAdvice { 
    
        /** * method : 要执行的目标对象的方法 * args : 被调用的方法的参数 * result : 返回值 * target : 被调用的目标对象 */
    
        @Override
        public void afterReturning(Object result, Method method, Object[] args, Object target){ 
            System.out.println(target.getClass()+"===="+method.getName()+"被执行了"+"===返回值"+result);
        }
    }

②beans.xml

<bean id="userService" class="service.UserServiceImpl"/>
        <bean id="afterLog" class="aoptest.AopAfterConfigLog"/>
        <bean id="beforeAop" class="aoptest.AopBeforeConfigLog"/>
    
        <aop:config>
            
            <aop:pointcut id="cut" expression="execution(* service.UserServiceImpl.*(..))"/>
    
            
            <aop:advisor advice-ref="afterLog" pointcut-ref="cut"/>
            <aop:advisor advice-ref="beforeAop" pointcut-ref="cut"/>
        </aop:config>

③测试类：

public class TestAop { 
        public static void main(String[] args) { 
            ApplicationContext Context = new ClassPathXmlApplicationContext("ContextAplication.xml");
            UserService userService = (UserService) Context.getBean("userService");
            userService.add();
            userService.selete();
            userService.update();
            userService.delete();
        }
    }

④执行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70]

⑤总结：

*  切面：横切的点
 *  通知：切面完成的工作，其实就是一个方法
 *  目标：被通知的对象
 *  `expression="execution(* service.UserServiceImpl.*(..))"`
    
     *  这是一套固定的公式
     *  `*`代表所有
     *  这句话的意思就是service.UserServiceImpl下的所有方法都被切面了！

##### 二、自定义类来实现 #####

①自定义`被切入`类

/* * 自定义类 * */
    public class MyDIYAopCut { 
        public void before(){ 
            System.out.println("方法执行前前前前前前前前前前");
        }
        public void after(){ 
            System.out.println("方法执行后后后后后后后后后后");
        }
    }

②beans.xml

<bean id="userService" class="service.UserServiceImpl"/>
        <bean id="Mydiycut" class="diyaop.MyDIYAopCut"/>
    
        <aop:config>
            
            <aop:aspect ref="Mydiycut">
                
                <aop:pointcut id="cut" expression="execution(* service.UserServiceImpl.*(..))"/>
    
                
                <aop:before method="before" pointcut-ref="cut"/>
                
                <aop:before method="after" pointcut-ref="cut"/>
            </aop:aspect>
        </aop:config>

③测试类不变，执行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 1]

④总结：

*  测试类的方法即是xml中method的方法名  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 2]
 *  其他见xml中的注释！

##### 三、使用注解实现 #####

①自定义增强注解实现类

@Aspect
    public class MyAnnotationAopCut { 
        @Before("execution(* service.UserServiceImpl.*(..))")
        public void before(){ 
            System.out.println("方法执行前");
        }
        @After("execution(* service.UserServiceImpl.*(..))")
        public void after(){ 
            System.out.println("方法执行后");
        }
        @Around("execution(* service.UserServiceImpl.*(..))")
        public void around(ProceedingJoinPoint point) throws Throwable { 
            System.out.println("环绕前=="+point.getSignature());
            //执行
            Object proceed = point.proceed();
            System.out.println("环绕后=="+point.getSignature());
        }
    }

②xml

<bean id="userService" class="service.UserServiceImpl"/>
        <bean id="myAnnotationAopCut" class="diyaop.MyAnnotationAopCut"/>
        
        <aop:aspectj-autoproxy proxy-target-class="false"/>

③测试类一致，执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 3]

④总结：

*  `proxy-target-class="false"`
    
     *  false 是以jdk实现动态代理
     *  true 是以CGLib实现动态代理
     *  这玩意我们一般使用默认机制，了解，知道有这么个玩意即可！
 *  `@Aspect`：把当前类标识为一个切面供容器读取
 *  `@Before`：方法执行前
 *  `@After`：方法执行后
 *  `@Around`：环绕式执行
    
     *  `ProceedingJoinPoint`：环绕通知=前置+目标方法执行+后置通知。proceed方法就是用于启动目标方法执行的
     *  就是必须得使用proceed(),相当于中间点，这样程序才能知道哪个是before哪个是after！

--------------------

***路漫漫其修远兮，吾必将上下求索~***  
如果你认为i博主写的不错！写作不易，请点赞、关注、评论给博主一个鼓励吧\*\*转载请注明出处哦\*\*

[Spring]: https://blog.csdn.net/weixin_43829443/article/details/115354124?spm=1001.2014.3001.5502
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70]: /images/20221022/394b68cf23cd4eedaf4a1b3c25ef51cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 1]: /images/20221022/b4671d95eb8446628efa7019f9eb9aca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 2]: /images/20221022/cb570a541c5d4b32b2240de0adcf5163.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70 3]: /images/20221022/bf012c99ffa54e4989a6994dfff80fa3.png