黑马Spring学习笔记(四)——面向切面编程AOP

目录

一、AOP简介

二、AOP核心概念

三、AOP入门案例

四、AOP配置管理

4.1  AOP切入点表达式

4.1.1  语法格式

4.2.2  通配符

4.2.3  书写技巧

4.2  AOP通知类型

4.2.1 前置、后置、返回后、抛出异常后获取参数

4.2.2  环绕通知


一、AOP简介

        AOP(Aspect Oriented Programming)面向切面编程,一种编程范式,也是一种编程思想,编程思想主要的内容就是指导程序员该如何编写程序。

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


        下面我们来看一个例子:

        最主要的类BookDaoImpl内容如下:

@Repository
    public class BookDaoImpl implements BookDao {
        public void save() {
        //记录程序当前执行执行(开始时间)
        Long startTime = System.currentTimeMillis();
        //业务执行万次
        for (int i = 0;i<10000;i++) {
            System.out.println("book dao save ...");
        }
        //记录程序当前执行时间(结束时间)
        Long endTime = System.currentTimeMillis();
         //计算时间差
         Long totalTime = endTime-startTime;
        //输出信息
         System.out.println("执行万次消耗时间:" + totalTime + "ms");
     }

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

     public void delete(){
        System.out.println("book dao delete ...");
     }

    public void select(){
         System.out.println("book dao select ...");
     }
 }

        不难看出,这个类中有四个方法,其中save()方法有计算万次执行消耗的时间。

        但是,当我们从容器中获取bookDao对象后,分别对其执行save(),delete(),update(),select(),会有如下的打印结果:

黑马Spring学习笔记(四)——面向切面编程AOP_第1张图片

 为什么delete()和update()方法也执行了10000次且计算了执行时间呢?

        这就是SpringAOP,在不惊动(改动)原有设计(代码)的前提下,想给谁添加功能就给谁添加。

二、AOP核心概念

        那Spring到底是如何实现AOP的呢?

黑马Spring学习笔记(四)——面向切面编程AOP_第2张图片

  1.  连接点与切入点

    连接点:执行的方法

    切入点:需要被增强的方法

    连接点: 程序执行过程中的任意位置,可以为方法,抛出异常,也可以为设置变量。

    切入点: 一个切入点可以描述一个具体的方法,也可以匹配多个方法,一个切入点可以只匹配一个update方法,也可以匹配某个包下面所有的查询方法。

    【连接点范围 > 切入点范围,切入点一定是连接点,反之未必】

  2. 通知与通知类

    通知:存放共性功能的方法

    通知类:定义通知的类

    通知: 在切入点处执行的操作,也就是共性功能。

    通知类: 通知是一个方法,方法不能独立存在,需要被写在一个类中,这个类我们也给起了个名字叫通知类

  3. 切面

    切面:通知与切入点之间的关系描述

    通知是要增强的内容,会有多个;切入点是需要被增强的方法,也会有多个,哪个切入点需要添加哪个通知,就需要提前将它们之间的关系描述清楚,那么对于通知和切入点之间的关系描述,我们称之为切面

三、AOP入门案例

        我们使用注解来完成AOP的开发。

        案例为:使用SpringAOP的注解方式完成在方法执行前打印出当前系统时间。

3.1 思路分析:

1. 导入坐标 (pom.xml)
2. 制作连接点 ( 原始操作, Dao 接口与实现类 )
3. 制作共性功能 ( 通知类与通知 )
4. 定义切入点
5. 绑定切入点与通知关系 ( 切面 )

3.2 实现步骤:

环境准备
  • 创建一个Maven项目
  • pom.xml 添加 Spring 依赖
    
         
             org.springframework
             spring-context
             5.3.20
        
    
  • 添加 BookDao BookDaoImpl
    public interface BookDao {
        public void save();
    
        public void update();
    }
    
    @Repository
    public class BookDaoImpl implements BookDao {
        public void save() {
            System.out.println(System.currentTimeMillis());
            System.out.println("book dao save ...");
        }
    
        public void update() {
            System.out.println("book dao update ...");
        }
    }
  • 创建Spring的配置类
    @Configuration
    @ComponentScan("com.itheima")
    public class SpringConfig {
    }

    项目结构如下:

    黑马Spring学习笔记(四)——面向切面编程AOP_第3张图片

AOP实现步骤
  1. 添加依赖
    
        org.aspectj
        aspectjweaver
        1.9.4
    

    因为spring-context中已经导入了spring-aop ,所以不需要再单独导入spring-aop

  2. 定义接口与实现类
    BookDaoImpl
    已经准备好,不需要做任何修改
  3. 定义通知类和通知
    public class MyAdvice {
        public void method(){
            System.out.println(System.currentTimeMillis());
        }
    }
    因类名和方法名没有要求,可以任意
  4. 定义切入点
    BookDaoImpl
    中有两个方法,分别是 save update ,我们要增强的是 update 方法,该如何定义呢 ?
    public class MyAdvice {
        @Pointcut("execution(void com.itheima.dao.BookDao.update())")
        private void pt() {
        }
    
        public void method() {
            System.out.println(System.currentTimeMillis());
        }
    }
    切入点定义依托一个不具有实际意义的方法进行,即无参数、无返回值、方法体无实际逻辑
  5. 制作切面
    public class MyAdvice {
        @Pointcut("execution(void com.itheima.dao.BookDao.update())")
        private void pt() {
        }
    
        @Before("pt()")
        public void method() {
            System.out.println(System.currentTimeMillis());
        }
    }
    绑定切入点与通知关系,并指定通知添加到原始连接点的具体执行 位置
  6. 将通知类配给容器并标识其为切面类
    @Component
    @Aspect
    public class MyAdvice {
        @Pointcut("execution(void com.itheima.dao.BookDao.update())")
        private void pt() {
        }
    
        @Before("pt()")
        public void method() {
            System.out.println(System.currentTimeMillis());
        }
    }
  7. 开启注解格式AOP功能
    @Configuration
    @ComponentScan("com.itheima")
    @EnableAspectJAutoProxy
    public class SpringConfig {
    }
  8. 运行程序
    public class App {
        public static void main(String[] args) {
            ApplicationContext ctx = new
                    AnnotationConfigApplicationContext(SpringConfig.class);
            BookDao bookDao = ctx.getBean(BookDao.class);
            bookDao.update();
        }
    }

