SpringBoot中4大AOP实战场景：让你的代码优雅起飞！

已于 2025-05-15 17:01:44 修改
阅读量940 收藏 10
点赞数 24
CC 4.0 BY-SA版权
分类专栏： springboot 文章标签： spring boot java spring
于 2025-05-03 08:27:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iku_n/article/details/147672358

📖 开篇：AOP的魔法世界

“编程的终极艺术是将复杂隐藏在简单之后”
AOP（面向切面编程）正是Spring赋予我们的魔法杖！它让日志、权限、缓存等横切关注点不再散落各处，而是优雅地编织成统一的面纱。本文带你解锁SpringBoot中4大AOP实战场景，让你的代码像交响乐般和谐！

🎯 场景一：日志监控交响曲 📊

需求痛点

  • 调试黑洞：线上问题排查像大海捞针

  • 性能迷雾：慢接口如隐形杀手

  • 审计难题：操作记录支离破碎

实现方案

@Aspect
@Component
@Slf4j
public class LoggingAspect {
    
    /**
     * 定义切点：所有controller包下的所有方法
     */
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    public void controllerMethods() {}
    
    /**
     * 环绕通知：记录请求日志和执行时间
     */
    @Around("controllerMethods()")
    public Object logAroundControllers(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取方法签名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getName();
        String className = signature.getDeclaringTypeName();
        
        // 记录请求参数
        String params = Arrays.toString(joinPoint.getArgs());
        log.info("Request to {}.{} with params: {}", className, methodName, params);
        
        // 记录开始时间
        long startTime = System.currentTimeMillis();
        
        // 执行目标方法
        Object result;
        try {
            result = joinPoint.proceed();
            
            // 计算执行时间
            long executionTime = System.currentTimeMillis() - startTime;
            
            // 记录返回结果和执行时间
            log.info("Response from {}.{} ({}ms): {}", 
                    className, methodName, executionTime, result);
            
            // 记录慢方法
            if (executionTime > 1000) {
                log.warn("Slow execution detected! {}.{} took {}ms", 
                        className, methodName, executionTime);
            }
            
            return result;
        } catch (Exception e) {
            // 记录异常信息
            log.error("Exception in {}.{}: {}", className, methodName, e.getMessage(), e);
            throw e;
        }
    }
    
    /**
     * 定义服务层方法切点
     */
    @Pointcut("execution(* com.example.demo.service.*.*(..))")
    public void serviceMethods() {}
    
    /**
     * 记录服务层方法的关键调用
     */
    @Before("serviceMethods() && @annotation(logMethod)")
    public void logServiceMethod(JoinPoint joinPoint, LogMethod logMethod) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getName();
        
        // 获取参数名
        String[] paramNames = signature.getParameterNames();
        Object[] args = joinPoint.getArgs();
        
        StringBuilder logMessage = new StringBuilder();
        logMessage.append("Executing ").append(methodName).append(" with params: {");
        
        for (int i = 0; i < paramNames.length; i++) {
            logMessage.append(paramNames[i]).append("=").append(args[i]);
            if (i < paramNames.length - 1) {
                logMessage.append(", ");
            }
        }
        logMessage.append("}");
        
        // 根据注解设置的级别记录日志
        switch (logMethod.level()) {
            case DEBUG:
                log.debug(logMessage.toString());
                break;
            case INFO:
                log.info(logMessage.toString());
                break;
            case WARN:
                log.warn(logMessage.toString());
                break;
            case ERROR:
                log.error(logMessage.toString());
                break;
        }
    }
}

