【Spring】009-AOP

蔚落 2023-10-05 09:37 27阅读 0赞

# 一、什么是AOP #

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70][]

# 二、Aop在Spring中的作用 #

提供声明式事务；允许用户自定义切面；

以下名词需要了解下：

*  横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
 *  切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
 *  通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
 *  目标（Target）：被通知对象。
 *  代理（Proxy）：向目标对象应用通知之后创建的对象。
 *  切入点（PointCut）：切面通知 执行的 “地点”的定义。
 *  连接点（JointPoint）：与切入点匹配的执行点。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 1][]

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 2][]

即 Aop 在 不改变原有代码的情况下 , 去增加新的功能（就是代理模式的功能）；

# 三、使用Spring的AIP接口实现AOP #

## 1、依赖的Maven坐标 ##

<dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
        <scope>runtime</scope>
    </dependency>

## 2、代码演示 ##

### 第一步：新建一个Moudle，在pom.xml导入AOP所依赖的Maven坐标 ###

### 第二步：创建一个UserService接口 ###

package com.zibo.service;
    
    public interface UserService {
        void add();
        void delete();
        void update();
        void select();
    }

### 第三步：写一个UserService接口的实现类 ###

package com.zibo.service;
    
    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 select() {
            System.out.println("查询了一个用户");
        }
    }

### 第四步：定义一个日志类 ###

package com.zibo.log;
    
    import org.springframework.aop.MethodBeforeAdvice;
    import org.springframework.lang.Nullable;
    
    import java.lang.reflect.Method;
    
    public class Log implements MethodBeforeAdvice {
        /**
         * 方法执行之前执行的方法，也就是传说中的前置通知
         * @param method 要执行的方法
         * @param args 给要执行的方法所传的参数
         * @param target 代理对象
         * @throws Throwable 异常
         */
        @Override
        public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
            assert target != null;
            System.out.println(target.getClass().getName() + "类的" + method.getName() + "方法要执行了！");
        }
    }

### 第五步：让我们再写一个日志类 ###

package com.zibo.log;
    
    import org.springframework.aop.AfterReturningAdvice;
    
    import java.lang.reflect.Method;
    
    public class LogAfter implements AfterReturningAdvice {
        /**
         * 方法执行之后执行的方法，也就是传说中的后置通知
         * @param returnValue 要执行的方法的返回值
         * @param method 要执行的方法
         * @param args 给要执行的方法所传的参数
         * @param target 代理对象
         * @throws Throwable 异常
         */
        @Override
        public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
            System.out.println("执行了" + method.getName() + "方法，返回结果为：" + returnValue);
        }
    }

### 第六步：创建配置文件applicationContext.xml ###

### 第七步：编写测试类 ###

package com.zibo;
    
    import com.zibo.service.UserService;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class MyTest {
        public static void main(String[] args) {
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            UserService service = context.getBean("userService", UserService.class);
            service.add();
        }
    }

### 测试结果： ###

com.zibo.service.UserServiceImpl类的add方法要执行了！
    添加了一个用户
    执行了add方法，返回结果为：null

# 四、使用自定义类实现AOP #

### 第一步：自定义DIYPointCut类 ###

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

### 第二步：修改配置文件applicationContext.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: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.zibo.service.UserServiceImpl"/>
        <bean id="log" class="com.zibo.log.Log"/>
        <bean id="logAfter" class="com.zibo.log.LogAfter"/>
        
        
    
    
    
    
    
    
    
        
        <bean id="diy" class="com.zibo.diy.DIYPointCut"/>
        <aop:config>
            
            <aop:aspect ref="diy">
                
                <aop:pointcut id="pointcut" expression="execution(* com.zibo.service.UserServiceImpl.*(..))"/>
                
                <aop:before method="before" pointcut-ref="pointcut"/>
                <aop:after method="after" pointcut-ref="pointcut"/>
            </aop:aspect>
        </aop:config>
    </beans>

### 测试结果： ###

======方法执行前======
    添加了一个用户
    ======方法执行后======

# 五、注解实现AOP #

### 第一步：修改pom.xml ###

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>StudySpring</artifactId>
            <groupId>org.example</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>spring_009_aop</artifactId>
        <dependencies>
            
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjrt</artifactId>
                <version>1.9.6</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.9.6</version>
                <scope>runtime</scope>
            </dependency>
    
            
            <dependency>
                <groupId>cglib</groupId>
                <artifactId>cglib</artifactId>
                <version>3.3.0</version>
            </dependency>
    
        </dependencies>
    
    </project>

### 第二步：修改配置文件applicationContext.xml ###

### 第三步：再自定义一个DIYPointCut类 ###

package com.zibo.diy;
    
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    
    @Aspect //标准这个类是一个切面
    public class DIYPointCut2 {
        @Before("execution(* com.zibo.service.UserServiceImpl.*(..))")
        public void before(){
            System.out.println("======方法执行前======");
        }
        @After("execution(* com.zibo.service.UserServiceImpl.*(..))")
        public void after(){
            System.out.println("======方法执行后======");
        }
    }

### 测试结果： ###

======方法执行前======
    添加了一个用户
    ======方法执行后======

### 那咱就也玩玩环绕通知： ###

package com.zibo.diy;
    
    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 DIYPointCut2 {
        @Before("execution(* com.zibo.service.UserServiceImpl.*(..))")
        public void before(){
            System.out.println("======方法执行前======");
        }
        @After("execution(* com.zibo.service.UserServiceImpl.*(..))")
        public void after(){
            System.out.println("======方法执行后======");
        }
        @Around("execution(* com.zibo.service.UserServiceImpl.*(..))")
        public void around(ProceedingJoinPoint jp) throws Throwable{
            System.out.println("环绕前");
            System.out.println("签名:"+jp.getSignature());
            //执行目标方法proceed
            Object proceed = jp.proceed();
            System.out.println("环绕后");
            System.out.println(proceed);
        }
    }

### 测试结果： ###

环绕前
    签名:void com.zibo.service.UserService.add()
    ======方法执行前======
    添加了一个用户
    环绕后
    null
    ======方法执行后======

### 说明： ###

通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了；

<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理；

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200904190434321.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200904190958201.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200904191034872.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5Njg5MzQz,size_16,color_FFFFFF,t_70