AOP日志高级写法

于 2023-12-13 11:45:33 发布
阅读量434 收藏 8
点赞数 12
文章标签： 开发语言 java springboot spring cloud spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38798644/article/details/134968356
版权

场景：在日程开发过程中，通常需要记录某接口操作的日志，但是需要的参数需要通过查询数据库后才有，有的数据需要当前接口操作完成之后才有的，或者更加复杂的自定义规则。那么普通方式的aop切面日志就不太够用了
先看使用后的案例

@RestController
@RequestMapping("/job")
@Api(tags = "职位模块")
@OperationLog(logClass = JobLogService.class) //标记使用的logService类
public class JobController {
    @OperationLogHandler(isAfterMethod = true) //标记需要保存日志的方法 isAfterMethod 表示需要方法执行后再保存日志
    @PostMapping("/operate/status")
    @ApiOperation("职位状态操作（审核职位/分配负责人/拒绝/停止招聘）")
    public void operateStatus(@RequestBody @Valid JobOperateDTO jobOperateDto) {
        jobService.operate(userDto, jobOperateDto);
    }
}
//日志服务类
@Service
public class JobLogService {
     @Resource
    private JobService jobService;
    @Resource
    private SysUserMapper sysUserMapper;
    //对应的方法  需要方法名称 参数完全一致  返回类型为自定义的类(Content)
    public Content operateStatus(JobOperateDTO jobOperateDto) {
        Optional<Status> statusOptional = Arrays.stream(Status.values()).filter(status -> status.getItem().equals(jobOperateDto.getStatus())).findFirst();
        if (statusOptional.isPresent()) {
            JobModelVO jobModelVO = jobService.selectJobModelVOById(jobOperateDto.getJobId());
            Content content = new Content();
            switch (statusOptional.get()) {
                case AUDITING:
                    content.setBehavior(BehaviorEnum.JOB_AUDIT);
                    content.setContent(StrUtil.format("【通过】【{companyName}】发布的【{jobName}】", BeanUtil.beanToMap(jobModelVO)));
                    break;
                case ALLOCATED:
                    content.setBehavior(BehaviorEnum.JOB_ALLOCATED);
                    Map<String, Object> map = BeanUtil.beanToMap(jobModelVO);
                    map.put("sysUserNameMobile", "无");
                    if (jobOperateDto.getSysUserIdList() != null && !jobOperateDto.getSysUserIdList().isEmpty()) {
                        List<SysUserEntity> sysUserEntityList = sysUserMapper.selectBatchIds(jobOperateDto.getSysUserIdList());
                        if (CollUtil.isNotEmpty(sysUserEntityList)) {
                            String sysUserNameMobile = sysUserEntityList.stream().map(x -> StrUtil.format("{}/{}", x.getRealName(), x.getMobile())).collect(Collectors.joining(","));
                            map.put("sysUserNameMobile", sysUserNameMobile);
                        }
                    }
                    content.setContent(StrUtil.format("【分配】【{companyName}】发布的【{jobName}】给【{sysUserNameMobile}】", map));
                    break;
                case REJECTED:
                    content.setBehavior(BehaviorEnum.JOB_AUDIT);
                    content.setContent(StrUtil.format("【不通过】【{companyName}】发布的【{jobName}】【{sysUserFailRemark}】", BeanUtil.beanToMap(jobModelVO)));
                    break;
                case STOP:
                    content.setBehavior(BehaviorEnum.JOB_STOP);
                    content.setContent(StrUtil.format("【停止招聘】【{companyName}】发布的【{jobName}】", BeanUtil.beanToMap(jobModelVO)));
                    break;
                case RESTORE_HIRING:
                    content.setBehavior(BehaviorEnum.JOB_RESTORE_HIRING);
                    content.setContent(StrUtil.format("【{companyName}】【{jobName}】恢复招聘", BeanUtil.beanToMap(jobModelVO)));
                    break;
                default:
                    break;
            }
            return content;
        }
        return null;
    }
}

需要使用的类以及注解

/**
 * 系统日志注解 作用在类上
 * 作用在复杂情况下的日志场景下<br/>
 * 1、新建一个spring bean  命名为 xxxLogService<br/>
 * 2、选择要记录日志的一个方法(比如void save(Dto dto))，复制到 xxxLogService 类，返回值必须为Content 或者 List< Content ><br/>
 * 3、在方法 save 上加上注解@OperationLogHandler
 *
 * @author
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
public @interface OperationLog {
    /**
     * 日志代理类 必填
     */
    Class logClass() default void.class;
}