四、AOP配置管理

4.1  AOP切入点表达式

黑马Spring学习笔记(四)——面向切面编程AOP_第4张图片

4.1.1  语法格式

execution(public User com.itheima.service.UserService.findById(int))


参数:

execution :动作关键字,描述切入点的行为动作,例如 execution 表示执行到指定切入点
public: 访问修饰符 , 还可以是 public private 等,可以省略
User :返回值,写返回值类型
com.itheima.service :包名,多级包使用点连接
UserService: / 接口名称
findById :方法名
int: 参数,直接写参数的类型,多个类型用逗号隔开
异常名:方法定义中抛出指定异常,可以省略
        切入点表达式就是要找到需要增强的方法,所以它就是对一个具体方法的描述,但是方法的定义会有很多,所以如果每一个方法对应一个切入点表达式,想想这块就会觉得将来编写起来会比较麻烦,就需要用到下面所学习的通配符。

4.2.2  通配符

  1.   *  单个独立的任意符号,可以独立出现,也可以作为前缀或者后缀的匹配符出现
    execution(public * com.itheima.*.UserService.find*(*))
  2.   ..   :多个连续的任意符号,可以独立出现,常用于简化包名与参数的书写
    execution(public User com..UserService.findById(..))
  3.   +   :专用于匹配子类类型
    execution(* *..*Service+.*(..))
    这个使用率较低,描述子类的,JavaEE开发,继承机会就一次,使用都很慎重,所以很少用它。*Service+,表示所有以Service结尾的接口的子类

例如:

execution(void com..*())
返回值为voidcom包下的任意包任意类任意方法,能匹配,*代表的是方法
execution(* com.itheima.*.*Service.find*(..))
将项目中所有业务层方法的以find开头的方法匹配
execution(* com.itheima.*.*Service.save*(..))
将项目中所有业务层方法的以save开头的方法匹配
       

4.2.3  书写技巧

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

4.2  AOP通知类型

        AOP提供了5种通知类型:

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

        我们来看一张图:

黑马Spring学习笔记(四)——面向切面编程AOP_第5张图片

4.2.1 前置、后置、返回后、抛出异常后获取参数

目前有执行方法(连接点、切入点)findName()如下:

@Repository
public class BookDaoImpl implements BookDao {

     public String findName(int id) {
         return "itcast";
     }
}

共性方法(通知类)如下:

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    private void pt() {
    }

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

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

那么当对findName()进行增强的时候,通知类中的共性方法如何才能获取findName中的参数id呢?


  • 使用JoinPoint

通知作如下修改:

@Before("pt()")
public void before(JoinPoint jp)
    Object[] args = jp.getArgs();
    System.out.println(Arrays.toString(args));

    System.out.println("before advice ..." );
}

我们在执行类执行findName(100)时,输出如下:

黑马Spring学习笔记(四)——面向切面编程AOP_第6张图片

可见,共性方法成功得到了执行方法中的id参数,并且以数组的形式进行了输出(因为方法中的形参可能有多个)

如果执行方法为findName(id, password),在执行类执行findName(100,itheima),那么输出为:

4.2.2  环绕通知

1. 环绕通知不能像前置和后置通知一样,简单地写成

@Around("pt()")
public void around(){
    System.out.println("around before advice ...");
    System.out.println("around after advice ...");
}
【❌❌❌❌❌】

而应该写成

@Around("pt()")
public void around(ProceedingJoinPoint pjp) throws Throwable{
    System.out.println("around before advice ...");
    //表示对原始操作的调用
    pjp.proceed();
    System.out.println("around after advice ...");
}

通过proceed()函数可以区分环绕前面和后面的通知

2. 如果我们使用环绕通知的话,要根据原始方法的返回值来设置环绕通知的返回值

代码示例:

@Around("pt2()")
public Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("around before advice ...");
    //表示对原始操作的调用
    Object ret = pjp.proceed();
    System.out.println("around after advice ...");
    return ret;
}
为什么返回的是 Object 而不是 int 的主要原因是 Object 类型更通用。

3. 环绕通知获取参数

与非环绕通知的JoinPoint类似,环绕通知使用ProceedingJoinPoint,示例:

@Around("pt()")
public Object around(ProceedingJoinPoint pjp)throws Throwable {
    Object[] args = pjp.getArgs();
    System.out.println(Arrays.toString(args));

    Object ret = pjp.proceed();
    return ret;
}

同时,我们还可修改原始方法的参数,通过 args[0] = 666,我们就可以在环绕通知中对原始方法的参数进行拦截过滤,避免由于参数的问题导致程序无法正确运行,保证代码的健壮性。

你可能感兴趣的:(Java,Web,spring,学习,java)