SSM框架学习——Spring之AOP学习

最新推荐文章于 2023-08-17 10:42:40 发布

程序员Lyle

最新推荐文章于 2023-08-17 10:42:40 发布

阅读量210

点赞数

分类专栏： SSM框架学习文章标签： spring 学习 java

本文链接：https://blog.csdn.net/weixin_58035422/article/details/125674661

版权

SSM框架学习专栏收录该内容

21 篇文章 1 订阅

订阅专栏

2. 制作连接点方法（原始操作，Dao接口与实现类）

3. 制作共性功能（通知类与通知)

4. 定义切入点

5. 绑定切入点与通知关系（切面)

6.最后还要开启Spring对AOP注解驱动支持

一、AOP简介

1.什么是AOP？

和OOP(Object Oriented Programming)面向对象编程一样，AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构。

作用︰在不惊动原始设计的基础上为其进行功能增强。

Spring理念:无入侵式/无侵入式

2.AOP核心概念
public void show() {
    System.out.println(System.currentTimeMillis());
    System.out.println("brand");

}

public void update() {
    System.out.println("update");
}

public void delete() {
    System.out.println("delete");
}
    
这里有三个方法,我们管他们叫做连接点，第一个方法里有输出当前时间，我想让别的方法不作改变也拥有这个功能。

对于要追加功能的方法内的那段代码叫做切入点。

连接点大，包含切入点。
public void delete() { //连接点
    System.out.println("delete"); //切入点
}
那么现在就需要将实现这功能的部分代码抽取出来。这组有共性的功能起名为通知，类叫做通知类。
public void method() {
    Long startTime = System.currentTimeMillis();
    for (int i = 0; i < 10000; i++) {
        //调用原始操作
    }
    Long endTime = System.currentTimeMillis();
    Long totalTime = startTime - endTime;
    System.out.println("执行万次耗时"+totalTime+"ms");
}
那么通知和切入点之间还需要一个东西进行绑定，那就是切面。

切面描述的就是在哪个切入点执行哪些通知。

连接点 ( JoinPoint )︰

        程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等。

        在SpringAOP中，理解为方法的执行。

切入点( Pointcut ) ∶

        匹配连接点的式子。

        在SpringAOP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法。

通知（Advice ):

        在切入点处执行的操作，也就是共性功能。

        在SpringAOP中，功能最终以方法的形式呈现。

通知类∶

        定义通知的类。
切面( Aspect ):

        描述通知与切入点的对应关系。

二、AOP入门案例

1.AOP入门案例思路分析

设定∶在接口执行前输出当前系统时间

开发模式:XML or 注解（我们这里用注解开发）
思路分析︰
1. 导入坐标（ pom.xml )

2. 制作连接点方法（原始操作，Dao接口与实现类）
3. 制作共性功能（通知类与通知)

4. 定义切入点
5. 绑定切入点与通知关系〈切面)

2.AOP入门案例实现

1. 导入坐标（ pom.xml )

说明: spring-context坐标依赖spring-aop坐标
<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>
2. 制作连接点方法（原始操作，Dao接口与实现类）

就是上文的三个方法，已经做好不再展示。

3. 制作共性功能（通知类与通知)

4. 定义切入点

说明︰切入点定义依托一个不具有实际意义的方法进行，即无参数，无返回值，方法体无实际逻辑

5. 绑定切入点与通知关系（切面)
//定义通知类受Spring容器管理，并定义当前类为切面类
@Component  //告诉Spring这个类需要加载
@Aspect    //告诉Spring这个类作为AOP使用

public class Advice {

    //定义切入点，切入点定义依托一个不具有实际意义的方法进行，即无参数，无返回值，方法体无实际逻辑
    @Pointcut("execution(void test.dao.BrandDao.update())")
    private void pointcut(){
    }

    //绑定切入点与通知关系
    @Before("pointcut()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
6.最后还要开启Spring对AOP注解驱动支持
@Configuration
@ComponentScan({"test"})
@EnableAspectJAutoProxy //启动AOP注解开发
public class SpringConfig {
}
运行代码：
public class App {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        BrandDao brandDao = context.getBean(BrandDao.class);
        brandDao.update();
    }
}
运行结果：

三、AOP工作流程

1. Spring容器启动
2. 读取所有切面配置中的切入点（就是绑定了关系使用了才读取）

3. 初始化bean ，判定bean对应的类中的方法是否匹配到任意切入点

如果匹配失败，创建对象

如果匹配成功，创建原始对象（目标对象）的代理对象

4、获取bean执行方法
获取bean，调用方法并执行，完成操作

获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

目标对象( Target )：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的。

代理（ Proxy )：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现。

四、AOP切入点表达式

1.语法格式

切入点表达式:要进行增强的方法的描述方式

描述方式一：执行接口中的方法
描述方式二：执行实现类中的方法

