Spring AOP通知类型与实战示例讲解

@aspect
@component
public class securityaspect {
    @before("@annotation(requiresauth)")
    public void checkauth(joinpoint joinpoint, requiresauth requiresauth) {
        // 获取当前用户信息
        servletrequestattributes attributes = 
            (servletrequestattributes) requestcontextholder.getrequestattributes();
        httpservletrequest request = attributes.getrequest();
        string token = request.getheader("authorization");
        // 验证token
        if (!tokenservice.isvalid(token)) {
            throw new unauthorizedexception("无效的认证令牌");
        }
        // 检查权限
        string requiredrole = requiresauth.role();
        if (!hasrole(token, requiredrole)) {
            throw new forbiddenexception("权限不足");
        }
    }
}

@before("execution(* com.example.service.*.*(..))")
public void beforeadvice(joinpoint joinpoint) {
    // 获取方法参数
    object[] args = joinpoint.getargs();
    // 获取方法签名
    methodsignature signature = (methodsignature) joinpoint.getsignature();
    string methodname = signature.getname();
    // 获取参数名称
    string[] parameternames = signature.getparameternames();
    // 获取参数类型
    class<?>[] parametertypes = signature.getparametertypes();
    // 打印参数信息
    for (int i = 0; i < args.length; i++) {
        logger.info("parameter {} ({}) = {}", parameternames[i], parametertypes[i].getsimplename(), args[i]);
    }
}

@before("@annotation(logparams)")
public void beforewithannotation(joinpoint joinpoint, logparams logparams) {
    // 直接获取注解属性
    string description = logparams.description();
    boolean logresult = logparams.logresult();
    // 获取方法参数
    object[] args = joinpoint.getargs();
    // 根据注解配置记录日志
    if (logparams.includeparameters()) {
        arrays.stream(args)
              .foreach(arg -> logger.info("parameter value: {}", arg));
    }
}

@aspect
@component
public class resourcecleanupaspect {
    @after("execution(* com.example.service.fileservice.*(..))")
    public void cleanup(joinpoint joinpoint) {
        try {
            // 清理临时文件
            string methodname = joinpoint.getsignature().getname();
            logger.info("cleaning up resources after method: {}", methodname);
            cleanuptempfiles();
            // 释放其他资源
            releaseresources();
        } catch (exception e) {
            logger.error("cleanup failed", e);
        }
    }
    private void cleanuptempfiles() {
        // 清理临时文件的具体实现
    }
    private void releaseresources() {
        // 释放资源的具体实现
    }
}

@after("execution(* com.example.service.*.*(..)) && args(id,name,..)")
public void afteradvice(joinpoint joinpoint, long id, string name) {
    // 直接使用参数
    logger.info("method executed with id: {} and name: {}", id, name);
    // 获取目标类信息
    class<?> targetclass = joinpoint.gettarget().getclass();
    // 获取代理类信息
    class<?> proxyclass = joinpoint.getthis().getclass();
}

@aspect
@component
public class responsehandleraspect {
    @afterreturning(
        pointcut = "execution(* com.example.controller.*.*(..))",
        returning = "result"
    )
    public void handleresponse(joinpoint joinpoint, object result) {
        if (result instanceof list) {
            // 对集合类型结果进行脱敏处理
            list<?> list = (list<?>) result;
            for (object item : list) {
                if (item instanceof userdto) {
                    userdto user = (userdto) item;
                    user.setphone(maskphonenumber(user.getphone()));
                    user.setemail(maskemail(user.getemail()));
                }
            }
        }
    }
    private string maskphonenumber(string phone) {
        // 手机号码脱敏逻辑
        return phone.replaceall("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    }
    private string maskemail(string email) {
        // 邮箱脱敏逻辑
        return email.replaceall("(\\w{3})\\w+(@\\w+\\.\\w+)", "$1***$2");
    }
}

@aspect
@component
public class exceptionhandleraspect {
    @afterthrowing(
        pointcut = "execution(* com.example.service.*.*(..))",
        throwing = "ex"
    )
    public void handleexception(joinpoint joinpoint, exception ex) {
        string methodname = joinpoint.getsignature().getname();
        string classname = joinpoint.gettarget().getclass().getsimplename();
        // 记录详细错误信息
        logger.error("exception in {}.{}: {}", classname, methodname, ex.getmessage());
        // 发送告警
        if (ex instanceof dataaccessexception) {
            alertservice.senddatabasealert(classname, methodname, ex);
        }
        // 异常分类统计
        metricservice.incrementexceptioncounter(classname, methodname, ex.getclass().getsimplename());
        // 如果需要，可以转换异常类型
        if (ex instanceof sqlexception) {
            throw new databaseexception("数据库操作失败", ex);
        }
    }
}

@aspect
@component
public class cacheaspect {
    @autowired
    private cachemanager cachemanager;
    @around("@annotation(cacheable)")
    public object handlecache(proceedingjoinpoint joinpoint, cacheable cacheable) throws throwable {
        // 构建缓存key
        string key = buildcachekey(joinpoint, cacheable);
        // 尝试从缓存获取
        object cachedvalue = cachemanager.get(key);
        if (cachedvalue != null) {
            logger.debug("cache hit for key: {}", key);
            return cachedvalue;
        }
        // 执行目标方法
        long starttime = system.currenttimemillis();
        object result = null;
        try {
            result = joinpoint.proceed();
            // 记录执行时间
            long executiontime = system.currenttimemillis() - starttime;
            logger.debug("method execution time: {}ms", executiontime);
            // 如果执行时间超过阈值，发送告警
            if (executiontime > 1000) {
                alertservice.sendperformancealert(joinpoint, executiontime);
            }
        } catch (exception e) {
            // 异常处理
            logger.error("method execution failed", e);
            throw e;
        }
        // 将结果放入缓存
        if (result != null) {
            cachemanager.put(key, result, cacheable.ttl());
        }
        return result;
    }
    private string buildcachekey(proceedingjoinpoint joinpoint, cacheable cacheable) {
        // 缓存key构建逻辑
        stringbuilder key = new stringbuilder();
        key.append(joinpoint.getsignature().getdeclaringtypename())
           .append(".")
           .append(joinpoint.getsignature().getname());
        object[] args = joinpoint.getargs();
        if (args != null && args.length > 0) {
            key.append(":");
            for (object arg : args) {
                key.append(arg != null ? arg.tostring() : "null").append(",");
            }
        }
        return key.tostring();
    }
}

@aspect
@component
public class ratelimiteraspect {
    private final ratelimiter ratelimiter = ratelimiter.create(100.0); // 每秒100个请求
    @around("@annotation(ratelimited)")
    public object limitrate(proceedingjoinpoint joinpoint, ratelimited ratelimited) throws throwable {
        if (!ratelimiter.tryacquire(100, timeunit.milliseconds)) {
            throw new toomanyrequestsexception("请求过于频繁，请稍后重试");
        }
        return joinpoint.proceed();
    }
}