Spring：（三）AOP

已于 2022-10-12 01:21:49 修改
阅读量115 收藏
点赞数
分类专栏： Java后端开发技术栈 文章标签： spring java 后端
于 2022-07-24 03:26:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sd_960614/article/details/125955272
版权

文章目录

3.1 AOP简介

3.1.1 AOP的概念

AOP：面向切面编程，利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

通俗描述：不通过修改源代码方式，在主干功能里面添加新功能

使用登录例子说明 AOP：

image-20220724004313458

3.2.2 AOP底层原理

AOP 底层使用动态代理，有两种情况的动态代理

  1. 有接口情况，使用 JDK 动态代理，创建接口实现类代理对象，增强类的方法

    image-20220724004622025

  2. 没有接口情况，使用 CGLIB 动态代理，创建子类的代理对象，增强类的方法

    image-20220724004657451

3.2 JDK动态代理

3.2.1 newProxyInstance

JDK 动态代理使用 Proxy 类里面的newProxyInstance()方法创建代理对象。

  • newProxyInstance 方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rVt19wEi-1658604183949)(../../AppData/Roaming/Typora/typora-user-images/image-20220724013911833.png)]

该方法有三个参数：

  • 第一参数，类加载器
  • 第二参数，增强方法所在的类实现的接口，支持多个接口
  • 第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

3.2.2 JDK动态代理实例

  1. 创建接口，定义方法

    public interface Human {
    public void eat(String str);
}

  2. 创建接口实现类，实现方法

    public class SuperMan implements Human{
    @Override
    public void eat(String str) {
        System.out.println("我喜欢吃" + str);
    }
}

  3. 使用 Proxy 类创建接口代理对象

    class ProxyFactory{
    Object object;

    public ProxyFactory(Object object) {
        this.object = object;
    }

    public Object getInstance(){
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // 在被代理对象的方法之上编写增强逻辑
                System.out.println("吃东西前要洗手...");
                Object returnValue = method.invoke(object, args);
                System.out.println("吃完东西要刷牙...");
                return returnValue;
            }
        });
    }
}

  4. 代码测试

    public class TestProxy {
    @Test
    public void testProxy(){
        SuperMan superMan = new SuperMan();
        ProxyFactory proxyFactory = new ProxyFactory(superMan);
        Human human = (Human) proxyFactory.getInstance();
        human.eat("四川麻辣烫");
    }
}

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QCvWYaqq-1658604183949)(../../AppData/Roaming/Typora/typora-user-images/image-20220724015703260.png)]

3.3 AOP相关术语

  1. 连接点：类里面哪些方法可以被增强，这些方法被称为连接点

  2. 切入点：实际上被增强的方法，被成为切入点

  3. 通知（增强）：实际上增强的逻辑部分被称为通知（增强）

    通知有多重类型：

    • 前置通知
    • 后置通知
    • 环绕通知
    • 异常通知
    • 最终通知

  4. 切面：是一个动作，把通知应用到切入点的过程叫做切面

3.4 Spring的AOP操作流程

3.4.1 AspectJ

Spring 框架一般都是基于AspectJ 实现AOP操作，AspectJ不是 Spring组成部分，而是一个独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作。

3.4.2 切入点表达式

  • 切入点表达式作用：知道对哪个类里面的哪个方法进行增强
  • 语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]))，其中中括号[]表示可选

举例1：对atguigu.dao.BookDao类里面的 add 进行增强 execution(* atguigu.dao.BookDao.add(…))

举例 2：对atguigu.dao.BookDao 类里面的所有的方法进行增强 execution(* atguigu.dao.BookDao.* (…))

3.4.3 基于AspectJ注解的AOP操作

  1. 创建类，在类里面定义方法

    public class User {
    public void add(){
        System.out.println("我要执行加法");
    }
}

  2. 创建增强类（编写增强逻辑）

    public class UserProxy {
    public void before() {//前置通知
        System.out.println("before......");
    }
}

  3. 进行通知的配置

    <?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="atguigu"></context:component-scan>
    <!--开启AspectJ生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

  4. 使用注解创建 User 和 UserProxy 对象

    @Component
public class User {
    public void add(){
        System.out.println("我要执行加法");
    }
}

    @Component
public class UserProxy {
    public void before() {//前置通知
        System.out.println("before......");
    }
}

  5. 在增强类上面添加注解 @Aspect

    @Component
@Aspect
public class UserProxy {
    public void before() {//前置通知
        System.out.println("before......");
    }
}

  6. 配置不同类型的通知：在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

    @Component
@Aspect
public class UserProxy {

    @Before(value = "execution(* atguigu.pojo.User.add(..))")
    public void before() {//前置通知
        System.out.println("Before......");
    }

    @AfterReturning(value = "execution(* atguigu.pojo.User.add(..))")
    public void afterRunning() {
        System.out.println("After Running......");
    }