import cn.xx.common.constant.BehaviorEnum;

import java.lang.annotation.*;

/**
 * 日志记录核心注解，作用在具体的方法上
 * 复杂情况下搭配注解 @OperationLog 在类上一起使用
 *
 * @author
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface OperationLogHandler {


    /**
     * 操作 日志枚举类  简单使用时必填
     */
    BehaviorEnum behavior() default BehaviorEnum.NULL;

    /**
     * 操作对象 一般值参数对象 简单使用时必填
     */
    String object() default "";

    /**
     * 操作详情 在简单的情况下使用，比如参数已经有日志需要的数据了
     */
    String content() default "";

    /**
     * 默认为false
     * false 注解在Controller,需要自己重写操作日志逻辑,返回Content
     * true 注解在操作记录实现类,针对已经写过操作记录的方法,直接修改操作记录返回值为Content类型,切面直接获取返回值。
     */
    boolean isReturn() default false;

    /**
     * 是否在方法执行完后调用
     *
     * @return boolean
     */
    boolean isAfterMethod() default false;

}




import cn.xx.common.annotation.OperationLog;
import cn.xx.common.annotation.OperationLogHandler;
import cn.xx.common.constant.Constant;
import cn.xx.common.convert.UserOperationLogConverter;
import cn.xx.common.dto.log.Content;
import cn.xx.common.dto.log.OperationLogEntity;
import cn.xx.common.dto.user.UserDto;
import cn.xx.common.entity.SysUserEntity;
import cn.xx.common.entity.UserOperationLog;
import cn.xx.common.mapper.UserOperationLogMapper;
import cn.xx.common.utils.ApplicationUtils;
import cn.xx.common.utils.SpringContextUtils;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.servlet.ServletUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.PropertyFilter;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.context.annotation.Scope;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.core.annotation.Order;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Objects;

/**
 * 日志切面
 */
@Slf4j
@Aspect
@Component
@Order(2)
@Scope("prototype")
public class OperationLogAspect {

    /**
     * 用于SpEL表达式解析.
     */
    private SpelExpressionParser spelExpressionParser = new SpelExpressionParser();
    /**
     * 用于获取方法参数定义名字.
     */
    private DefaultParameterNameDiscoverer nameDiscoverer = new DefaultParameterNameDiscoverer();

    @Pointcut("@within(operationLogHandler) || @annotation(operationLogHandler)")
    public void point(OperationLogHandler operationLogHandler) {
    }

    private List<OperationLogEntity> logEntityList;