/**
 * 自定义日志注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogMethod {
    LogLevel level() default LogLevel.INFO;
    
    public enum LogLevel {
        DEBUG, INFO, WARN, ERROR
    }
}

使用示例 

@Service
public class UserService {
    
    @LogMethod(level = LogMethod.LogLevel.INFO)
    public User findById(Long id) {
        // 业务逻辑
        return userRepository.findById(id).orElse(null);
    }
    
    @LogMethod(level = LogMethod.LogLevel.WARN)
    public void updateUserStatus(Long userId, String status) {
        // 更新用户状态
    }
}

扩展：MDC实现请求跟踪 

@Component
public class RequestIdFilter implements Filter {
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        try {
            // 为每个请求生成唯一ID
            String requestId = UUID.randomUUID().toString().replace("-", "");
            MDC.put("requestId", requestId);
            
            if (request instanceof HttpServletRequest) {
                HttpServletRequest httpRequest = (HttpServletRequest) request;
                // 记录用户信息
                Authentication auth = SecurityContextHolder.getContext().getAuthentication();
                if (auth != null && auth.isAuthenticated()) {
                    MDC.put("userId", auth.getName());
                }
                MDC.put("remoteAddr", httpRequest.getRemoteAddr());
            }
            
            chain.doFilter(request, response);
        } finally {
            // 请求完成后清理MDC
            MDC.clear();
        }
    }
}

魔法配方(额外了解)

@Around("controllerMethods()")
public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
    long start = System.currentTimeMillis();
    log.info("🚀 请求进入: {}.{} 参数: {}", 
            pjp.getSignature().getDeclaringTypeName(),
            pjp.getSignature().getName(),
            Arrays.toString(pjp.getArgs()));
    
    Object result = pjp.proceed();
    
    long cost = System.currentTimeMillis() - start;
    log.info("✅ 请求完成: {}.{} 耗时: {}ms 结果: {}", 
            pjp.getSignature().getDeclaringTypeName(),
            pjp.getSignature().getName(),
            cost, 
            result);
    
    if(cost > 1000) {
        log.warn("🐢 慢接口警告！耗时超过1秒！");
    }
    return result;
}

🎨 功能增强

  1. MDC日志染色：用ThreadLocal实现请求链路追踪

    MDC.put("traceId", UUID.randomUUID().toString());

  2. 动态采样：根据QPS动态调整日志级别

  3. 异常画像：自动统计异常类型分布

🔒 场景二：权限守卫者之盾 🛡️

权限设计三要素

维度实现方式示例
角色控制@RequiresRole管理员/普通用户
权限控制@RequiresPermissionuser:delete
数据权限动态SQL过滤部门数据隔离

实现方案

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface RequiresPermission {
    /**
     * 所需权限编码数组，满足其中任一即可
     */
    String[] value() default {};
    
    /**
     * 权限逻辑类型：AND(同时具有所有权限), OR(满足任一权限即可)
     */
    LogicalType logical() default LogicalType.OR;
    
    public enum LogicalType {
        AND, OR
    }
}

@Aspect
@Component
@Slf4j
public class PermissionAspect {
    
    @Autowired
    private UserService userService;
    
    /**
     * 定义切点：所有带有@RequiresPermission注解的方法
     */
    @Pointcut("@annotation(com.example.demo.annotation.RequiresPermission)")
    public void permissionCheck() {}
    
    /**
     * 权限验证前置通知
     */
    @Before("permissionCheck() && @annotation(requiresPermission)")
    public void checkPermission(JoinPoint joinPoint, RequiresPermission requiresPermission) {
        // 获取当前用户
        User currentUser = getCurrentUser();
        if (currentUser == null) {
            throw new UnauthorizedException("用户未登录或会话已过期");
        }
        
        // 获取用户权限列表
        Set<String> userPermissions = userService.getUserPermissions(currentUser.getId());
        
        // 获取注解中要求的权限
        String[] requiredPermissions = requiresPermission.value();
        RequiresPermission.LogicalType logicalType = requiresPermission.logical();
        
        // 权限校验
        boolean hasPermission = false;
        
        if (logicalType == RequiresPermission.LogicalType.OR) {
            // 满足任一权限即可
            for (String permission : requiredPermissions) {
                if (userPermissions.contains(permission)) {
                    hasPermission = true;
                    break;
                }
            }
        } else {
            // 必须同时满足所有权限
            hasPermission = true;
            for (String permission : requiredPermissions) {
                if (!userPermissions.contains(permission)) {
                    hasPermission = false;
                    break;
                }
            }
        }
        
        if (!hasPermission) {
            log.warn("用户 {} 尝试访问未授权资源: {}.{}", 
                    currentUser.getUsername(),
                    joinPoint.getSignature().getDeclaringTypeName(),
                    joinPoint.getSignature().getName());
            
            throw new ForbiddenException("权限不足，无法执行该操作");
        }
        
        // 记录敏感操作
        log.info("用户 {} 执行了需授权操作: {}.{}", 
                currentUser.getUsername(), 
                joinPoint.getSignature().getDeclaringTypeName(),
                joinPoint.getSignature().getName());
    }
    
    private User getCurrentUser() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (authentication == null || !authentication.isAuthenticated()) {
            return null;
        }
        
        Object principal = authentication.getPrincipal();
        if (principal instanceof User) {
            return (User) principal;
        }
        