    @After(value = "execution(* atguigu.pojo.User.add(..))")
    public void after() {
        System.out.println("After.........");
    }

    @AfterThrowing(value = "execution(* atguigu.pojo.User.add(..))")
    public void afterThrowing() {
        System.out.println("AfterThrowing.........");
    }

    @Around(value = "execution(* atguigu.pojo.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.........");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后.........");
    }

}

  7. 相同的切入点抽取

    @Component
@Aspect
public class UserProxy {
    @Pointcut(value = "execution(* atguigu.pojo.User.add(..))")
    public void pointCut(){

    }

    @Before(value = "pointCut()")
    public void before() {//前置通知
        System.out.println("Before......");
    }

    @AfterReturning(value = "pointCut()")
    public void afterRunning() {
        System.out.println("After Running......");
    }

    @After(value = "pointCut()")
    public void after() {
        System.out.println("After.........");
    }

    @AfterThrowing(value = "pointCut()")
    public void afterThrowing() {
        System.out.println("AfterThrowing.........");
    }

    @Around(value = "pointCut()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.........");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后.........");
    }
}

  8. 有多个增强类多同一个方法进行增强，设置增强类优先级,在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高

    @Component
@Aspect
@Order(1)
public class UserProxy {
	...
}

3.4.4 完全注解开发

创建配置类代替xml配置文件

@Configuration
@ComponentScan(value = "atguigu")
// proxyTargetClass = true:表示使用CGLIB实现代理类；默认为false:使用JDK实现代理类
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class SpringConfig {
}

代码测试：

public class Test1 {
    @Test
    public void test(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = context.getBean("user", User.class);
        user.add();
    }
}

在这里插入图片描述

3.5 配置文件方式的AOP操作（已过时，了解即可）

  1. 创建对象

    <!--创建对象-->
<bean id="user" class="atguigu.pojo.User"></bean>
<bean id="userProxy" class="atguigu.pojo.UserProxy"></bean>

  2. 在 spring 配置文件中配置切入点

    <!--配置 aop 增强-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="p" expression="execution(* atguigu.pojo.User.add(..))"/>
    <!--配置切面-->
    <aop:aspect ref="userProxy">
        <!--增强作用在具体的方法上-->
        <aop:before method="before" pointcut-ref="p"/>
    </aop:aspect>
