AOP

最新推荐文章于 2024-11-09 11:25:35 发布
最新推荐文章于 2024-11-09 11:25:35 发布
阅读量62 收藏
点赞数
分类专栏： Spring 文章标签： aop spring java
原文链接：https://www.bilibili.com/video/BV1WE411d7Dv?p=20&share_source=copy_web
版权

1、简介

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

在这里插入图片描述

在这里插入图片描述

2、AOP在Spring中的作用

提供了声明式事务；允许用户自定义切面。

  • 横切关注点：跨越应用程序多个模块的方法或功能。即与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点，例如：日志、安全、缓存、事务等……
  • 切面（ASPECT）:横切关注点被模块化的特殊对象。即它是一个类，例如：日志类等……
  • 通知（Advice）：切面必须要完成的工作。即它是切面（类）中的一个方法；
  • 目标（Target）：被通知对象；
  • 代理（Proxy）：向目标对象应用统治之后创建的对象；
  • 切入点（PointCut）：切面通知执行的地点的定义；
  • 连接点（JointPoint）：与切入点匹配的执行点。

3、使用Spring实现AOP

【重点】使用AOP织入，需要导入一个依赖包；

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

3.1、方式一：使用Spring的API接口

  1. 编写UserService接口，Log，AfterLog类；

    package com.beyond.service;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

    package com.beyond.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {
    /*
    method：要执行的目标对象的方法；
    objects：参数
    o：目标对象
     */
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

    package com.beyond.log;


import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {

    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}

  2. 编写applicationContext.xml；

    <?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="log" class="com.beyond.log.Log"/>
    <bean id="afterlog" class="com.beyond.log.AfterLog"/>

    <!--方式一：使用原生Spring API接口-->
    <!--配置aop：需要导入aop的约束-->
    <aop:config>
        <!--pointcut（切入点），expression（表达式，即要执行的位置）

       任意公共方法的执行：execution(public * (..))

       任何一个以“set”开始的方法的执行：execution( set(..))

       AccountService 接口的任意方法的执行：execution( com.xyz.service.AccountService.(..))

       定义在service包里的任意方法的执行：execution( com.xyz.service..(..))

       定义在service包和所有子包里的任意类的任意方法的执行：execution(* com.xyz.service...(..))

       定义在pointcutexp包和所有子包里的JoinPointObjP2类的任意方法的执行：execution(* com.test.spring.aop.pointcutexp..JoinPointObjP2.*(..))")
        -->
        <aop:pointcut id="pointcut" expression="execution(* com.beyond.service.UserServiceImpl.*(..))"/>

        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

  3. 测试。

    import com.beyond.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        //动态代理代理的是接口
        UserService userservice = context.getBean("userservice", UserService.class);

        userservice.query();
    }
}

3.2、方式二：自定义类实现AOP

  1. 编写UserService接口，UserServiceImpl实现类，自定义DiyPointCut类；

    package com.beyond.service;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

    package com.beyond.service;

public class UserServiceImpl implements UserService{
    public void add() {
        System.out.println("增加一个用户");
    }

    public void delete() {
        System.out.println("删除一个用户");
    }

    public void update() {
        System.out.println("修改一个用户");
    }

    public void query() {
        System.out.println("查询一个用户");
    }
}

    package com.beyond.diy;

public class DiyPointCut {
    public void before(){
        System.out.println("===========方法执行前==============");
    }

    public void after(){
        System.out.println("===========方法执行后==============");
    }
}

  2. 编写applicationContext.xml；

    <?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!--注册bean-->
    <bean id="userservice" class="com.beyond.service.UserServiceImpl"/>

    <!--方式二：自定义类-->
    <bean id="diy" class="com.beyond.diy.DiyPointCut"/>

    <aop:config>
        <!--自定义切面，ref：要引用的类-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* com.beyond.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

</beans>

  3. 测试。

    import com.beyond.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        //动态代理代理的是接口
        UserService userservice = context.getBean("userservice", UserService.class);

        userservice.query();
    }
}