    @SuppressWarnings("unchecked")
    @Before(value = "point(operationLogHandler)", argNames = "joinPoint,operationLogHandler")
    public void beforeMethod(JoinPoint joinPoint, OperationLogHandler operationLogHandler) {
        OperationLog sysLog = joinPoint.getTarget().getClass().getDeclaredAnnotation(OperationLog.class);
        if (operationLogHandler == null) {
            return;
        }
        logEntityList = new ArrayList<>();
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        OperationLogEntity operationLogEntity = getLog(joinPoint);

        try {
            if (operationLogHandler.isReturn()) {
                logEntityList.add(operationLogEntity);
            } else if (!operationLogHandler.isAfterMethod()) {
                if (StrUtil.isNotEmpty(operationLogHandler.object()) && StrUtil.isNotEmpty(operationLogHandler.content())) {
                    String object = operationLogHandler.object();
                    String content = operationLogHandler.content();
                    if (object.contains("#")) {
                        //获取方法参数值
                        Object[] args = joinPoint.getArgs();
                        object = getValBySpEL(object, methodSignature, args);
                    }
                    if (content.contains("#")) {
                        //获取方法参数值
                        Object[] args = joinPoint.getArgs();
                        content = getValBySpEL(content, methodSignature, args);
                    }
                    operationLogEntity.setContent(content);
                    operationLogEntity.setObject(object);
                    operationLogEntity.setBehavior(operationLogHandler.behavior().getTitle());
                    logEntityList.add(operationLogEntity);
                } else {
                    Method method = methodSignature.getMethod();
                    Class proxyClass = sysLog.logClass();
                    Method logMethod = proxyClass.getDeclaredMethod(method.getName(), method.getParameterTypes());
                    Object object = SpringContextUtils.getBean(proxyClass);
                    Object logInvoke = logMethod.invoke(object, joinPoint.getArgs());
                    logEntityList.addAll(transferLogEntity(logInvoke, operationLogEntity, operationLogHandler));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("日志记录异常:{}", e.getMessage());
        }
    }

    @AfterReturning(value = "point(operationLogHandler)", argNames = "joinPoint,operationLogHandler,val", returning = "val")
    public void afterMethodReturning(JoinPoint joinPoint, OperationLogHandler operationLogHandler, Object val) {
        if (operationLogHandler == null) {
            return;
        }
        try {
            if (operationLogHandler.isReturn()) {
                OperationLogEntity operationLogEntity = logEntityList.get(0);
                logEntityList = new ArrayList<>();
                logEntityList.addAll(transferLogEntity(val, operationLogEntity, operationLogHandler));
            } else if (operationLogHandler.isAfterMethod()) {
                OperationLog sysLog = joinPoint.getTarget().getClass().getDeclaredAnnotation(OperationLog.class);
                logEntityList = new ArrayList<>();
                MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
                OperationLogEntity operationLogEntity = getLog(joinPoint);

                if (StrUtil.isNotEmpty(operationLogHandler.object()) && StrUtil.isNotEmpty(operationLogHandler.content())) {
                    String object = operationLogHandler.object();
                    String content = operationLogHandler.content();
                    if (object.contains("#")) {
                        //获取方法参数值
                        Object[] args = joinPoint.getArgs();
                        object = getValBySpEL(object, methodSignature, args);
                    }
                    if (content.contains("#")) {
                        //获取方法参数值
                        Object[] args = joinPoint.getArgs();
                        content = getValBySpEL(content, methodSignature, args);
                    }
                    operationLogEntity.setContent(content);
                    operationLogEntity.setObject(object);
                    operationLogEntity.setBehavior(operationLogHandler.behavior().getTitle());
                    logEntityList.add(operationLogEntity);
                } else {
                    Method method = methodSignature.getMethod();
                    Class proxyClass = sysLog.logClass();
                    Method logMethod = proxyClass.getDeclaredMethod(method.getName(), method.getParameterTypes());
                    Object object = SpringContextUtils.getBean(proxyClass);
                    Object logInvoke = logMethod.invoke(object, joinPoint.getArgs());
                    logEntityList.addAll(transferLogEntity(logInvoke, operationLogEntity, operationLogHandler));
                }
            }

            for (OperationLogEntity operationLogEntity : logEntityList) {
                //封禁状态不记录日志
                if (operationLogEntity.isBan()) {
                    break;
                }
                UserOperationLog userOperationLog = SpringContextUtils.getBean(UserOperationLogConverter.class).toEntity(operationLogEntity);
                if (userOperationLog != null) {
                    if (operationLogEntity.getTargetUser() != null) {
                        UserDto targetUser = operationLogEntity.getTargetUser();
                        userOperationLog.setTargetUserId(Integer.parseInt(targetUser.getUserId().toString()));
                        userOperationLog.setTargetUserName(targetUser.getUserName());
                        userOperationLog.setTargetUserMobile(targetUser.getUserMobile());
                        userOperationLog.setTargetUserType(targetUser.getUserType());
                    }
                    SpringContextUtils.getBean(UserOperationLogMapper.class).insert(userOperationLog);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("日志记录异常:{}", e.getMessage());
        }
    }

    @SuppressWarnings("unchecked")
    private List<OperationLogEntity> transferLogEntity(Object obj, OperationLogEntity operationLogEntity, OperationLogHandler operationLogHandler) {
        List<OperationLogEntity> operationLogEntityList = new ArrayList<>();
        if (obj instanceof Content) {
            Content content = (Content) obj;
            operationLogEntity.setContent(content.getContent());
            operationLogEntity.setObject(content.getObject());
            operationLogEntity.setTargetUser(content.getTargetUser());
            if (content.getBehavior() == null) {
                operationLogEntity.setBehavior(operationLogHandler.behavior().getTitle());
            } else {
                operationLogEntity.setBehavior(content.getBehavior().getTitle());
            }
            operationLogEntityList.add(operationLogEntity);
        } else if (obj instanceof Collection) {
            List<Content> contentList = (List) obj;
            for (Content content : contentList) {
                OperationLogEntity operationLog = ObjectUtil.clone(operationLogEntity);
                operationLog.setContent(content.getContent());
                operationLog.setObject(content.getObject());
                operationLog.setTargetUser(content.getTargetUser());
                if (content.getBehavior() == null) {
                    operationLog.setBehavior(operationLogHandler.behavior().getTitle());
                } else {
                    operationLog.setBehavior(content.getBehavior().getTitle());
                }
                operationLogEntityList.add(operationLog);
            }
        }
        return operationLogEntityList;
    }

    /**
     * 构建日志对象
     */
    private OperationLogEntity getLog(JoinPoint joinPoint) {
        OperationLogEntity operationLogEntity = new OperationLogEntity();
        Object[] args = joinPoint.getArgs();
        List<Object> objectList = new ArrayList<>(args.length);
        for (Object arg : args) {
            boolean parse = parse(arg);
            if (parse) {
                objectList.add(arg);
            }
        }
        operationLogEntity.setArgs(JSON.toJSONString(objectList, new JsonFilter()));
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        operationLogEntity.setClassName(methodSignature.getDeclaringTypeName());
        operationLogEntity.setMethodName(methodSignature.getName());
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes != null) {
            HttpServletRequest request = attributes.getRequest();
            String ipAddress = ServletUtil.getClientIP(request);
            operationLogEntity.setCreatorIp(ipAddress);
        }
        UserDto userInfo = ApplicationUtils.getUserInfo();
        if (userInfo != null) {
            operationLogEntity.setCreatorId(Integer.parseInt(String.valueOf(userInfo.getUserId())));
            operationLogEntity.setCreatorName(userInfo.getUserName());
            operationLogEntity.setCreatorMobile(userInfo.getUserMobile());
            operationLogEntity.setCreatorType(userInfo.getUserType());
            if (userInfo.getUserInfo() != null && userInfo.getUserInfo() instanceof SysUserEntity) {
                SysUserEntity sysUserEntity = (SysUserEntity) userInfo.getUserInfo();
                if (Objects.equals(sysUserEntity.getIsBan(), Constant.YES)) {
                    operationLogEntity.setBan(true);
                }
                operationLogEntity.setCreatorName(sysUserEntity.getRealName());
            }
        }
        return operationLogEntity;
    }

    class JsonFilter implements PropertyFilter {

        /**
         * @param object the owner of the property
         * @param name   the name of the property
         * @param value  the value of the property
         * @return true if the property will be included, false if to be filtered out
         */
        @Override
        public boolean apply(Object object, String name, Object value) {
            return parse(object) && parse(value);
        }
    }

    /**
     * 数据是否可以序列化
     *
     * @param object
     * @return true
     */
    private boolean parse(Object object) {
        if (object instanceof HttpServletRequest) {
            return false;
        } else if (object instanceof HttpServletResponse) {
            return false;
        } else if (object instanceof MultipartFile) {
            return false;
        } else if (object instanceof OutputStream) {
            return false;
        }
        return true;
    }

    /**
     * 解析spEL表达式
     */
    private String getValBySpEL(String spEL, MethodSignature methodSignature, Object[] args) {
        //获取方法形参名数组
        String[] paramNames = nameDiscoverer.getParameterNames(methodSignature.getMethod());
        if (paramNames != null && paramNames.length > 0) {
            Expression expression = spelExpressionParser.parseExpression(spEL);
            // spring的表达式上下文对象
            EvaluationContext context = new StandardEvaluationContext();
            // 给上下文赋值
            for (int i = 0; i < args.length; i++) {
                context.setVariable(paramNames[i], args[i]);
            }
            Object value = expression.getValue(context);
            return value != null ? value.toString() : null;
        }
        return null;
    }
}

OperationLogAspect类没有采用单例模式，原因：使用了局部变量临时保存数据，如果使用单例模式会有问题



import lombok.AllArgsConstructor;
import lombok.Getter;

@AllArgsConstructor
@Getter
public enum BehaviorEnum {
    /**
     * 日志操作类型枚举类
     */
    LOGOUT("登出"),
    LOGIN("登录"),
    NULL(""),
    ;

    private String title;
}


import cn.xx.common.constant.BehaviorEnum;
import cn.xx.common.dto.user.UserDto;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Content {
	
    //可能需要用到的
    private String object;
    //内容
    private String content;
	//枚举类 
    private BehaviorEnum behavior;

    @ApiModelProperty(value = "目标用户")
    private UserDto targetUser;


}

尽管涉及到的组件较多，但是一旦理解，就会明白这种方式非常便捷，可以处理更复杂的日志情况。
这套AOP日志的源头是悟空CRM，我对原始AOP日志逻辑进行了优化，而非简单搬运。

搬砖的杰夫
关注
SpringBoot使用AOP实现REST接口简易灵活的安全认证实践
KHOST的博客
01-31 557
本文将通过AOP的方式实现一个相对更加简易灵活的API安全认证服务。 我们先看实现，然后介绍和分析AOP基本原理和常用术语。 一、Authorized实现 1、定义注解 packagecom.power.demo.common; importjava.lang.annotation.*; /* *安全认证 **/ @Target({ElementType.TYPE,El...
Spring系列22：Spring AOP 概念与快速入门篇v
Sdj356512265的博客
03-08 138
本文内容 Spring AOP含义和目标 AOP相关概念 声明式AOP快速入门 编程式创建代理对象 Spring AOP含义和目标 OOP： Object-oriented Programming 面向对象编程，大家再熟悉不过了 AOP：Aspect-oriented Programming 面向切面编程 面向切面编程通过提供另一种思考程序结构的方式来补充面向对象编程。OOP 中模块化的关键单元是类，而 AOP 中模块化的单元是切面。 Spring 的关键组件之一是 AOP 框架。Sprin
Spring高级 AOP(面向切面编程)
Aa_Yy1的博客
04-02 216
Spring AOP 5种通知（前置、后置、异常、最终、环绕） 导入依赖包 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"...
Spring AOP 常用术语说明
weixin_33802505的博客
09-01 155
通知（Advice） 就是你想要的功能，也就是上面说的 安全，事物，日志等。你给先定义好把，然后在想用的地方用一下。 连接点（JoinPoint） 这个更好解释了，就是spring允许你使用通知的地方，那可真就多了，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点.其他如aspectJ还可以让...
js aop 写法
liuqiang211的专栏
10-09 466
//给函数扩展方法 Function.prototype.before = function( func ) { var __self = this; return function() { if ( func.apply( this, arguments ) === false ) { return false; }
AOP具体的实现写法
weixin_34410662的博客
06-14 457
AOP具体的实现写法 转载于:https://www.cnblogs.com/cuiqq/p/11022747.html
使用Spring的API接口实现AOP
你今天真好看呀
10-23 600
使用AOP，需要导入一个jar包： <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</art...
AOP的切入点表达式写法
qq_37717458的博客
04-26 213
关键字：execution 表达式： 访问修饰符 返回值 包名.包名.包名.包名…类名.方法名（参数列表） 标准的写法： public void com.spring.service.impl.AccountServiceImpl.saveAccount() TIPS： 访问修饰符可以省略 void com.spring.service.impl.AccountServiceImpl.save...
深入讨论Python 装饰器 (与Java Aop对比思考)
weixin_45722061的博客
10-16 1463
先说结论 java 注解能实现的功能，python 的装饰器绝大部分都是可以胜任的，装饰器更像 Java 中注解加上Aop两者的组合 python 是一门极简的语言，语言简洁学习起来也是相当轻松的，但是依然有一些高级技巧，例如装饰器，协程，并发会让人感觉困惑，失望与沮丧，本文将重点讲解 python装饰器的使用，使用常用的例子让我们更直观的看到装饰器的强大表达能力，最后也给出了编写装饰器...
SSH项目实例，有不同写法模板
12-31
AOP则允许开发者在不修改原有代码的情况下，插入新的功能，如日志记录、性能监控等。Spring还提供了数据访问抽象，包括JDBC模板和ORM支持，如Hibernate。 Struts作为MVC（Model-View-Controller）框架，负责处理...
java高级工程师面试题
10-27
4. **垃圾回收过程分析**：可以通过JVM参数来设置日志记录级别，例如使用`-XX:+PrintGCDetails`等参数，观察GC的具体行为。 ### 浅拷贝与深拷贝 1. **浅拷贝**：仅复制对象的基本类型属性值，对于对象类型的属性，...
Spring框架 第4章 AOP概述
尚硅谷铁杆粉丝的博客
04-29 195
第4章 AOP概述 4.1 AOP概述 AOP(Aspect-Oriented Programming，面向切面编程)：是一种新的方法论，是对传 统 OOP(Object-Oriented Programming，面向对象编程)的补充。 AOP编程操作的主要对象是切面(aspect)，而切面模块化横切关注点。 在应用AOP编程时，仍然需要定义公共功能，但可以明确的定义...
Spring AOP及事务控制小结
jeannia的博客
04-24 793
这里写自定义目录标题AOP和OOP区别：JAVA动态代理基本语法 AOP和OOP区别： AOP和OOP定义： AOP：（Aspect Oriented Programming）面向切面编程 OOP：（Object Oriented Programming ）面向对象编程 面向切面编程：基于OOP基础之上新的编程思想，指在程序运行期间，将某段代码动态的切入到指定方法的指定位置进行运行的编程方式 JA...
浅谈Spring切面编程AOP的实现，以及两种写法aspect和advisor
weixin_41884446的博客
10-17 854
在开发过程种，很多地方会用到Spring的AOP ，之前一致使用 <aop:aspect ref='eventMethodInterceptor'> <aop:before method='beforeMethod' pointcut-ref='prAspect'> </aop:aspect> ，偶然间发现居然还有这种写法 <aop:advisor p...
【Spring】超详细讲解AOP(面向切面编程)
最新发布
云泽野の编程日记
11-16 1175
目标: 本文围绕AOP相关的注解,各个注解运行的时机,以及@Around相较于其它注解有什么不同,并且如果要执行目标方法需要调用什么方法Spring的AOP（面向切面编程）是Spring框架的一个重要特性，它允许开发人员在应用程序中通过定义切面来实现横切关注点的功能，如日志记录、性能监控、事务管理等。AOP通过将这些关注点从业务逻辑中抽离出来，使得代码更加模块化、可维护和可重用。SpringAOP就是批量对Spring容器中bean的方法做增强，并且这种增强不会与原来方法中的代码耦合。
AOP 切面编程实战（日志+限流）
HHH的博客
08-11 563
现在我有这么一个controller , 想要给他们都添加一个打印日志的功能，传统的方法就是都在每一个方法里写上一个打印的代码， 可是万一方法数量更多，并且有很多个这样的controller ,你还是一个个的处理吗？所以这里就要用到我们的AOP 切面编程了。顾名思义，切面就是统一的来对某些方法进行操作 AOP切面编程一共有两种写法，我这里就基于更加主流更加灵活的注解的写法进行演示。我们这里先创建一个注解，这个注解里只有一个属性 basenessName（基本名称）我们想要的效果就是将该注解放在对应的方法上
AOP编程
f_Nikola的博客
10-26 277
AOP半自动编写： 所谓半自动编写就是spring容器自动为我们生成代理对象，由我们手动获取代理对象。 环境搭建 1.接口（目标类） 2.切面类 3.spring容器 4.测试类 具体代码 接口代码 package com.fxy.study.aop; public interface UserService { public void addUser(); public void upda...
Spring 学习3--AOP（面向切面编程）
qq_39376487的博客
12-05 439
Spring 学习3 AOP（面向切面编程） 利用 AOP 可以对业务逻辑的各部分进行隔离，使业务逻辑的各部分耦合度降低，提高程序可重用性。 简单理解就是把我们程序重复的代码抽取出来，在需要执行的时候，用动态代理的技术，在不改源码的基础上，对我们的已有方法进行增强。 名词解释 Joinpoint（连接点）：指被拦截的点，在 Spring 中这些点指方法， Spring 只支持方法类型的连接点。业务方法和增强代码通过连接点联系在一起。 Pointcut（切入点）：指我们要对哪些 Joinpoint 进行拦截的
AOP编程常规步骤
mzcan666的博客
12-10 1440
AOP本质上是原始功能加上额外功能，使用的是代理模式的思想，一个典型的例子是： 房东（原始功能）只想出租房子，但是嫌自己找租客太麻烦 于是找到中介，中介替他去找租客（额外功能） 静态代理： 最开始是使用静态代理的模式：额外功能实现目标类相同的接口。缺点是要为每个原始类写一个代理类,并且修改扩展功能比较麻烦 public class User {} public interface UserService { void test(User user); } public class UserS
使用Spring AOP实现日志记录
"本文将介绍如何使用Spring AOP进行日志管理，包括创建日志实体类LogInfo，并展示了类的部分属性和构造方法。" 在软件开发中，日志管理是一项重要的任务，它帮助开发者追踪和诊断应用程序的行为。Spring AOP（面向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值