AOP面向切面编程

最新推荐文章于 2024-07-12 13:59:10 发布
最新推荐文章于 2024-07-12 13:59:10 发布
阅读量158 收藏
点赞数
文章标签： aop spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Young_Naive/article/details/108957946
版权

AOP（面向切面编程）

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

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

底层原理

  1. AOP底层使用动态代理方式
    • 有两种情况的动态代理
    • 有接口情况，使用JDK动态代理
    • 没有接口情况，使用CGLIB动态代理

有接口情况，使用JDK动态代理

创建UserDao接口实现类代理对象，增强类的方法image-20201007084912912

没有接口情况,使用CGLIB动态代理

创建当前类子类的代理对象image-20201007085245339

AOP（JDK动态代理）

  1. 使用JDK动态代理，使用Proxy类里面的方法创建代理对象image-20201007085625842
  2. 调用newProxyInstance方法来实现，有三个参数
    • 类加载器
    • 增强方法所在的类，类实现的接口，支持多个接口
    • 实现这个接口InvocationHandler，创建代理对象，写增强的方法

image-20201007085805054

  1. 编写JDK动态代理代码

    • 创建接口，定义方法

      public interface UserDao {

    int add(int a,int b);
    
    String update(String id);
}

    • 创建接口实现类，实现方法

      public class UserDaoImpl implements UserDao{
    public int add(int a, int b) {
        return a+b;
    }

    public String update(String id) {
        return id; 
    }
}

    • 使用Proxy创建接口的代理对象

      public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类的代理对象
        UserDao userDao = new UserDaoImpl();
        Class[] interfaces = {UserDao.class};
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int res = dao.add(1, 2);
        System.out.println("result = "+res);
    }
}

//创建代理对象代码
class UserDaoProxy implements InvocationHandler {
    //把创建的代理对象的本体传递过来
    //有惨构造进行传递
    private Object obj;

    public UserDaoProxy(Object obj) {
        this.obj = obj;
    }

    //增强的逻辑
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前
        System.out.println("方法前执行 : " + method.getName() + "传递的参数：" + Arrays.toString(args));
        //被增强的方法执行
        Object res = method.invoke(obj, args);
        //方法之后
        System.out.println("方法后执行 : " + obj);
        return res;
    }
}

AOP术语

  1. 连接点，类里面哪些方法可以被增强，这些方法称为连接点
  2. 切入点，实际被增强的方法，称为切入点
  3. 通知（增强），
    • 实际增强的逻辑部分称为通知（增强）
    • 通知有多种类型，前置通知,后置通知,环绕通知,异常通知，最终通知（finally）
  4. 切面:把通知应用到切入点的过程

AOP操作（准备）

  1. Spring框架中，一般基于AspectJ实现AOP操作

    AspectJ：不是spring组成部分，独立AOP框架，一半把AspectJ与Spring框架一起使用。进行AOP相关操作

  2. 基于AspectJ实现AOP操作

    • 基于xml配置文件
    • 基于注解方式（使用）

  3. 在项目工程中引入AOP相关依赖

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>

  4. 切入点表达式

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

    举例1：对com.yang.dao.Book类里面的add进行增强

    execution(* com.yang.dao.Book.add(..))

    举例2：对com.yang.dao.Book类里面的所有方法进行增强

    execution(* com.yang.dao.Book.*(..))

    举例3：对com.yang.dao包里面的所有类里面的所有包进行增强

    execution(* com.yang.dao.*.*(..))

AOP操作（AspectJ注解）

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

    public class User {
    public void add(){
        System.out.println("add,,,,");
    }
}

  2. 创建增强类(编写增强的逻辑)

    在增强类里面创建方法，让不同方法代表不同通知类型

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

  3. 进行通知的配置

    • 在Spring配置文件中，开启注解扫描

      <?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="com.yang.aopanno"/>
</beans>

    • 使用注解创建Userh和UserProxy对象

      package com.yang.aopanno;

import org.springframework.stereotype.Component;

//被增强类
@Component
public class User {
    public void add(){
        System.out.println("add,,,,");
    }
}

      package com.yang.aopanno;

import org.springframework.stereotype.Component;

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

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

    • 在Spring配置文件中，开启生成代理对象

      <aop:aspectj-autoproxy/>

    • 配置不同类型的通知

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

package com.yang.aopanno;

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

//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.yang.aopanno.User.add(..))")
    public void before() {
        System.out.println("before........");
    }
    //最终通知
    @After(value = "execution(* com.yang.aopanno.User.add(..))")
    public void after() {
        System.out.println("after.........");
    }
    //后置通知（返回通知），有异常不执行
    @AfterReturning(value = "execution(* com.yang.aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning....");
    }

    @AfterThrowing(value = "execution(* com.yang.aopanno.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing....");
    }
    @Around(value = "execution(* com.yang.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前。。。");
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后。。。");
    }
}

公共切入点提取

//相同切入点抽取
@Pointcut(value = "execution(* com.yang.aopanno.User.add(..))")
public void pointDemo(){

}
@Before(value = "pointDemo()")
public void before() {
    System.out.println("before........");
}