        return null;
    }
}

 使用示例

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping
    @RequiresPermission("user:list")
    public List<User> listUsers() {
        return userService.findAll();
    }
    
    @GetMapping("/{id}")
    @RequiresPermission("user:view")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
    
    @PostMapping
    @RequiresPermission(value = {"user:create", "user:edit"}, logical = RequiresPermission.LogicalType.OR)
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
    
    @DeleteMapping("/{id}")
    @RequiresRole("ADMIN")
    public void deleteUser(@PathVariable Long id) {
        userService.delete(id);
    }
}

安全切面实现(额外了解)

@Before("@annotation(requiresPermission)")
public void checkPermission(JoinPoint jp, RequiresPermission anno) {
    User user = CurrentUser.get();
    Set<String> permissions = userService.getPermissions(user.getId());
    
    // 权限逻辑判断
    boolean hasPerm = checkLogic(anno.logical(), anno.value(), permissions);
    
    if(!hasPerm) {
        log.warn("🚫 用户[{}]尝试越权访问: {}", user.getName(), jp.getSignature());
        throw new ForbiddenException("权限不足！");
    }
}

private boolean checkLogic(LogicalType type, String[] required, Set<String> actual) {
    return type == LogicalType.OR ? 
        Arrays.stream(required).anyMatch(actual::contains) :
        Arrays.stream(required).allMatch(actual::contains);
}

🛠️ 安全增强

  • 权限变更实时生效：通过Redis Pub/Sub同步权限变更

  • 敏感操作二次认证：关键操作需短信/邮件验证

  • 操作审计日志：记录所有敏感操作轨迹

💾 场景三：缓存魔术师 ✨

缓存策略对比

策略适用场景优点缺点
穿透保护频繁访问不存在的数据防止DB压力需要维护空值缓存
击穿保护热点key过期保证高可用增加复杂度
雪崩保护大量key同时过期系统稳定性高内存占用可能增加

实现方案 

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Cacheable {
    /**
     * 缓存名称
     */
    String cacheName();
    
    /**
     * 缓存键表达式，支持SpEL表达式
     */
    String key() default "";
    
    /**
     * 过期时间（秒）
     */
    long expireTime() default 300;
    
    /**
     * 是否使用方法参数作为缓存键的一部分
     */
    boolean useMethodParameters() default true;
}

@Aspect
@Component
@Slf4j
public class CacheAspect {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private CacheKeyGenerator keyGenerator;
    
    /**
     * 定义缓存获取切点
     */
    @Pointcut("@annotation(com.example.demo.annotation.Cacheable)")
    public void cacheableOperation() {}
    
    /**
     * 缓存环绕通知
     */
    @Around("cacheableOperation() && @annotation(cacheable)")
    public Object handleCacheable(ProceedingJoinPoint joinPoint, Cacheable cacheable) throws Throwable {
        // 生成缓存键
        String cacheKey = generateCacheKey(joinPoint, cacheable.cacheName(), cacheable.key(), cacheable.useMethodParameters());
        
        // 检查缓存中是否已有数据
        Boolean hasKey = redisTemplate.hasKey(cacheKey);
        if (Boolean.TRUE.equals(hasKey)) {
            Object cachedValue = redisTemplate.opsForValue().get(cacheKey);
            log.debug("Cache hit for key: {}", cacheKey);
            return cachedValue;
        }
        
        // 缓存未命中，执行方法获取结果
        log.debug("Cache miss for key: {}", cacheKey);
        Object result = joinPoint.proceed();
        
        // 将结果存入缓存
        if (result != null) {
            redisTemplate.opsForValue().set(cacheKey, result, cacheable.expireTime(), TimeUnit.SECONDS);
            log.debug("Stored in cache with key: {}, expire time: {}s", cacheKey, cacheable.expireTime());
        }
        
        return result;
    }
    
    private String generateCacheKey(JoinPoint joinPoint, String cacheName, String keyExpression, boolean useParams) {
        StringBuilder keyBuilder = new StringBuilder(cacheName).append(":");
        
        // 如果提供了自定义键表达式
        if (StringUtils.hasText(keyExpression)) {
            String evaluatedKey = keyGenerator.generateKey(keyExpression, joinPoint);
            keyBuilder.append(evaluatedKey);
        } else if (useParams) {
            // 使用方法签名和参数作为键
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            String methodName = signature.getName();
            keyBuilder.append(methodName);
            
            // 添加参数
            Object[] args = joinPoint.getArgs();
            if (args != null && args.length > 0) {
                for (Object arg : args) {
                    if (arg != null) {
                        keyBuilder.append(":").append(arg.hashCode());
                    } else {
                        keyBuilder.append(":null");
                    }
                }
            }
        } else {
            // 仅使用方法名
            keyBuilder.append(joinPoint.getSignature().getName());
        }
        
        return keyBuilder.toString();
    }
}