切入点表达式标准格式:

动作关键字(访问修饰符返回值包名.类/接口名.方法名(参数)异常名)

动作关键字 :描述切入点的行为动作,例如execution表示执行到指定切入点
访问修饰符 : public , private等,可以省略
返回值
包名
类/接口名
方法名
参数
异常名: 方法定义中抛出指定异常,可以省略

2.通配符

可以使用通配符描述切入点,快速描述。

*:单个独立的任意符号,可以独立出现,也可以作为前缀或者后缀的匹配符出现
execution(public * test.*.BrandService.select*(*))
匹配test包下的任意包中的BrandService类或接口中所有select开头的带有一个参数的方法

.. :多个连续的任意符号,可以独立出现,常用于简化包名与参数的书写
execution (public Brand test..BrandService.findById(..))
匹配test包下的任意东西（不管几层包）中的BrandService类或接口中所有名称为findByld的方法

+ :专用于匹配子类类型
execution(* *.. *Service+.*(..))
匹配所有业务层的所有方法

3.书写技巧

所有代码按照标准规范开发 ,否则以下技巧全部失效
描述切入点通常描述接口 ,而不描述实现类
访问控制修饰符针对接口开发均采用public描述(可省略访问控制修饰符描述)
返回值类型对于增删改类使用精准类型加速匹配 ,对于查询类使用*通配快速描述
包名书写尽量不使用..匹配 ,效率过低,常用*做单个包描述匹配,或精准匹配
接口名/类名书写名称与模块相关的采用*匹配 ,例如UserService书写成*Service ,绑定业务层接口名
方法名书写以动词进行精准匹配 ,名词采用*匹配,例如getByld书写成getBy*,selectAII书写成selectAll
参数规则较为复杂 ,根据业务方法灵活调整
通常不使用异常作为匹配规则

五、AOP通知类型

AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置。

AOP通知共分为5种类型:

前置通知
后置通知
环绕通知（重点)
返回后通知（了解)
抛出异常后通知 (了解)

前置通知

名称:@Before

类型:方法注解
位置∶通知方法定义上方
作用∶设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行

相关属性:

value (默认）︰切入点方法名，格式为类名.方法名()

范例∶
@Pointcut("execution(void test.dao.BrandDao.update())")
private void pointcut(){}

@Before("pointcut()")
public void before(){
    System.out.println("Before");
}

后置通知

名称:@After

类型︰方法注解
位置︰通知方法定义上方
作用︰设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行
相关属性: value （默认）:切入点方法名，格式为类名.方法名()

范例∶
@Pointcut("execution(void test.dao.BrandDao.update())")
private void pointcut(){}

@After("pointcut()")
public void after(){
    System.out.println("After");
}

环绕通知（重点)

名称:@Around (重点，常用)

类型︰方法注解
位置∶通知方法定义上方
作用∶设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行

相关属性: value （默认）:切入点方法名，格式为类名.方法名()

范例：

①当原始操作无返回值时
@Pointcut("execution(void test.dao.BrandDao.update())")
private void pointcut(){}

@Around("pointcut()")    //形参中添加ProceedingJoinPoint参数
public void around(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("Before");
    pjp.proceed(); //这句话代表调用原始操作，放在需要的位置
    System.out.println("After");
}
②当原始操作有返回值时

此时需要对返回值进行处理。通过ProceedingJoinPoint.proceed()对原始操作进行调用，获得结果进行灵活处理，最后需要return回去。
@Pointcut("execution(int test.dao.BrandDao.delete())")
private void pointcut2(){}

@Around("pointcut2()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("Before");
    Integer o = (Integer) pjp.proceed();
    System.out.println("After");
    return o+566;  //此处返回值到就代替了原始操作的返回值
}
第二种情况实例

运行代码：
public class App {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        BrandDao brandDao = context.getBean(BrandDao.class);
        int i = brandDao.delete();
        System.out.println(i);
    }
}
运行结果：

注意事项：

环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知
通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行（可用此进行权限校验，过滤器等）
对原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，必须设定为Object类型
原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void，也可以设置成Object
由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须抛出Throwable对象

返回后通知（了解)

名称:@AfterReturning ( 了解)

类型:方法注解
位置:通知方法定义上方
作用∶设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法正常执行完毕后运行

相关属性: value （默认）:切入点方法名，格式为类名.方法名()

范例︰
@Pointcut("execution(int test.dao.BrandDao.delete())")
private void pointcut2(){}

@AfterReturning("pointcut2()")    //只要当方法没有抛出异常，正常时才会执行
public void afterReturning(){
    System.out.println("AfterReturning");
}
位置：

抛出异常后通知 (了解)

名称︰@AfterThrowing (了解)

类型:方法注解
位置:通知方法定义上方
作用∶设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行