有多个增强类对同一个方法进行增强，设置增强类优先级

  1. 在增强类上面添加注解@Order(数字类型值),数字类型值越小，优先级越高

    @Component//对象创建
@Aspect//代理对象创建
@Order(1)
public class PersonProxy {
    @Before(value = "execution(* com.yang.aopanno.User.add(..))")
    public void before(){
        System.out.println("Person before......");
    }
}

  2. 
@ComponentScan(basePackages = {"com.yang"})
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class MyConfig {

}

AOP操作（AspectJ配置文件）

  1. 创建两个类，增强类和被增强类，创建方法

  2. 在spring配置文件中创建两个类对象

    <!--    创建对象-->
<bean id="book" class="com.yang.aopxml.Book"/>

<bean id="bookProxy" class="com.yang.aopxml.BookProxy"/>

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

        <!--    创建对象-->
    <bean id="book" class="com.yang.aopxml.Book"/>

    <bean id="bookProxy" class="com.yang.aopxml.BookProxy"/>
<!--    配置aop增强-->
    <aop:config>
<!--        配置切入点-->
        <aop:pointcut id="p" expression="execution(* com.yang.aopxml.Book.buy(..))"/>
<!--        配置切面-->
        <aop:aspect ref="bookProxy">
<!--            增强在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>
来旺
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
AOP——面向切面编程
m0_62912377的博客
05-05 7922
AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构。 OOP(Object Oriented Programming)面向对象编程，是一种编程思想，所以，AOP也是一种编程思想，只是他们两个是不同的编程范式。
AOP（面向切面编程）的基本概念和原理
jakelihua
01-05 1832
日志记录是软件开发中一项重要的工作，它帮助开发人员了解系统的运行状态、排查问题以及进行性能分析。然而，将日志记录与业务逻辑混合在一起可能导致代码的臃肿，降低了代码的可读性和可维护性。在这种情况下，AOP可以提供一种优雅的解决方案。首先，我们需要定义一个日志记录的切面。这个切面包含了在业务逻辑执行前后记录日志的代码。// 在业务逻辑执行前记录日志// 在业务逻辑执行后记录日志事务管理是数据库操作中一个重要的方面，确保数据库操作的一致性和完整性。
编程范式之面向切面编程（AOP）
最新发布
cooldream2009的博客
07-12 1159
在现代软件开发中，代码的可维护性和可重用性变得越来越重要。为了应对这些挑战，开发者不断探索新的编程范式。其中，面向切面编程（Aspect-Oriented Programming, AOP）作为一种新的编程方法，逐渐受到关注。本文将详细介绍面向切面编程的定义、特点、适用场景、优点、缺点，以及代表性的编程语言和示例代码。
什么是面向切面编程
岛田悠米
05-17 2824
        面向切面编程（AOP是Aspect Oriented Program的首字母缩写） ，我们知道，面向对象的特点是继承、多态和封装。而封装就要求将功能分散到不同的对象中去，这在软件设计中往往称为职责分配。实际上也就是说，让不同的类设计不同的方法。这样代码就分散到一个个的类中去了。这样做的好处是降低了代码的复杂程度，使类可重用。        &n
