AOP~面向切面编程介绍

于 2024-07-28 21:26:53 发布
阅读量494 收藏 11
点赞数 16
分类专栏： javaWeb 文章标签： java 开发语言 AOP Springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61801450/article/details/140756486
版权

AOP基础

概述

  • AOP：Aspect Oriented Programming（面向切面编程、面向方面编程），面向特定方法的编程。

  • 动态代理是面向切面编程最主流的实现。

  • SpringAOP是Spring框架的高级技术，旨在管理bean对象的过程中，主要通过底层的动态代理机制，对特定的方法进行编程。

入门程序

  • 需求

    • 统计各个业务层方法的执行耗时

  • 步骤

    • 导入依赖

    • <!--        AOP依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

    • 编写代码

    • package com.testpeople.aop;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Component
@Slf4j
@Aspect //AOP类
public class TimeAspect {


    @Around("execution(* com.testpeople.service.*.*(..))") //切入点表达式
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
        //1.记录开始时间
        long begin = System.currentTimeMillis();
        //2.调用原始方法运行
        Object result = joinPoint.proceed();
        //3.记录结束时间
        long end = System.currentTimeMillis();

        //日志
        log.info(joinPoint.getSignature()+"方法执行耗时：{}ms",end-begin);

        return result;

    }

}

    • 效果

  

优势

  • 场景

    • 记录日志

    • 权限控制

    • 事务管理

  • 优势

    • 代码无侵入

    • 减少重复代码

    • 提高开发效率

    • 维护方便

核心概念

  • 连接点

    • JoinPoint,可以被AOP控制的方法（暗含方法执行时的相关信息）

  • 通知

    • Advice,指哪些重复的逻辑，也就是共性功能（体现为一个方法）

  • 切入点

    • PointCut,匹配连接点的条件，通知仅会在切入点方法执行时被应用

  • 切面

    • Aspect,描述通知与切入点的对应关系（通知+切入点）

  • 目标对象

          Target,通知所应用的对象

图解

流程

  • 进行开发后，使用的是代理对象，而不是实际对象。

AOP进阶

通知类型

  1. @Around：环绕通知，此注解标注的通知在目标方法前，后都被执行。

  2. @Before: 前置通知，此注解标注的通知方法在目标方法前被执行。

  3. @After: 后置通知，此注解标注的通知方法在目标方法被执行，无论是否异常都会执行。

  4. @AfterReturning: 返回后通知，此注解标注的通知方法在，目标方法后被执行，有异常不执行。

  5. @AfterThrowing: 异常后通知，此注解标注的通知方法发生异常后执行。

测试

package com.testpeople.aop;


import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Slf4j
@Aspect
public class MyAspect {

    @Before("execution(* com.testpeople.service.impl.DeptServiceImpl.*(..))")
    public void before(){

        log.info("前置通知");

    }

    @Around("execution(* com.testpeople.service.impl.DeptServiceImpl.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {

        log.info("环绕通知"+"before");

        Object result = joinPoint.proceed();

        log.info("环绕通知"+"after");

        return result;

    }

    @After("execution(* com.testpeople.service.impl.DeptServiceImpl.*(..))")
    public void after(){
        log.info("后置通知");

    }

    @AfterReturning("execution(* com.testpeople.service.impl.DeptServiceImpl.*(..))")
    public void afterReturning(){
        log.info("后置返回通知");
    }

    @AfterThrowing("execution(* com.testpeople.service.impl.DeptServiceImpl.*(..))")
    public  void afterThrowing(){

        log.info("后置异常通知");
    }



}

效果

注意

  • @Around：环绕通知需要自己调用 ProceedingJoinPoint.proceed();

  • @Around：环绕通知方法的返回值，必须指定为Object,来接受原始方法的返回值。

tips

  • 切入点表达式抽取

package com.testpeople.aop;


import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Slf4j
@Aspect
public class MyAspect {

    @Pointcut("execution(* com.testpeople.service.impl.DeptServiceImpl.*(..))")
    private void pt(){

    }
    //这个方法可以改修订范围，然后被别的包引用。


    @Before("pt()")
    public void before(){

        log.info("前置通知");

    }

    @Around("pt()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {

        log.info("环绕通知"+"before");

        Object result = joinPoint.proceed();

        log.info("环绕通知"+"after");

        return result;

    }

    @After("pt()")
    public void after(){
        log.info("后置通知");

    }

    @AfterReturning("pt()")
    public void afterReturning(){
        log.info("后置返回通知");
    }

    @AfterThrowing("pt()")
    public  void afterThrowing(){

        log.info("后置异常通知");
    }



}