</aop:config>
程序员aDing
关注
专栏目录
Spring：AOP
啊Q老师
08-01 5591
Spring AOP介绍
spring注解:spring aop注解详解
weixin_37862824的博客
01-09 1万+
AOP的基本概念、切面、切点、通知、环绕通知
系统学习SpringFramework：Spring AOP
栗筝i的博客
11-02 4609
本篇内容包括：Spring AOP 概述（AOP 简介、AOP 为什么叫面向切面编程、AOP 主要用来解决的问题 和 AOP 的相关术语）、Spring AOP Demo（xml 方式、注解方式）以及相关知识点（JDK 动态代理和 CGLIB 代理、Spring AOP 和 AspectJ AOP、@Aspect、@Pointcut、@Around 注解）等内容！
Spring：IOC和AOP
机械工程跑路哥
03-16 3492
IOC(控制反转)和AOP(面向方面编程)作为Spring框架的两个核心，可以很好地实现解耦合。
Spring：入门AOP案例分析
黑马程序员官方博客
06-06 1541
🍭SSM框架01：Spring的IoC和DI，以及手把手带你创建Spring核心配置文件 🍭SSM框架02：从0-1学习Spring配置文件 🍭为什么要学Spring？学什么？怎么学？ 🍭Spring到底是如何来实现IOC和DI？案例解析入门篇 🍭万字详解Spring之IOC全部知识点 🍭详解DI相关内容，一文掌握DI配置与使用 🍭Spring掌握IOC/DI配置管理第三方bean 🍭Spring核心容器环境配置、创建、依赖注入等 🍭Spring掌握IOC/DI注解管理第三方bean 🍭...
细说Spring——AOP详解（AOP概览）
热门推荐
啦啦啦的博客
05-30 53万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
Spring系列八：Spring AOP 和 AspectJ AOP 区别
退役复学在校大学生，目光所至，皆为华夏
07-27 4641
编译期织入（Compile-timeweaving）如类A使用AspectJ添加了一个属性，类B引用了它，这个场景就需要编译期的时候就进行织入，否则没法编译类B。来实现的，在容器启动时需要生成代理实例，在方法调用上也会增加栈的深度，使得SpringAOP的性能不如AspectJ的那么好。类加载后织入（Load-timeweaving）指的是在加载类的时候进行织入，要实现这个时期的织入，有几种常见的方法。AspectJ是一个易用的功能强大的AOP框架，属于。.........
深入理解Spring两大特性：IoC和AOP
null
02-14 9万+
众所周知，Spring拥有两大特性：IoC和AOP。。Spring核心容器的主要组件是Bean工厂（BeanFactory），Bean工厂使用控制反转（IoC）模式来降低程序代码之间的耦合度，并提供了面向切面编程（AOP）的实现。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的容器框架。下面，我们简要说明下这两大特性。
Spring AOP之aop:config
小9的专栏
09-15 2796
Spring在某个版本之后开始支持一组新的xml标签用来简化配置，如context，aop，mvc等，下面我们来看看aop标签的配置方法。
Spring实现AOP的三种方式
一只九菜的博客
06-19 1268
Spring实现AOP的方式有三种 方式一：使用<aop:advisor >的形式，此时要将类实现相应的接口。 方式二：使用<aop:aspect >的形式，只需要自己写的一个类，类中有定义方法即可。 方式三：使用相关的注解。@Aspect、@Before、@After 方式1代码实现： java代码： public class AfterLogClass implements AfterReturningAdvice { @Override public void
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
Spring基础：Spring AOP简单使用
05-04
- **XML配置**：在Spring的配置文件中，可以使用<aop:config>标签来定义切面，<aop:pointcut>定义切点，<aop:advisor>定义通知，<aop:aspect>将切点和通知关联起来。 - **注解配置**：Spring 2.5引入了基于注解的...
第四章：Spring AOP API 设计模式1
08-03
【Spring AOP设计模式】是Spring框架中面向切面编程的重要组成部分，它允许开发者通过分离关注点来解耦代码，实现灵活的模块化设计。在本章中，我们将探讨17种设计模式在Spring AOP中的应用和实现，以及它们如何帮助...
hualinux spring 3.15：Spring AOP.pdf
06-25
此外，需要在Spring的Bean配置文件中添加<aop:aspectj-autoproxy>元素以启用AspectJ注解的支持。 5. 声明AspectJ切面 要在Spring中声明AspectJ切面，需要在IOC容器中将切面声明为Bean实例。一旦在Spring IOC容器中...
基于java的企业级应用开发：Spring AOP简介.ppt
06-21
**Spring AOP 简介** 面向切面编程（AOP），全称为 Aspect-Oriented Programming，是一种编程范式，旨在解决传统面向对象编程（OOP）中的代码重复和分散问题。在OOP中，诸如事务管理、日志记录等功能往往会分散在多...
netty之SpringBoot+Netty+Elasticsearch收集日志信息数据存储
CSDN_LiMingfly的博客
10-04 430
将大量的业务以及用户行为数据存储起来用于分析处理，但是由于数据量较大且需要具备可分析功能所以将数据存储到文件系统更为合理。尤其是一些互联网高并发级应用，往往数据库都采用分库分表设计，那么将这些分散的数据通过binlog汇总到一个统一的文件系统就显得非常有必要。#开发环境环境准备windows安装包 下载注意 es是以来java环境 所以需要安装jdk 支持1.7以上es-hander下载可视化操作插件@Id//姓名//年龄//级别//时间//电话//邮箱//地址。
毕业设计_基于springboot+layui+mybatisPlus的中小型仓库物流管理系统源码+SQL+教程+可运行】41004
最新发布
pingguocu3的博客
10-04 737
毕业设计--课程设计--springboot--java 登录管理员账号：system 密码：123456 验证码输入：注意验证码字母要大写。启动项目后运行http://locahost:8080跳转到登录界面即可。后端：springboot、mybatis-plus、shiro。application.yml文件中的数据库连接信息。运行sql目录下的warehouse.sql文件。1.基础管理：商品管理、客户管理、供应商管理；2.物流管理：进货管理、发货管理、交付管理...
SpringBoot--为什么Controller是串行的？怎样才能并行？
IT利刃出鞘的博客
09-29 678
本文介绍SpringBoot为什么Controller是串行的？在什么场景下才能并行执行？
基于SpringBoot原创歌曲分享平台设计与实现
zhshx19900318的博客
09-29 860
在这样的背景下人类社会进入了全新的信息化的时代。在音乐分享管理页面中可以查看索引,音乐分类，音乐名称，音乐视频，区域，视频封面，发布时间，歌词，用户账号，用户姓名等内容，并进行详情，修改，查看评论和删除操作；在举报管理页面中可以查看索引,音乐名称，发布时间，用户账号，用户姓名，举报原因，审核回复，审核状态，审核等内容，并进行详情，修改，删除操作；
AspectJ：Spring AOP 实现与概念解析
本文将介绍AspectJ，一种广泛使用的面向切面编程(AOP)框架，尤其在Spring框架中被广泛应用。首先，我们假设读者已经了解AOP的基本概念，具备一定的Java编程基础和面向对象设计(OOD)的知识。 AspectJ是1998年由Xerox...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值