• Spring5入门到实战------10、操作术语解释--Aspectj注解开发实例。AOP切面编程的实际应用

    1、操作术语

    1.1、连接点

    类里面哪些方法可以被增强、这些方法被称为连接点。比如：用户控制层有登录、注册、修改密码、修改信息等方法。假如只有登录类和注册类可以被增强，登录和注册方法就称为连接点

    1.2、切入点

    实际被真正增强的方法，称为切入点。假如登录方法被正真增强（登陆前做些权限验证之类的、假设原始方法只是查询数据库、无权限认证过程）、登录方法又称为切入点。

    1.3、通知（增强）

    实际增强的逻辑部分称为通知（增强）。你编写的新的业务逻辑、比如在登录前进行的权限认证操作。

    通知有多种类型

    • 前置通知
    • 后置通知
    • 环绕通知
    • 异常通知
    • 最终通知

    1.4、切面

    把通知应用到切入点过程。你编写的业务逻辑（通知）如何加入到之前的方法（切入点）

    2、准备工作和如何使用

    友情提示：如果直接建立spring项目、则不需要进行这一步
    2.1

    2.1 jar包引入

    1、Spring 框架一般都是基于 AspectJ 实现 AOP 操作

    • AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP 操作

    2、基于 AspectJ 实现 AOP 操作

    • 基于 xml 配置文件实现
    • 基于注解方式实现（使用）

    3、在项目工程里面引入 AOP 相关依赖
    在这里插入图片描述

    2.2、切入点表达式（具体使用）

    （1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )

    • 1
    • 2

    例子

    举例 1：对 com.zyz.dao.BookDao 类里面的 add 进行增强
execution(* com.zyz.dao.BookDao.add(..))

举例 2：对 com.zyz.dao.BookDao 类里面的所有的方法进行增强
execution(* com.zyz.dao.BookDao.* (..))

举例 3：对 com.zyz.dao 包里面所有类，类里面所有方法进行增强
execution(* com.zyz.dao.*.* (..))

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3、代码实战

    3.1 User .java

    一个类里边的基本方法。 使用注解@Component创建 User 对象。

    /**
 * @author Lenovo
 * @version 1.0
 * @data 2022/10/20 22:16
 */
@Component
public class User {
    public void add(){
//        int a = 1/0;
        System.out.println("add......");
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    3.2 UserProxy .java

    1、代理类中进行方法的增强。
    2、使用注解@Component创建 UserProxy 对象。
    3、在增强类上面添加注解 @Aspec。
    4、增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

    /**
 * 增强的类
 * @author Lenovo
 * @version 1.0
 * @data 2022/10/20 22:19
 */
@Component
@Aspect//生成代理对象
public class UserProxy {

    /**
     * 1、前置通知
     */
    @Before(value = "execution(* com.zyz.spring5.aop.User.add(..))")
    public void before(){
        System.out.println("before。。。。。。");
    }

    /**
     * 2、后置通知
     */
    @AfterReturning(value = "execution(* com.zyz.spring5.aop.User.add(..))")
    public void afterReturnning(){
        System.out.println("afterReturnning。。。。。。");
    }


    /**
     * 3、最终通知
     */
    @After(value = "execution(* com.zyz.spring5.aop.User.add(..))")
    public void after(){
        System.out.println("after。。。。。。");
    }

    /**
     * 4、异常通知
     */
    @AfterThrowing(value = "execution(* com.zyz.spring5.aop.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing。。。。。。");
    }

    /**
     * 5、环绕通知
     * @param proceedingJoinPoint
     * @throws Throwable
     */
    @Around(value = "execution(* com.zyz.spring5.aop.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前。。。。。。。");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后。。。。。。。");
    }


}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59

    3.3 bean.xml

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

    
    <context:component-scan base-package="com.zyz.spring5.aop">context:component-scan>

    
    <aop:aspectj-autoproxy>aop:aspectj-autoproxy>


beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    3.4 测试类

    /**
 * @author Lenovo
 * @version 1.0
 * @data 2022/10/20 22:38
 */