使用示例

@Service
public class ProductService {
    
    @Cacheable(cacheName = "products", expireTime = 3600)
    public Product getById(Long id) {
        return productRepository.findById(id).orElse(null);
    }
    
    @Cacheable(cacheName = "products", key = "'list:category:' + #categoryId", expireTime = 1800)
    public List<Product> getByCategory(Long categoryId) {
        return productRepository.findByCategoryId(categoryId);
    }
}

缓存切面黑科技(额外了解)

@Around("@annotation(cacheable)")
public Object handleCache(ProceedingJoinPoint pjp, Cacheable anno) throws Throwable {
    String cacheKey = generateKey(pjp, anno);
    Object cached = redisTemplate.opsForValue().get(cacheKey);
    
    if(cached != null) {
        log.debug("💡 缓存命中: {}", cacheKey);
        return cached;
    }
    
    log.debug("❓ 缓存未命中: {}", cacheKey);
    Object result = pjp.proceed();
    
    if(result != null) {
        redisTemplate.opsForValue().set(
            cacheKey, 
            result, 
            anno.expireTime() + randomOffset(), // 随机过期时间防雪崩
            TimeUnit.SECONDS
        );
    }
    return result;
}

private long randomOffset() {
    return ThreadLocalRandom.current().nextLong(30); // ±30秒随机偏移
}

🚨 场景四：异常处理大师 🤹

重试策略对比

策略公式适用场景
固定间隔每次等待固定时间网络抖动
指数退避2^(n-1)*base远程服务不可用
随机抖动base + random分布式系统防拥塞

实现方案 

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Retryable {
    /**
     * 最大重试次数
     */
    int maxAttempts() default 3;
    
    /**
     * 重试间隔（毫秒）
     */
    long backoff() default 1000;
    
    /**
     * 指定捕获的异常类型
     */
    Class<? extends Throwable>[] value() default {Exception.class};
    
    /**
     * 重试策略
     */
    RetryStrategy strategy() default RetryStrategy.FIXED;
    
    /**
     * 重试策略枚举
     */
    enum RetryStrategy {
        /**
         * 固定间隔
         */
        FIXED,
        
        /**
         * 指数退避
         */
        EXPONENTIAL
    }
}

@Aspect
@Component
@Slf4j
public class RetryAspect {
    
    /**
     * 定义可重试操作切点
     */
    @Pointcut("@annotation(com.example.demo.annotation.Retryable)")
    public void retryableOperation() {}
    
    /**
     * 重试环绕通知
     */
    @Around("retryableOperation() && @annotation(retryable)")
    public Object handleRetry(ProceedingJoinPoint joinPoint, Retryable retryable) throws Throwable {
        int attempts = 0;
        Class<? extends Throwable>[] retryableExceptions = retryable.value();
        Retryable.RetryStrategy strategy = retryable.strategy();
        
        while (true) {
            attempts++;
            try {
                // 执行目标方法
                return joinPoint.proceed();
            } catch (Throwable t) {
                // 检查是否是需要重试的异常类型
                boolean shouldRetry = false;
                for (Class<? extends Throwable> exceptionType : retryableExceptions) {
                    if (exceptionType.isInstance(t)) {
                        shouldRetry = true;
                        break;
                    }
                }
                
                // 如果不需要重试，或者达到最大重试次数，则抛出异常
                if (!shouldRetry || attempts >= retryable.maxAttempts()) {
                    log.warn("Method {} failed after {} attempts: {}", 
                            joinPoint.getSignature().getName(), attempts, t.getMessage());
                    throw t;
                }
                
                // 计算重试等待时间
                long waitTime;
                if (strategy == Retryable.RetryStrategy.EXPONENTIAL) {
                    // 指数退避: 基础时间 * 2^(尝试次数-1)
                    waitTime = retryable.backoff() * (long) Math.pow(2, attempts - 1);
                } else {
                    // 固定间隔
                    waitTime = retryable.backoff();
                }
                
                log.info("Retrying {} (attempt {}/{}) after {} ms due to: {}", 
                        joinPoint.getSignature().getName(), 
                        attempts, 
                        retryable.maxAttempts(), 
                        waitTime, 
                        t.getMessage());
                
                // 等待指定时间后重试
                Thread.sleep(waitTime);
            }
        }
    }
}