通知顺序

  • 不同切面类中，默认按照切面类的类名字母排序

    • 目标方法前的通知方法：字母排名靠前的先执行。

    • 目标方法后的通知方法：字母排名靠前的后执行。

  • 用@Order(数字)加在切面类上来控制顺序

    • 目标方法前的通知方法：数字小的先执行

    • 目标方法后的通知方法：数字小的后执行

  • 概述

    • 描述切入点方法的一种表达式

  • 作用

    • 主要用来决定项目中的哪些方法需要加入通知

  • 常见形式

    • execution(...)；根据方法的签名来匹配

  • 特殊符号

  • 如果匹配两个方法，可以使用“||”连接。

  • Tips

  • @annotation(...)；根据注解匹配

    • 新建注解

    • package com.testpeople.aop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME) //合适生效（运行是）
@Target(ElementType.METHOD)//作用到哪里（方法）
public @interface MyLog {


}

    • 在需要添加方法上添加注解，更换切入点表达式。

    • @Around("@annotation(com.testpeople.aop.MyLog)")

连接点

  • 开发

  • @Around("@annotation(com.testpeople.aop.MyLog)")
public Object testJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {

    //1.获取 目标对象的类名
    String className = joinPoint.getTarget().getClass().getName();
    log.info(className);
    //2.获取 目标方法的方法名
    String methodName = joinPoint.getSignature().getName();
    log.info(methodName);
    //3.获取 目标方法运行时传入的参数
    Object[] methodArgs = joinPoint.getArgs();
    log.info(Arrays.toString(methodArgs));
    //4.放行 目标方法执行
    Object result = joinPoint.proceed();

    //5.获取 目标方法的返回值
    log.info(result.toString());

    return result;//此处可以改变函数的返回结果(添加其他方法)
}

效果

AOP案例(操作日志记录功能)

需求

  • 将案例中 增、删、改相关的接口的操作日志记录到数据库表中

  • 日志信息~操作人、操作时间、执行方法的全类名、执行方法、方法运行时的参数、返回值、方法执行的时长。

思路

步骤

  • 准备

    • 在案例中引入AOP的依赖

    • <!--        AOP依赖-->

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

    • 设计好数据库表

    • # 操作日志记录表
create table operate_log(
    id int unique primary key auto_increment comment 'ID',
    operate_user int unsigned comment '操作人ID',
    operate_time datetime comment '操作时间',
    class_name varchar(100) comment '操作类名',
    method_name varchar(100) comment '操作方法名',
    method_params varchar(1000) comment '操作方法参数',
    return_value varchar(2000) comment '返回值',
    cost_time bigint comment '耗时,单位:ms'
) comment '操作日志记录表';

    • 设计好实体类

    • package com.testpeople.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDateTime;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class OperateLog {

    private Integer id;//ID

    private Integer operateUser;//操作人ID

    private LocalDateTime operateTime;//操作时间

    private String className;//操作类名

    private String methodName;//方法名

    private String methodParams;//方法参数

    private String returnValue;//返回值

    private Long costTime;//耗时

}

    • Mapper接口

    • package com.testpeople.mapper;

import com.testpeople.pojo.OperateLog;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface OperateLogMapper {

    //插日志数据

    @Insert("insert into operate_log (operate_user,operate_time,class_name,method_name,method_params,return_value,cost_time) " +
            "values(#{operateUser},#{operateTime},#{className},#{methodName},#{methodParams},#{returnValue},#{costTime})")
    void insert(OperateLog operateLog);

}

    • 编码

      • 自定义注解

      • package com.testpeople.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Log {
}

      • 定义切面类，完成记录操作日志的逻辑

      • package com.testpeople.aop;

import com.alibaba.fastjson.JSONObject;
import com.testpeople.mapper.OperateLogMapper;
import com.testpeople.pojo.OperateLog;
import com.testpeople.utils.JwtUtils;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.Arrays;

@Slf4j
@Component
@Aspect
public class LogAspct {

    @Autowired
    private HttpServletRequest request;

    @Autowired
    private OperateLogMapper operateLogMapper;

    @Around("@annotation(com.testpeople.anno.Log)")
    public Object recordLog(ProceedingJoinPoint joinPoint) throws Throwable {

        //操作人ID~ 当前员工ID
        //获取请求头中的jwt令牌中的员工ID
        String jwt = request.getHeader("token");
        //解析
        Integer operateUser = (Integer) JwtUtils.parseJwt(jwt).get("id");
        //操作时间
        LocalDateTime operateTime = LocalDateTime.now();
        //类名
        String className = joinPoint.getTarget().getClass().getName();
        //方法名
        String methodName = joinPoint.getSignature().getName();
        //方法参数
        Object[] args = joinPoint.getArgs();
        String methodParams = Arrays.toString(args);

        //记录时间
        long begin = System.currentTimeMillis();

        //调用原始目标方法运行
        Object result = joinPoint.proceed();
        
        //记录结束时间
        
        long end = System.currentTimeMillis();
        
        //方法返回值
        String returnValue = JSONObject.toJSONString(result);
        //耗时
        long costTime = end - begin;


        //记录操作日志

        OperateLog operateLog = new OperateLog();

        operateLog.setOperateUser(operateUser);
        operateLog.setOperateTime(operateTime);
        operateLog.setClassName(className);
        operateLog.setMethodName(methodName);
        operateLog.setMethodParams(methodParams);
        operateLog.setReturnValue(returnValue);
        operateLog.setCostTime(costTime);

        operateLogMapper.insert(operateLog);

        log.info("AOP记录操作日志 {}",operateLog.toString()+"\n");

        return result;

    }


}

      • 给有需求的类添加@Log注解