public class Test {

    @org.junit.Test
    public void testDemo(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        User user = context.getBean("user", User.class);
        user.add();

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    3.5 测试结果

    在这里插入图片描述
    在这里插入图片描述

    4、优化代码

    4.1 相同的切入点抽取

    仔细看代码不难发现、耦合性很高。比如增强的方法类的位置移动。那么所有增强的表达式中的路径也要一个一个改动（3.2 UserProxy.java）

    相同的切入点抽取、达到复用的效果。可以只需要改动少量的代码、完成相同的事情。便于后期的维护

    /**
 * 增强的类
 * @author Lenovo
 * @version 1.0
 * @data 2022/10/20 22:19
 */
@Component
@Aspect//生成代理对象
public class UserProxy {
    /**
     * 相同切入点抽取
     */
    @Pointcut(value = "execution(* com.zyz.spring5.aop.User.add(..))")
    public void pointDemo(){}


    /**
     * 1、前置通知
     */
    @Before(value = "pointDemo()")
    public void before(){
        System.out.println("before。。。。。。");
    }

    /**
     * 2、后置通知
     */
    @AfterReturning(value = "pointDemo()")
    public void afterReturnning(){
        System.out.println("afterReturnning。。。。。。");
    }


    /**
     * 3、最终通知
     */
    @After(value = "pointDemo()")
    public void after(){
        System.out.println("after。。。。。。");
    }

    /**
     * 4、异常通知
     */
    @AfterThrowing(value = "pointDemo()")
    public void afterThrowing(){
        System.out.println("afterThrowing。。。。。。");
    }

    /**
     * 5、环绕通知
     * @param proceedingJoinPoint
     * @throws Throwable
     */
    @Around(value = "pointDemo()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前。。。。。。。");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后。。。。。。。");
    }


}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65

    4.2 有多个增强类多同一个方法进行增强，设置增强类优先级

    @Order(1)数字越小优先级越高

    @Component
@Aspect
@Order(1)
public class UserProxy1

    • 1
    • 2
    • 3
    • 4

    在这里插入图片描述
    新建一个增强类1

    /**
 * @author Lenovo
 * @version 1.0
 * @data 2022/10/22 18:50
 */
@Component
@Aspect
@Order(1)
public class UserProxy1 {

    /**
     * 1、前置通知
     */
    @Before(value = "execution(* com.zyz.spring5.aop.User.add(..))")
    public void before(){
        System.out.println("我的优先级高哦、我先执行。before。。。。。。");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    之前的增强类也添加一个优先级

    @Component
@Aspect//生成代理对象
@Order(3)
public class UserProxy {

    • 1
    • 2
    • 3
    • 4

    测试结果
    在这里插入图片描述

    5、完全注解开发

    5.1 新增一个配置类

    ConfigAop.java

    /**
 * @author Lenovo
 * @version 1.0
 * @data 2022/10/22 18:58
 */
@Configuration
@ComponentScan(basePackages = {"com.zyz"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    5.2 测试方式改动

    之前读取的是配置文件。现在要读取配置类

        @org.junit.Test
    public void testDemo1(){
        //加载配置类
        ApplicationContext context = new AnnotationConfigApplicationContext(ConfigAop.class);
        User user = context.getBean("user", User.class);
        user.add();

    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    测试结果不变
    在这里插入图片描述

    目录结构
    在这里插入图片描述

    6、后语

    学无止境…

  • 相关阅读:
    电商小程序实战教程-类别导航续
    事务的隔离级别与MVCC
    18.（开发工具篇Gitlab）Git如何回退到指定版本
    开发知识点-uniapp微信小程序-开发指南
    安卓APP源码和报告——音乐播放器
    win10 环境下Python 3.8按装fastapi paddlepaddle 进行图片文字识别1
    【思维构造】Element Extermination—CF1375C
    IT项目经理必备的五种能力
    cmake配置opencv与boost库
    jupyterlab教程
  • 原文地址：https://blog.csdn.net/weixin_43304253/article/details/127465205