相关属性: value （默认）:切入点方法名，格式为类名.方法名()

范例∶
public int delete() {
    System.out.println("delete...");
    int i = 1/0; // 程序带有异常
    return 100;
}
@Pointcut("execution(int test.dao.BrandDao.delete())")
private void pointcut2(){}

@AfterThrowing("pointcut2()")    //带异常才会执行
public void afterThrowing(){
    System.out.println("AfterThrowing");
}

六、AOP通知获取数据

获取切入点方法的参数

JoinPoint:适用于前置、后置、返回后、抛出异常后通知

ProceedJointPoint :适用于环绕通知

JoinPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数。

ProceedJointPoint是JoinPoint的子类。
    //都是通过getArgs方法获取原始操作传过来的参数

    public void before(JoinPoint jp) {
        Object[] args = jp.getArgs();
        System.out.println("Before:" + Arrays.toString(args));
    }

    //    @After("pointcut3()")
    public void after(JoinPoint jp) {
        Object[] args = jp.getArgs();
        System.out.println("After:" + Arrays.toString(args));
    }

    @Around("pointcut3()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("Before");
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        args[0] = 666;  
        String o = (String) pjp.proceed(args);
        System.out.println("After");
        return o;
    }
获取切入点方法返回值

返回后通知

环绕通知

返回后通知可以获取切入点方法的返回值，使用形参可以接收对应的返回值。

环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值。
    @Around("pointcut3()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("Before");
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        args[0] = 666;  
        String o = (String) pjp.proceed(args);
        System.out.println("After");
        return o;
    }

    @AfterReturning(value = "pointcut3()",returning = "ret")
    //returning 如果原始操作有返回值就把这个返回值装在设定的参数中
    public void afterReturning(Object ret) {
        System.out.println("AfterReturning:"+ret);
    }
public void afterReturning(JoinPoint jp,Object ret) {
    System.out.println("AfterReturning:"+ret);
}
注意：通知方法如果参数中有JoinPoint ，JoinPoint 必须在第一个，位置换了报错。

获取切入点方法运行异常信息

抛出异常后通知

环绕通知

抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象。

环绕通知在方法内用trycatch获取异常信息进行处理。
    @Around("pointcut3()")
    public Object around(ProceedingJoinPoint pjp){
        System.out.println("Before");
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        args[0] = 666;
        String o = null;
        try {
            o = (String) pjp.proceed(args);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("After");
        return o;
    }

    @AfterThrowing(value = "pointcut2()", throwing = "e")
    public void afterThrowing(Throwable e) {
        System.out.println("AfterThrowing" + e);
    }

AOP总结

概念︰AOP(Aspect Oriented Programming)面向切面编程，一种编程范式

作用︰在不惊动原始设计的基础上为方法进行功能增强
核心概念：

代理（ Proxy ) : SpringAoP的核心本质是采用代理模式实现的
连接点( JoinPoint ) :在SpringAOP中，理解为任意方法的执行
切入点( Pointcut ) :匹配连接点的式子，也是具有共性功能的方法描述
通知( Advice ):若干个方法的共性功能，在切入点处执行，最终体现为一个方法
切面( Aspect )︰描述通知与切入点的对应关系
目标对象( Target ):被代理的原始对象成为目标对象

切入点表达式标准格式︰

        动作关键字（访问修饰符返回值﹐包名.类/接口名.方法名（参数）异常名)

切入点表达式描述通配符:

作用:用于快速描述，范围描述

* :匹配任意符号（常用)
.. :匹配多个连续的任意符号（常用)
＋:匹配子类类型

示例：

execution(* test. service.*Service.*( ..))

通知类型:

前置通知
后置通知
环绕通知（重点)
返回后通知
抛出异常后通知

AOP通知获取数据

        获取切入点方法的参教

JoinPoint:适用于前置、后置、返回后、抛出异常后通知，设置为方法的第一个形参
ProceedJointPoint:适用于环绕通知

        获取切入点方法返回值

返回后通知
环绕通知

        获取切入点方法运行异常信息

抛出异常后通知
环绕通知

程序员Lyle

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
SSM框架学习——Spring之AOP学习

目录一、AOP简介1.什么是AOP？2.AOP核心概念二、AOP入门案例 1.AOP入门案例思路分析2.AOP入门案例实现1. 导入坐标（ pom.xml )2. 制作连接点方法（原始操作，Dao接口与实现类）3. 制作共性功能（通知类与通知)4. 定义切入点5. 绑定切入点与通知关系（切面)6.最后还要开启Spring对AOP注解驱动支持运行结果：三、AOP工作流程四、AOP切入点表达式1.语法格式2.通配符3.书写技巧五、AOP通知类型前置通知后置通知环绕通知（重点)返回后通知（了解)抛出异常后通知
复制链接

扫一扫