效果

注意

  • 获取当前用户

    • 从request中获取token 在token中提取当前用户id

以上是对SpringBoot框架中的AOP相关的介绍以及简单的使用，通过一个操作记录日志功能进行练习。多点关注、多点爱。（以上知识点笔记来自于小编学习黑马程序员的课程所记录）

项目地址

admin_web_project: 黑马程序员项目javaWebjavaWeb开发学习仓库，前后端分离项目前端Vue后端springboot数据库Mysql

jie~TestPeo
关注
  • 16
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring——面向切面编程(AOP)
行者无疆的博客
06-05 3593
本文介绍了切向切面编程(AOP)中的各个概念，并用两个案例分别讲解了如何通过注解和XML配置的方式使用AOP。
AOP（面向切面编程）
m0_58487321的博客
04-21 2158
AOP（面向切面编程）注解
AOP(面向切面编程)
m0_65431718的博客
05-09 6163
对aop的理解
AOP——面向切面编程
m0_62912377的博客
05-05 7570
AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构。 OOP(Object Oriented Programming)面向对象编程，是一种编程思想，所以，AOP也是一种编程思想，只是他们两个是不同的编程范式。
AOP（面向切面编程）详解
suqieer的博客
05-13 1338
AOP 通过“切面”模块化跨多个类的功能，这些功能通常与业务逻辑不直接相关。AOP 的核心概念是“切面”（Aspect）和“连接点”（Joinpoint）。切面（Aspect）：一组同时横切多个类的代码，封装成一个单元。连接点（Joinpoint）：程序执行的特定点，如方法的调用或执行。
【Spring AOP】面向切面编程
书生-w的博客
06-18 6621
AOP是面向切面编程，是一种思想，是对某一类事情的集中处理，其核心思想是将那些与业务逻辑无关，但是被多处业务逻辑模块共享的代码（比如日志管理，权限检查，事务管理等）抽取出来，通过预编译方式和运行期动态代理实现程序功能的统一维护的方式。这样，开发者可以将更多的精力放在处理核心业务逻辑上。 AOP是一种思想，Spring AOP是一种具体实现的框架
【Spring】 AOP面向切面编程
Orion
02-23 1387
横切关注点从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。有十个附加功能，就有十个横切关注点。AOP核心关注点和横切关注点。业务处理的主要流程是核心关注点，非核心代码是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事务、异常等。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。(分离核心业务代码与非核心代码通知(增强)每一个横切关注点。
SpringAOP面向切面编程
trong_ 的烂笔头
09-09 2051
介绍面向切面编程的思想（AOP），AOP的组成，SpringAOP的简单演示使用，SpringAOP基于动态代理的实现原理。
AOP面向切面编程
weixin_45723046的博客
03-26 817
AOP 什么是AOP AOP (Aspect Oriented programming)意为:面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性。 Aop在Spring中的作用：提供声明式的事务，允许用户自定义切面 横切关注点:跨越应用程序多个模块的方法或功能。即是
MVC AOP面向切面编程简单介绍及实例
08-31
面向切面编程（AOP，Aspect Oriented Programming）是一种编程范式，旨在提供更好的模块化和组织代码的方式，尤其在处理系统中横切关注点时。MVC（Model-View-Controller）架构模式则是一种用于构建Web应用程序的...
aop 面向切面编程 demo
11-16
面向切面编程（AOP）是一种编程范式，它旨在将关注点分离，使得系统中的核心业务逻辑与系统服务（如日志、事务管理、权限控制等）可以解耦。在Android开发中，AOP的应用可以帮助我们更好地组织代码，提高可维护性和...
浅谈Android面向切面编程（AOP）
01-04
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是...
aop.rar_面向切面编程
09-24
面向切面编程（AOP，Aspect Oriented Programming）是一种编程范式，旨在将关注点分离，使得系统中的横切关注点（如日志、事务管理、权限检查等）能够独立于核心业务逻辑进行处理。AOP的核心概念包括切面、连接点、...
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
golang 接口
m0_70982551的博客
07-24 863
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 385
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 540
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 466
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 342
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值