3.3、方式三：使用注解实现AOP

  1. 编写UserService接口，AnnotationPointCut类；

    package com.beyond.service;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

    package com.beyond.diy;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

//使用注解实现AOP
@Aspect
public class AnnotationPointCut {
    @Before("execution(* com.beyond.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("===========方法执行前==============");
    }

    @After("execution(* com.beyond.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("===========方法执行后==============");
    }

    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理的切入的点
    @Around("execution(* com.beyond.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint pj) throws Throwable {
        System.out.println("环绕前==============");

        //执行方法
        Object proceed = pj.proceed();

        //获得签名
        Signature signature = pj.getSignature();
        System.out.println("签名："+signature);

        System.out.println("环绕后==============");

    }
}

  2. 编写applicationContext.xml；

    <?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--方式三：使用注解实现AOP-->
    <bean id="annotationPointCut" class="com.beyond.diy.AnnotationPointCut"/>
    <!--开启注解支持      JDK(默认 proxy-target-class="false")    cglib（proxy-target-class="true"）-->
    <aop:aspectj-autoproxy/>

</beans>

  3. 测试。

    import com.beyond.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        //动态代理代理的是接口
        UserService userservice = context.getBean("userservice", UserService.class);

        userservice.query();
    }
}
SpringAOP(图文详解)
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Aop实现日志功能
qq_44392492的博客
05-24 7256
Aop实现日志功能1、创建表和日志实体2、编写dao、service类3、导入maven依赖4、编写注解和切面类5、配置所需要的工具类6、系统测试 众所周知AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。可以对业务方法进行扩展，常用在缓存，日志、权限等方面。这里我用aop对日志进行一个小demo演示，帮助自己更好的理解和使用aop的功能。 本案例基于一个小的增删改查的demo，用s
细说Spring——AOP详解（AOP概览）
热门推荐
啦啦啦的博客
05-30 53万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
Spring AOP 详解
2301_80035594的博客
10-19 3181
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
SpringAOP学习--SpringAOP简介及原理
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
在Spring AOP切面中启用新事务
yjclsx的博客
07-31 43万+
在工作中有一个在切面中需要记录一下操作日志的需求，而且要求这些操作日志要存入数据库，并且无论业务层有什么异常，日志照常记录，那就不能沿用业务层的事务，而是需要新启一个事务了。 sping的声明式事务就是靠AOP来实现的，一般事务都在业务层中启用，那如果要在AOP的逻辑中启用一个新的事务要怎么做呢？比如下面的例子： //定义一个切点，这里指com.lidehang.remote包下所有的类的方法...
AOP详解
北京叮咚的博客
05-18 6758
文章目录 目录 前言 二、设计模式 三、名词解释 四、代码 方式一 方式二 方式三：注解 总结 前言 Spring的两大核心是IOC和AOP，其中IOC是指控制反转，指的是bean对象无需用户手动维护，全部交由Spring管理；AOP大家都知道是面向切面，但是什么是面向切面，这里面由涉及的一些名词如何理解，我们如何理解并使用AOP，在这里我们简单聊一下 一、AOP是什么？ AOP（Aspect-Oriented Programming，面向方面编程），可以说是OOP...
深入理解Spring两大特性：IoC和AOP
null
02-14 9万+
众所周知，Spring拥有两大特性：IoC和AOP。。Spring核心容器的主要组件是Bean工厂（BeanFactory），Bean工厂使用控制反转（IoC）模式来降低程序代码之间的耦合度，并提供了面向切面编程（AOP）的实现。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的容器框架。下面，我们简要说明下这两大特性。
简单了解AOP
2302_78100610的博客
09-16 1486
AOP（面向切面编程）：一、概念解释AOP 即 Aspect Oriented Programming，意为面向切面编程。它是通过预编译方式和运行期间动态代理实现程序功能统一维护的一种技术。AOP 是面向对象编程（OOP）的延续，在 Java 开发中占据重要地位。它能够将业务逻辑和非业务逻辑进行隔离，比如将日志记录、事务管理、权限验证等与核心业务逻辑分离，从而降低各部分之间的耦合度，提高程序的可重用性和开发效率。二、核心原理AOP 的核心原理是使用动态代理的方式在执行方法前后或者出现异常的时候加入相关的逻辑
Java利用spring aop进行监测方法执行耗时
05-25
使用 Spring AOP 进行方法耗时监测的好处有以下几点： 1. 代码实现简单，易于维护：使用 Spring AOP 可以将耗时监测的逻辑与业务逻辑进行解耦，避免业务逻辑代码的冗余和代码维护难度的提高。 2. 安全性高：使用 ...
AndroidAop:aop aop样本
05-16
AndroidAop aop 小栗子 为什么要用Aop 简化我们的代码，对于公用的逻辑我们可以抽取出来统一处理。比如对于很多地方我们 都需要判断网络是否连接，如果连接，那么页面上的一些按钮点击之后是可以成功发出 请求与后台...
aopalliance-1.0 jar包
04-27
**aopalliance-1.0 jar包** 在Java开发领域，AOP（Aspect Oriented Programming，面向切面编程）是一种强大的设计模式，它允许程序员将关注点分离，比如日志、事务管理等横切关注点，从核心业务逻辑中解耦。aop...
SpringBoot+AOP+TraceID.pdf
01-04
SpringBoot+AOP+TraceID.pdf 本文档主要讲解了 SpringBoot 中 AOP（Aspect Oriented Programming）的应用和 TraceID 的实现。 AOP 基本概念 AOP 的 existence 目的是为了解耦，使得一组类可以共享相同的行为。在 ...
aop
05-07
AOP是对OOP的补充和完善，它允许开发人员动态修改OOP定义的静态对象模型--- 开发者可以不用修改原始的OOP对象模型，甚至无须修改OOP代码本身，就能够 解决“多个不具有继承层次的对象引入同一公共行为”的问题
SpEL（Spring Expression Language）入门指南
kersixy的博客
11-05 695
SpEL（Spring Expression Language）是 Spring 框架提供的一个强大的表达式语言，用于在运行时查询和操作对象图。它类似于 JSP EL（JavaServer Pages Expression Language）和 OGNL（Object-Graph Navigation Language），但在功能上更为丰富和强大。
后端SpringBoot及vue proxyTable解决跨域
qq_42059717的博客
11-06 285
昨天上线项目遇到了一个奇怪的问题，本来服务实在腾讯云的轻量应用服务器的，但是迁移到一个香港的服务器之后就出现了各种各样的问题。Nginx 开启Https Springboot开启Https，先后出现了噔噔蹬蹬但是我其实已经部署了一个项目了的，那个用的proxyTable,新部署的这个用的是里边的env控制的。后来改成proxyTable就好了。
Spring中@Autowired@Resource和@Inject注解区别
2401_87333857的博客
11-06 425
同时，它默认是采用byType装配，当指定了1SR-330规范中的@Named注解之后，变成byName装配。它也可以出现在方法上，构造函数上和字段上但是需要注意的是:因为IRE无法决定构造方法注入的优先级，所以规范中规定类中只能有一个构造方法带@Inject注解。@Autowired:来源于spring框架自身默认是byType自动装配，当配合了@Qualifier注解之后，在没有指定name属性时是byType自动装配，当指定了name属性之后，采用byName方式自动装配。
SpringBoot助力的共享汽车业务优化系统
最新发布
2402_85762143的博客
11-09 869
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。近来，软件工程界趋向于一种新的观点，即认为软件生命周期每一阶段中都应包含测试，从而检验本阶段的成果是否接近预期的目标，尽可能早的发现错误并加以修正，如果不在早期阶段进行测试，错误的延时扩散常常会导致最后成品测试的巨大困难。任务：消除软件故障，保证程序的可靠运行。
Spring AOP实践与理解
本文主要探讨了Spring AOP的使用和实现方式，通过实例解析了Spring AOP在项目中的应用，特别是针对日志记录和性能测试的需求。文章提到了Spring AOP的两种实现方式——JDK动态代理和CGLIB，并探讨了它们之间的区别。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值