使用示例

@Service
public class PaymentService {
    
    @Retryable(
        value = {ConnectException.class, TimeoutException.class, PaymentGatewayException.class},
        maxAttempts = 3,
        backoff = 2000,
        strategy = Retryable.RetryStrategy.EXPONENTIAL
    )
    public PaymentResult processPayment(String orderId, BigDecimal amount) {
        log.info("Processing payment for order {} with amount {}", orderId, amount);
        
        // 调用远程支付网关
        return paymentGateway.processPayment(orderId, amount);
    }
}

幂等性实现(额外了解)

@Around("@annotation(idempotent)")
public Object handleIdempotent(ProceedingJoinPoint pjp, Idempotent anno) throws Throwable {
    String lockKey = "idempotent:" + parseKey(pjp, anno);
    
    Boolean locked = redisTemplate.opsForValue().setIfAbsent(
        lockKey, "processing", 30, TimeUnit.SECONDS);
    
    if(!Boolean.TRUE.equals(locked)) {
        String status = redisTemplate.opsForValue().get(lockKey);
        // 状态机处理...
    }
    
    try {
        Object result = pjp.proceed();
        redisTemplate.opsForValue().set(lockKey, "success", 300, TimeUnit.SECONDS);
        return result;
    } catch(Exception e) {
        redisTemplate.opsForValue().set(lockKey, "failed:"+e.getMessage(), 60, TimeUnit.SECONDS);
        throw e;
    }
}

🏆 最佳实践指南

AOP设计黄金法则

  1. 切面粒度：每个切面只做一件事

  2. 执行顺序：使用@Order控制切面顺序

  3. 异常处理：切面内部做好异常捕获

  4. 性能监控：切面本身要轻量高效

常见陷阱

  • ⚠️ 循环依赖：切面不要直接依赖业务Bean

  • ⚠️ 代理失效：内部方法调用不走代理

  • ⚠️ 线程安全：切面中不要保存状态

🌟 结语：AOP的星辰大海

通过这4大场景的实战演练，相信你已经掌握AOP这把双刃剑！但请记住：

“With great power comes great responsibility”
AOP虽好，但过度使用会让代码变成"面条式"结构。合理运用，才能让代码既有弹性又保持优雅！

