索取营销诊断书
021-80394720QQ
您的位置：上海毫米网络优化公司 > 小程序 > 百度小程序 >
相关推荐recommended
Spring AOP入门指南：轻松掌握面向切面编程的基础知识
作者：mmseoamin日期：2023-12-25

面向切面编程

    • 1，AOP简介
      • 1.1 什么是AOP?
      • 1.2 AOP作用
      • 1.3 AOP核心概念
      • 2，AOP入门案例
        • 2.1 需求分析
        • 2.2 思路分析
        • 2.3 环境准备
        • 2.4 AOP实现步骤
          • 步骤1:添加依赖
          • 步骤2:定义接口与实现类
          • 步骤3:定义通知类和通知
          • 步骤4:定义切入点
          • 步骤5:制作切面
          • 步骤6:将通知类配给容器并标识其为切面类
          • 步骤7:开启注解格式AOP功能
          • 步骤8:运行程序
          • 知识点1：@EnableAspectJAutoProxy
          • 知识点2：@Aspect
          • 知识点3：@Pointcut
          • 知识点4：@Before
          • 3，AOP工作流程
            • 3.1 AOP工作流程
              • 流程1:Spring容器启动
              • 流程2:读取所有切面配置中的切入点
              • 流程3:初始化bean，
              • 流程4:获取bean执行方法
              • 验证容器中是否为代理对象
                • 验证思路
                • 步骤1:修改App类,获取类的类型
                • 步骤2:修改MyAdvice类，不增强
                • 步骤3:运行程序
                • 步骤4:修改MyAdvice类，增强
                • 步骤5:运行程序
                • 3.2 AOP核心概念

                  1，AOP简介

                  1.1 什么是AOP?

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

                      我们都知道OOP是一种编程思想，那么AOP也是一种编程思想，编程思想主要的内容就是指导程序员该如何编写程序，所以它们两个是不同的编程范式。

                      1.2 AOP作用

                      • 作用:在不惊动原始设计的基础上为其进行功能增强，前面咱们有技术就可以实现这样的功能即代理模式。

                        前面咱们有技术就可以实现这样的功能即代理模式。

                        1.3 AOP核心概念

                        为了能更好的理解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方法中有计算万次执行消耗的时间。

                        当在App类中从容器中获取bookDao对象后，分别执行其save,delete,update和select方法后会有如下的打印结果:

                        Spring AOP入门指南：轻松掌握面向切面编程的基础知识,在这里插入图片描述,第1张

                        这个时候，我们就应该有些疑问?

                        • 对于计算万次执行消耗的时间只有save方法有，为什么delete和update方法也会有呢?
                        • delete和update方法有，那什么select方法为什么又没有呢?

                          这个案例中其实就使用了Spring的AOP，在不惊动(改动)原有设计(代码)的前提下，想给谁添加功能就给谁添加。这个也就是Spring的理念：

                          • 无入侵式/无侵入式

                            说了这么多，Spring到底是如何实现的呢?

                            Spring AOP入门指南：轻松掌握面向切面编程的基础知识,在这里插入图片描述,第2张

                            (1)Spring的AOP是对一个类的方法在不进行任何修改的前提下实现增强。对于上面的案例中BookServiceImpl中有save,update,delete和select方法,这些方法我们给起了一个名字叫连接点。

                            (2)在BookServiceImpl的四个方法中，update和delete只有打印没有计算万次执行消耗时间，但是在运行的时候已经有该功能，那也就是说update和delete方法都已经被增强，所以对于需要增强的方法我们给起了一个名字叫切入点。

                            (3)执行BookServiceImpl的update和delete方法的时候都被添加了一个计算万次执行消耗时间的功能，将这个功能抽取到一个方法中，换句话说就是存放共性功能的方法，我们给起了个名字叫通知。

                            (4)通知是要增强的内容，会有多个，切入点是需要被增强的方法，也会有多个，那哪个切入点需要添加哪个通知，就需要提前将它们之间的关系描述清楚，那么对于通知和切入点之间的关系描述，我们给起了个名字叫切面。

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

                            至此AOP中的核心概念就已经介绍完了，总结下:

                            • 连接点(JoinPoint)：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等
                              • 在SpringAOP中，理解为方法的执行
                              • 切入点(Pointcut):匹配连接点的式子
                                • 在SpringAOP中，一个切入点可以描述一个具体方法，也可也匹配多个方法
                                  • 一个具体的方法:如com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法
                                  • 匹配多个方法:所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法
                                  • 连接点范围要比切入点范围大，是切入点的方法也一定是连接点，但是是连接点的方法就不一定要被增强，所以可能不是切入点。
                                  • 通知(Advice):在切入点处执行的操作，也就是共性功能
                                    • 在SpringAOP中，功能最终以方法的形式呈现
                                    • 通知类：定义通知的类
                                    • 切面(Aspect):描述通知与切入点的对应关系。

                                      2，AOP入门案例

                                      2.1 需求分析

                                      案例设定：测算接口执行效率，但是这个案例稍微复杂了点，我们对其进行简化。

                                      简化设定：在方法执行前输出当前系统时间。

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

                                      2.2 思路分析

                                      需求明确后，具体该如何实现，都有哪些步骤，我们先来分析下:

                                      1.导入坐标(pom.xml)

                                      2.制作连接点(原始操作，Dao接口与实现类)

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

                                      4.定义切入点

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

                                      2.3 环境准备

                                      • 创建一个Maven项目

                                      • pom.xml添加Spring依赖

                                        
    
        org.springframework
        spring-context
        5.2.10.RELEASE

                                      • 添加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 {
}

                                      • 编写App运行类

                                        public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.save();
    }
}

                                        最终创建好的项目结构如下:

                                        Spring AOP入门指南：轻松掌握面向切面编程的基础知识,在这里插入图片描述,第3张

                                        说明:

                                        • 目前打印save方法的时候，因为方法中有打印系统时间，所以运行的时候是可以看到系统时间
                                        • 对于update方法来说，就没有该功能
                                        • 我们要使用SpringAOP的方式在不改变update方法的前提下让其具有打印系统时间的功能。

                                          2.4 AOP实现步骤

                                          步骤1:添加依赖

                                          pom.xml

                                          
    org.aspectj
    aspectjweaver
    1.9.4

                                          Spring AOP入门指南：轻松掌握面向切面编程的基础知识,在这里插入图片描述,第4张

                                          • 因为spring-context中已经导入了spring-aop,所以不需要再单独导入spring-aop
                                          • 导入AspectJ的jar包,AspectJ是AOP思想的一个具体实现，Spring有自己的AOP实现，但是相比于AspectJ来说比较麻烦，所以我们直接采用Spring整合ApsectJ的方式进行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());
    }
}

                                              绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置

                                              Spring AOP入门指南：轻松掌握面向切面编程的基础知识,在这里插入图片描述,第5张

                                              说明:@Before翻译过来是之前，也就是说通知会在切入点方法执行之前执行，除此之前还有其他四种类型，后面会讲。

                                              步骤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();
    }
}

                                              看到在执行update方法之前打印了系统时间戳，说明对原始方法进行了增强，AOP编程成功。

                                              Spring AOP入门指南：轻松掌握面向切面编程的基础知识,在这里插入图片描述,第6张

                                              知识点1：@EnableAspectJAutoProxy

                                              名称@EnableAspectJAutoProxy
                                              类型配置类注解
                                              位置配置类定义上方
                                              作用开启注解格式AOP功能

                                              知识点2：@Aspect

                                              名称@Aspect
                                              类型类注解
                                              位置切面类定义上方
                                              作用设置当前类为AOP切面类

                                              知识点3：@Pointcut

                                              名称@Pointcut
                                              类型方法注解
                                              位置切入点方法定义上方
                                              作用设置切入点方法
                                              属性value（默认）：切入点表达式

                                              知识点4：@Before

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

                                              3，AOP工作流程

                                              3.1 AOP工作流程

                                              由于AOP是基于Spring容器管理的bean做的增强，所以整个工作过程需要从Spring加载bean说起:

                                              流程1:Spring容器启动
                                              • 容器启动就需要去加载bean,哪些类需要被加载呢?
                                              • 需要被增强的类，如:BookServiceImpl
                                              • 通知类，如:MyAdvice
                                              • 注意此时bean对象还没有创建成功
                                                流程2:读取所有切面配置中的切入点

                                                Spring AOP入门指南：轻松掌握面向切面编程的基础知识,在这里插入图片描述,第7张

                                                • 上面这个例子中有两个切入点的配置，但是第一个ptx()并没有被使用，所以不会被读取。
                                                  流程3:初始化bean，

                                                  判定bean对应的类中的方法是否匹配到任意切入点

                                                  • 注意第1步在容器启动的时候，bean对象还没有被创建成功。

                                                  • 要被实例化bean对象的类中的方法和切入点进行匹配

                                                    Spring AOP入门指南：轻松掌握面向切面编程的基础知识,在这里插入图片描述,第8张

                                                    • 匹配失败，创建原始对象,如UserDao
                                                      • 匹配失败说明不需要增强，直接调用原始对象的方法即可。
                                                      • 匹配成功，创建原始对象（目标对象）的代理对象,如:BookDao
                                                        • 匹配成功说明需要对其进行增强
                                                        • 对哪个类做增强，这个类对应的对象就叫做目标对象
                                                        • 因为要对目标对象进行功能增强，而采用的技术是动态代理，所以会为其创建一个代理对象
                                                        • 最终运行的是代理对象的方法，在该方法中会对原始方法进行功能增强
                                                          流程4:获取bean执行方法
                                                          • 获取的bean是原始对象时，调用方法并执行，完成操作
                                                          • 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作
                                                            验证容器中是否为代理对象

                                                            为了验证IOC容器中创建的对象和我们刚才所说的结论是否一致，首先先把结论理出来:

                                                            • 如果目标对象中的方法会被增强，那么容器中将存入的是目标对象的代理对象
                                                            • 如果目标对象中的方法不被增强，那么容器中将存入的是目标对象本身。
                                                              验证思路

                                                              1.要执行的方法，不被定义的切入点包含，即不要增强，打印当前类的getClass()方法

                                                              2.要执行的方法，被定义的切入点包含，即要增强，打印出当前类的getClass()方法

                                                              3.观察两次打印的结果

                                                              步骤1:修改App类,获取类的类型
                                                              public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        System.out.println(bookDao);
        System.out.println(bookDao.getClass());
    }
}
                                                              步骤2:修改MyAdvice类，不增强

                                                              因为定义的切入点中，被修改成update1,所以BookDao中的update方法在执行的时候，就不会被增强，

                                                              所以容器中的对象应该是目标对象本身。

                                                              @Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update1())")
    private void pt(){}
    
    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
                                                              步骤3:运行程序

                                                              Spring AOP入门指南：轻松掌握面向切面编程的基础知识,在这里插入图片描述,第9张

                                                              步骤4:修改MyAdvice类，增强

                                                              因为定义的切入点中，被修改成update,所以BookDao中的update方法在执行的时候，就会被增强，

                                                              所以容器中的对象应该是目标对象的代理对象

                                                              @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());
    }
}
                                                              步骤5:运行程序

                                                              Spring AOP入门指南：轻松掌握面向切面编程的基础知识,在这里插入图片描述,第10张

                                                              至此对于刚才的结论，我们就得到了验证，这块大家需要注意的是:

                                                              不能直接打印对象，从上面两次结果中可以看出，直接打印对象走的是对象的toString方法，不管是不是代理对象打印的结果都是一样的，原因是内部对toString方法进行了重写。

                                                              3.2 AOP核心概念

                                                              在上面介绍AOP的工作流程中，我们提到了两个核心概念，分别是:

                                                              • 目标对象(Target)：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的
                                                              • 代理(Proxy)：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现

                                                                上面这两个概念比较抽象，简单来说，

                                                                目标对象就是要增强的类[如:BookServiceImpl类]对应的对象，也叫原始对象，不能说它不能运行，只能说它在运行的过程中对于要增强的内容是缺失的。

                                                                SpringAOP是在不改变原有设计(代码)的前提下对其进行增强的，它的底层采用的是代理模式实现的，所以要对原始对象进行增强，就需要对原始对象创建代理对象，在代理对象中的方法把通知[如:MyAdvice中的method方法]内容加进去，就实现了增强,这就是我们所说的代理(Proxy)。

                                                                后记

                                                                👉👉💕💕美好的一天，到此结束，下次继续努力！欲知后续，请看下回分解，写作不易，感谢大家的支持！！ 🌹🌹🌹

                                                                 

上一篇：SpringCloud Alibaba（一）微服务简介+Nacos的安装部署与使用+Nacos集成springboot实现服务注册+Feign实现服务之间的远程调用+负载均衡+领域划分

下一篇：Spring security之授权

网站优化运营
整站seo优化
网络营销运营
成功案例
品牌创意网站
营销型网站
小程序
微信小程序
微信公众号
百度熊掌号
网站优化分享
关于我们
公司概况
公司新闻
公司文化
结构体系
企业资质
加入我们
关注我们
扫描二维码
获取更多信息
精彩一手掌握
Copyright © 2014-2019 seo,上海网站优化_网络制作_网站seo排名_网站建设推广_上海网络公司 版权所有 沪ICP备19022315号