面向切面编程（AOP）的理解
热门推荐
Intlgj的专栏
06-14 6万+
<br />在传统的编写业务逻辑处理代码时，我们通常会习惯性地做几件事情：日志记录、事务控制及权限控制等，然后才是编写核心的业务逻辑处理代码。当代码编写完成回头再看时，不禁发现，扬扬洒洒上百行代码中，真正用于核心业务逻辑处理才那么几行，如图6-4所示。方法复方法，类复类，就这样子带着无可奈何遗憾地度过了多少个春秋。这倒也罢，倘若到了项目的尾声，突然决定在权限控制上需要进行大的变动时，成千上万个方法又得一一"登门拜访"，痛苦"雪上加霜"。 <br />如果能把图6-4中众多方法中的所有共有代码全部抽取出来，放
aop 面向切面编程 demo
11-16
面向切面编程（AOP）是一种编程范式，它旨在将关注点分离，使得系统中的核心业务逻辑与系统服务（如日志、事务管理、权限控制等）可以解耦。在Android开发中，AOP的应用可以帮助我们更好地组织代码，提高可维护性和...
AOP面向切面编程实例
05-17
面向切面编程（Aspect-Oriented Programming，简称AOP）是一种编程范式，它旨在提高软件的模块化程度，通过将关注点分离到不同的“切面”中来实现。在.NET环境中，AOP通常通过拦截器（Interceptor）或动态代理...
AOP面向切面编程总结
08-22
### AOP面向切面编程详解 #### 一、AOP概览 AOP（Aspect-Oriented Programming，面向切面编程）是一种编程思想和技术，它作为OOP（面向对象编程）的一种补充，主要解决了OOP在处理横切关注点方面的不足。在传统的...
SpringBoot整合aop面向切面编程过程解析
08-24
SpringBoot整合AOP面向切面编程过程解析 AOP（Aspect Oriented Programming），即面向切面编程，是一种编程技术，通过预编译方式和运行期动态代理实现程序功能的统一维护。AOP是Spring框架中的一个重要内容，它通过...
面向切面编程（AOP)
zyn2091872563的博客
07-21 1044
面向切面编程(AOP)定义: 定义:将程序中共同的非核心业务逻辑封装成切面，降低模块间耦合度的编程思想。 AOP实现效果 效果：将影响多个类的公共行为封装成一个可重用模块，减少系统重复代码，降低模块间的耦合度，提高复用性和可维护性 为了更好地理解 AOP，我们需要了解一些它的相关术语。这些专业术语并不是 Spring 特有的，有些也同样适用于其它 AOP 框架，如 AspectJ。它们的含义如下表所示。 名称 说明 Joinpoint（连接点） ...
（2021.9.25）面向切面编程简述
qq_23665305的博客
09-25 2685
说到面向切面编程，想必大家都不会陌生。不就是AOP——Aspect Orient Programming 但是说了那么久，你所理解的面向切面编程，用一句话概括到底是什么呢？ 1.什么是AOP（面向切面编程） 在我的理解来说： 在运行时，动态的 将代码切入到 类的 指定方法。 这种编程思想就成为面向切面编程 来举个例子吧,你写了A方法之后，老板想让你看看这段代码的执行时间。ok，那你就在A方法的前后加上代码，查看时间。。。 过了几天，你又完成了B方法之后，老板又想让看你记录这段代码的日志...
Spring核心AOP（面向切面编程）总结
冷血之心的博客
07-16 3万+
（尊重劳动成果，转载请注明出处：http://blog.csdn.net/qq_25827845/article/details/75208354冷血之心的博客） 目录 1、AOP概念： 2、AOP特点： 3、AOP底层实现： JDK动态代理实现： cglib动态代理实现： 代理方式的选择： 静态代理和动态代理的区别： 4、AOP原理 5、AOP操作术语： 6、AOP操作案例...
Spring零基础入门到精通 --- AOP面向切面编程
shuai_h的博客
03-28 919
事务是开发中必不可少的东西，使用JDBC开发时，我们使用connnection对事务进行控制，使用MyBatis时，我们使用SqlSession对事务进行控制，缺点显而易见，当我们切换数据库访问技术时，事务控制的方式总会变化，Spring 就将这些技术基础上，提供了统一的控制事务的接口。Spring的事务分为：编程式事务控制 和 声明式事务控制事务控制方式解释编程式事务控制Spring提供了事务控制的类和方法，使用编码的方式对业务代码进行事务控制，事务控制代码和业务操作代码耦合到了一起，开发中不使用。
AOP（面向切面编程）详解
suqieer的博客
05-13 2309
AOP 通过“切面”模块化跨多个类的功能，这些功能通常与业务逻辑不直接相关。AOP 的核心概念是“切面”（Aspect）和“连接点”（Joinpoint）。切面（Aspect）：一组同时横切多个类的代码，封装成一个单元。连接点（Joinpoint）：程序执行的特定点，如方法的调用或执行。
【学习笔记】 面向切面编程的全面认知
Xcong_Zhu的博客
04-06 1339
从理解AOP的概念你开始入手
AOP面向切面编程的测试代码
07-20
以下是一个简单的AOP面向切面编程的测试代码示例，使用Spring框架实现： 首先，创建一个切面类 `LoggingAspect`，用于定义切面逻辑： ```java import org.aspectj.lang.JoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.stereotype.Component; @Aspect @Component public class LoggingAspect { @Before("execution(* com.example.service.*.*(..))") public void beforeAdvice(JoinPoint joinPoint) { System.out.println("Before method: " + joinPoint.getSignature().getName()); } @After("execution(* com.example.service.*.*(..))") public void afterAdvice(JoinPoint joinPoint) { System.out.println("After method: " + joinPoint.getSignature().getName()); } } ``` 然后，创建一个测试服务类 `UserService`，用于演示AOP的应用： ```java import org.springframework.stereotype.Service; @Service public class UserService { public void createUser(String username) { System.out.println("Creating user: " + username); } public void deleteUser(String username) { System.out.println("Deleting user: " + username); } } ``` 最后，创建一个Spring Boot应用程序，并在启动类中进行配置： ```java import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.EnableAspectJAutoProxy; @SpringBootApplication @EnableAspectJAutoProxy public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); UserService userService = context.getBean(UserService.class); userService.createUser("John"); userService.deleteUser("John"); } } ``` 在上述示例中，`LoggingAspect` 切面类使用 `@Before` 和 `@After` 注解分别定义了在目标方法执行前和执行后的逻辑。切面逻辑会应用于 `UserService` 类中的所有方法。 当运行应用程序时，可以看到切面逻辑在方法执行前和执行后打印了相应的日志消息。 这是一个简单的AOP面向切面编程的示例，你可以根据实际需求进行更复杂的切面逻辑定义和应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值