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：对 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.*.* (..))

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......");
    }

}

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("环绕之后。。。。。。。");
    }

}

3.3 bean.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: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>

    <!-- 开启 Aspect 生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

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();

    }
}

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("环绕之后。。。。。。。");
    }

}

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

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

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

新建一个增强类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。。。。。。");
    }
}

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

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

测试结果

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 {
}

5.2 测试方式改动

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

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

    }

测试结果不变

目录结构

6、后语

学无止境…