Spring--AOP知识学习

1.引入AOPjar包文件

 		<!--引入AOPjar包文件-->
        <dependency>
  	          <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

2.AOP介绍

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

总结: Spring中的AOP 利用代理对象在不修改源代码的条件下,对方法进行扩展.

一句话：

动态代理执行力目标方法，并且对目标方法进行了扩充，称为切面

入门案例

编辑配置类

package com.jt.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.jt")
@EnableAspectJAutoProxy//启用AOP
public class SpringConfig {
}

编辑切片类

package com.jt.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component//将该类交给容器管理
@Aspect //标识该
public class SpringAop {
    /**
     * 公式：切面=切入点表达式+通知方法
     * 切入点表达式：如果目标对象满足切入点表达式的判断（if），则spring自动为其创建代理对象
     * 通知方法：对目标方法进行扩展的封装方法
     * 目标对象的beanID：userServiceImpl
     * 切入点表达式：
     *      1.bean("bean的id")
     * AOP规则;
     * */
    @Pointcut("bean(userServiceImpl)")
    public void pointcut(){

    }

    //1.前置通知：在目标方法执行之前执行
    @Before("pointcut()")
    public void before(){
        System.out.println("我是前置通知");
    }

//    2.后置通知：在目标方法执行之后执行
    @AfterReturning("pointcut()")
    public void afterReturn(){
        System.out.println("我是后置通知");
    }

    //3.异常通知：目标方法执行报错时，执行该通知
    @AfterThrowing("pointcut()")
    public void afterThrowing(){
        System.out.println("我是异常通知");
    }

    //4.最终通知：目标方法之后都要执行的通知
    @After("pointcut()")
    public void after(){
        System.out.println("最终通知都要执行");
    }
    //5.重点掌握 环绕通知：在目标方法执行前后都要执行，控制目标方法
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知执行前");
        //底层调用动态代理的invoke方法，执行目标方法
        Object result = joinPoint.proceed();
        System.out.println("环绕通知执行后");
        return result;
    }
}

编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestSpring {
    @Test
    public void TestDemo1(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean(UserService.class);
        //获取代理对象
        System.out.println(userService.getClass());
        userService.addUser();
    }
}

AOP表达式

bean标签

• 说明：根据bean的id拦截指定对象
• 语法：@Pointcut(“bean(userServiceImpl)”)
  public void pointcut(){
  }

within标签

• 语法：按照类型匹配，可以使用通配符*
• 说明：
• @Pointcut(“within(com.jt.service.UserServiceImpl)”)
  只扫描UserServiceImpl类
• 2.@Pointcut(“within(com.jt.service.*)”)
  扫描service包的一级类
• 3@@Pointcut(“within(com.jt.service…*)”)
  扫描service包下的所有类
• 4@@Pointcut(“within(com.jt.service…*)”)
  扫描任意包下service包下的所有类

上述两种操作方式粒度较粗，一般不用。

execution表达式

• execution(返回值类型 包名类名方法名(参数列表))
  @Pointcut(“execution(* com.jt.service.UserServiceImpl.addUser())”)
• execution(返回值类型 包名类名下所有类的所有方法(所有参数))
  @Pointcut(“execution(* com.jt.service….(…))”)
• execution(返回值类型 包名类名下所有类中的add开头的方法，且参数只有一个int类型 进行拦截(所有参数))
  @Pointcut(“execution(* com.jt.service…add.(int))”)

@annotation表达式
作用: 可以根据用户的自定义注解进行拦截

• 完成注解类

package com.jt.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)//注解运行期有效
@Target(ElementType.METHOD)//注解标识方法
public @interface Wxin {

}

• 标识注解

@Pointcut("@annotation(com.jt.anno.Wxin)")