Spring Boot 项目中实现 AOP 的常见用法与案例
一名热衷于技术的全栈开发者，专注于前端与后端的全面技术探索。在这里，我将分享我在技术领域的学习与成长，助力更多开发者的进步。
01-10 1120
定义Retention;Target;在 Spring Boot 项目中，AOP 是实现横切关注点的强大工具。通过定义切面，可以在不改变业务代码的情况下实现日志记录、权限校验、性能监控等功能，从而提升代码的模块化和可维护性。结合实际需求和性能优化策略，合理使用 AOP，可以让你的项目更加高效和优雅。
Spring AOP使用:自定义注解、通知（简单使用和原理了解）
Int_Xu的博客
09-12 895
引言 本文主要简单介绍一下什么是AOP，如何自定义注解，任何使用通知，以及简单介绍一下什么是动态代理
AOP在SpringBoot项目中的简单使用场景
最新发布
m0_63164811的博客
04-03 376
AOP在SpringBoot项目中的简单使用场景
springboot中aop的应用场景_springboot中使用aop技术
weixin_39558221的博客
12-21 226
aop是面向切面编程的意思，它可以需要先选择一些切入点，然后对这些切入点进行拦截，注入统一的代码逻辑，这也是解耦的一种方式，也是为了避免重复的代码，让开发人员把关注点放在业务上。引用包'org.springframework.boot:spring-boot-starter-aop'添加切入点/*** 基于com.lind.basic.controller包下的方法进行拦截.*/@Aspect@C...
SpringBoot Aop 详解和多种使用场景
Leo_Wcg的博客
09-26 384
aop
Java进阶之光！java将数组拼接成一个字符串
m0_57286518的博客
07-22 1797
Java基础 1.Java语言的三大特性 2.Java语言主要特性 3. JDK和JRE有什么区别 4.Java基本数据类型及其封装类 5.如果main方法被声明为private会怎样? 6.说明- -下public static void main(String argsQ])这段声明里每个关键字的作用 7.==与equals的区别 8.Object有哪些公用方法 9.为什么Java里没有全局变量? 10.while循环和do循环有什么不同? 11.char型变量中能不能存储一个中文汉字?为什么? 12
透过现象看本质，究竟为什么阿里巴巴爱招Java开发程序员？
Q54665642ljf的博客
09-09 592
每个程序员心中都有一个大厂梦，无论是阿里还是腾讯，对于程序员的技术要求都是比较高的，抛开学历不谈，你的技术水平是否达到了阿里的标准和要求？如果你与其他同行存在着较大的技术差距，而且还没有改变现状的想法，那么被市场所淘汰，只是时间问题。所以，不管你是否想要进入大厂，或是想要拥有一份满意的薪资，都需要认真对待自己。以上这份Java技术成长笔记，需要的朋友点击“传送门”即可免费获取。
传智教育|2022最新版Java学习路线图全集汇总——Java学习到底学什么？一文详解
CZ-001的博客
08-02 1711
2022版Java学习路线图来了！
【吐血整理】三年老Java经验面经
m0_56830858的博客
05-17 266
一、背景 我们日常在电商网站购物时经常会遇到一些高并发的场景，例如电商 App 上经常出现的秒杀活动、限量优惠券抢购，还有我们去哪儿网的火车票抢票系统等，这些场景有一个共同特点就是访问量激增，虽然在系统设计时会通过限流、异步、排队等方式优化，但整体的并发还是平时的数倍以上，为了避免并发问题，防止库存超卖，给用户提供一个良好的购物体验，这些系统中都会用到锁的机制。 对于单进程的并发场景，可以使用编程语言及相应的类库提供的锁，如 Java 中的 synchronized 语法以及 ReentrantLock 类
92天寒窗苦学，泪谈京东三面+交叉面经历，终获30K*14薪
m0_55849656的博客
06-30 468
技术面共三轮，一面二面是远程，三面是现场面外加2人交叉面试，说实话还是很紧张！最后HR定薪资是30K*14
springboot AOP使用实例源码
12-20
在Springboot上使用AOP的简单实例源码，可以结合本人的文章一起学习理解 https://blog.csdn.net/vincent_yuan89/article/details/85128009
Spring Boot中使用AOP统一处理web层异常的方法
08-27
主要介绍了Spring Boot中使用AOP统一处理web层异常的相关资料,需要的朋友可以参考下
Spring Boot中AOP的深度解析与应用场景实践
勤于笔记，成于点滴。
03-08 794
Spring Boot中的AOP功能强大且易于使用，能够帮助开发者更高效地管理横切关注点，提高代码的可维护性和可扩展性。通过合理地运用AOP，可以显著提升软件开发的质量和效率。
Spring AOP应用场景深度解析：从核心原理到六大实战案例
Zyw907155124的博客
06-08 4343
本文系统解析Spring AOP的核心机制与高频应用场景，涵盖日志记录、权限校验、事务管理等六大经典案例，并深入实战缓存优化、API调用统计、滑动窗口限流等高级技巧。通过自定义注解与环绕通知设计，助你快速掌握AOP在复杂业务中的模块化实践，提升代码可维护性与开发效率。适合中高级开发者快速突破AOP落地难点。
AOP的那些事以及在SpringBoot的应用
zhaoenweiex的博客
10-08 2173
面向切面编程(Aspect Oriented Programming),通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 *AOP其实只是OOP的补充而已。OOP从横向上区分出一个个的类来，而AOP则从纵向上向对象中加入特定的代码。有了AOP，OOP变得立体了。如果加上时间维度，AOP使OOP由原来的二维变为三维了，由平面变成立体了*
SpringBoot AOP 实现埋点日志记录（完整源码）
GitChat
04-18 1723
随着互联网技术的深入发展，各个系统的日活用户、访问量、点击量成指数上升，为保证系统的安全性、易用性，每个系统都需要对用户的访问做埋点记录、跟踪，从而获取用户常用的操作习惯，同时也方便系统管理人员对系统做日常记录、跟踪。 本 Chat 你将会获得以下知识： 1、Spring Boot AOP的使用、术语； 2、完整源码实现埋点日志记录，直接COPY使用到项目中。...
Aop实操
qq_42938698的博客
02-17 212
准备面试
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值