spring实现AOP

客官°小女子只卖身不卖艺 2024-03-27 15:43 52阅读 0赞

#### 文章目录 ####

*  前言
 *  一、AOP的底层实现原理
 *  二、AOP的两种开发模式
 *   *  1.使用xml配置文件
     *   *  1.1 添加AOP依赖
         *  1.2 创建UserService
         *  1.3创建UserServiceImpl
         *  1.4创建通知类
         *  1.5 创建applicationContext.xml（添加aop约束）
         *  1.6 测试
     *  2.使用注解开发
     *   *  2.1 创建bean.xml文件配置注解方式
         *  2.2 在通知类上使用相关注解
         *  2.3 测试
 *  总结

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

## 前言 ##

spring的核心是IOC（控制反转）和AOP（面向切面编程）。AOP面向切面编程是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

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

## 一、AOP的底层实现原理 ##

此处再解释，详情请看我这篇文章  
[静态代理和动态代理https://blog.csdn.net/l\_zl2021/article/details/127095878][https_blog.csdn.net_l_zl2021_article_details_127095878]

## 二、AOP的两种开发模式 ##

关于AOP的案例，看我这边篇文章，本文只是记录两种AOP开发方式  
[AOP初识https://blog.csdn.net/l\_zl2021/article/details/127113425][AOP_https_blog.csdn.net_l_zl2021_article_details_127113425]

### 1.使用xml配置文件 ###

#### 1.1 添加AOP依赖 ####

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.20</version>
        </dependency>
    
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.9.1</version>
        </dependency>
    
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>compile</scope>
        </dependency>
    
    </dependencies>

#### 1.2 创建UserService ####

package com.wmj.service;
    
    //目标对象target
    public interface UserService {
        
        //未增强的方法叫做连接点JoinPoint
        //已增强的方法叫做切入点PointCut
        public void add();
    
        public void delete();
    }

#### 1.3创建UserServiceImpl ####

代码如下（示例）：

package com.wmj.service.impl;
    
    import com.wmj.service.UserService;
    
    public class UserServiceImpl implements UserService {
        
        @Override
        public void add() {
        
            System.out.println("添加用户..");
            //int i = 1/0;
        }
    
        @Override
        public void delete() {
        
            System.out.println("删除用户..");
        }
    }

#### 1.4创建通知类 ####

> 前置通知(before)：目标方法运行之前调用  
> 后置通知(after-returning)：在目标方法运行之后调用 (如果出现异常不会调用)  
> 环绕通知(around)：在目标方法之前和之后都调用(ProceedingJoinPoint对象 -->> 调用proceed方法)  
> 异常拦截通知(after-throwing)：如果出现异常,就会调用  
> 最终通知(after)：在目标方法运行之后调用 (无论是否出现 异常都会调用)

package com.wmj.advice;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    
    //通知类，增强的代码（方法）Advice
    public class MyAdvice {
        
    
        public void before(){
        
            System.out.println("前置通知，目标对象调用方法前执行");
        }
    
        public void after(){
        
            System.out.println("后置通知（最终通知），目标对象调用方法后执行，无论是否发生异常都执行");
        }
    
        public void after_returning(){
        
            System.out.println("后置通知，目标对象调用方法后执行，发生异常不执行");
        }
    
        public void after_throwing(){
        
            System.out.println("异常通知，发生异常执行");
        }
    
        public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        
            System.out.println("环绕通知，目标对象调用方法之前");
            joinPoint.proceed();
            System.out.println("环绕通知，目标对象调用方法之后");
        }
    
    }

#### 1.5 创建applicationContext.xml（添加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"> 
    
            <bean id="userService" class="com.wmj.service.impl.UserServiceImpl"></bean>
    
            
            <bean id="myAdvice" class="com.wmj.advice.MyAdvice"></bean>
    
            
            
            
            <aop:config proxy-target-class="true">
                    
    
    
               
                		
    
                    <aop:pointcut id="pc" expression="execution(* com.wmj.service.impl.*ServiceImpl.*(..))"/>
                    
                    <aop:aspect ref="myAdvice">
                            
                            <aop:before method="before" pointcut-ref="pc"></aop:before>
                            
                            <aop:after method="after" pointcut-ref="pc"></aop:after>
                            
                            <aop:after-returning method="after_returning" pointcut-ref="pc"></aop:after-returning>
                            
                            <aop:after-throwing method="after_throwing" pointcut-ref="pc"></aop:after-throwing>
                            
                            <aop:around method="around" pointcut-ref="pc"></aop:around>
                    </aop:aspect>
            </aop:config>
    
    </beans>

#### 1.6 测试 ####

package com.wmj.test;
    
    import com.wmj.service.UserService;
    import org.junit.Test;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class SpringTest {
        
    
        @Test
        public void testUserService(){
        
    
            ClassPathXmlApplicationContext applicationContext =
                    new ClassPathXmlApplicationContext("applicationContext.xml");
    
            UserService userService = (UserService)applicationContext.getBean("userService");
    
            userService.add();
            userService.delete();
        }
    
    }

### 2.使用注解开发 ###

#### 2.1 创建bean.xml文件配置注解方式 ####

#### 2.2 在通知类上使用相关注解 ####

@Aspect
    //表示该类是一个通知类
    //通知类，增强的代码（方法）Advice
    public class MyAdvice {
        
    
        //自己设置一个切点，管理重复代码
    	@Pointcut("execution(* com.wmj.service.impl.*ServiceImpl.*(..))")
    	public void pc(){
        }
        
    	//前置通知
    	//指定该方法是前置通知,并制定切入点
    	@Before("MyAdvice.pc()")
        public void before(){
        
            System.out.println("前置通知，目标对象调用方法前执行");
        }
    
        //最终通知
    	@After("execution(* com.wmj.service.impl.*ServiceImpl.*(..))")
        public void after(){
        
            System.out.println("后置通知（最终通知），目标对象调用方法后执行，无论是否发生异常都执行");
        }
    
        //后置通知
    	@AfterReturning("execution(* com.wmj.service.impl.*ServiceImpl.*(..))")
        public void after_returning(){
        
            System.out.println("后置通知，目标对象调用方法后执行，发生异常不执行");
        }
    
        //异常通知
    	@AfterThrowing("execution(* com.wmj.service.impl.*ServiceImpl.*(..))")
        public void after_throwing(){
        
            System.out.println("异常通知，发生异常执行");
        }
    
        //环绕通知
    	@Around("execution(* com.wmj.service.impl.*ServiceImpl.*(..))")
        public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        
            System.out.println("环绕通知，目标对象调用方法之前");
            joinPoint.proceed();
            System.out.println("环绕通知，目标对象调用方法之后");
        }
    
    }

#### 2.3 测试 ####

@Test
    public void testUserService(){
        
    
        ClassPathXmlApplicationContext applicationContext =
            new ClassPathXmlApplicationContext("bean.xml");
    
        UserService userService = (UserService)applicationContext.getBean("userService");
    
        userService.add();
        userService.delete();
    }

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

## 总结 ##

本文记录了两种开发AOP编程的方式

[https_blog.csdn.net_l_zl2021_article_details_127095878]: https://blog.csdn.net/l_zl2021/article/details/127095878
[AOP_https_blog.csdn.net_l_zl2021_article_details_127113425]: https://blog.csdn.net/l_zl2021/article/details/127113425