@Service
public class UserServiceImpl implements UserService {
    
    // 模拟一个简单的 Map 作为缓存
    private final Map<Long, UserVO> userCache = new ConcurrentHashMap<>();

    @Override
    public UserVO findUserById(Long id) {
        // 1. 先从缓存查找
        if (userCache.containsKey(id)) {
            log.info("命中缓存: {}", id);
            return userCache.get(id);
        }

        // 2. 缓存未命中，查询数据库 (核心业务逻辑)
        User user = userMapper.selectById(id);
        if (user == null) {
            return null;
        }
        UserVO userVO = convertToVO(user);

        // 3. 将结果放入缓存
        userCache.put(id, userVO);
        log.info("查询数据库并写入缓存: {}", id);
        
        return userVO;
    }
}

package com.example.democommon.annotation;

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

@Target(ElementType.METHOD) // 注解作用于方法上
@Retention(RetentionPolicy.RUNTIME) // 运行时保留，AOP才能读取到
public @interface SimpleCache {
    /**
     * 缓存的键名前缀
     */
    String key();

    /**
     * 缓存过期时间, 单位秒, 默认1小时
     */
    long timeoutSeconds() default 3600;
}

package com.example.demoframework.aspect;

import cn.hutool.cache.Cache;
import cn.hutool.cache.CacheUtil;
import cn.hutool.core.util.StrUtil;
import com.example.democommon.annotation.SimpleCache;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect //  1.声明这个类是一个切面。
@Component
@Slf4j
public class SimpleCacheAspect {
    // 使用 Hutool 创建一个定时缓存，默认过期时间为1小时
    // `CacheUtil.newTimedCache(...)`: 我们创建了一个 `TimedCache` 实例来存储我们的缓存数据。
    private final Cache<String, Object> cache = CacheUtil.newTimedCache(3600 * 1000);

    /**
     * 定义一个切点，匹配所有被 @SimpleCache 注解标记的方法
     */
    @Pointcut("@annotation(com.example.democommon.annotation.SimpleCache)")
    public void cachePointcut() {
    }

    // `@Around`: 我们使用环绕通知，因为它能完全控制方法的执行流程：
    // 先查缓存，如果缓存没有，再执行原方法 `joinPoint.proceed()`，最后将结果放入缓存。
    @Around("cachePointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 1. 获取注解和方法信息 在我们的这次调试中出发是的就是
        // UserVO com.example.demosystem.service.impl.UserServiceImpl.findUserById(Long)
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 方法:
        // public com.example.demosystem.vo.UserVO com.example.demosystem.service.impl.UserServiceImpl.findUserById(java.lang.Long)
        Method method = signature.getMethod();
        // 通过反射获取我们方法上的注解
        SimpleCache cacheAnnotation = method.getAnnotation(SimpleCache.class);
        // 2. 根据方法和参数生成动态的缓存 Key
        String keyPrefix = cacheAnnotation.key();
        String argsString = StrUtil.join(",", joinPoint.getArgs());
        // 获取我们请求中传入的UserID的值与方法参数名进行拼接，例如 user:1
        String key = keyPrefix + ":" + argsString;

        // 3. 检查缓存 (Hutool 的 get 方法会自动处理过期)
        // `cache.get(key)`: Hutool 缓存的核心方法。如果键存在且未过期，它会返回值；
        // 否则返回 `null`。这一个方法就代替了 `containsKey` 和 `get` 两步操作。
        Object cachedResult = cache.get(key);
        if (cachedResult != null) {
            log.info("命中缓存: {}", key);
            return cachedResult;
        }
        // 4. 缓存未命中，执行目标方法
        log.info("查询数据库并写入缓存: {}", key);
        Object actualResult = joinPoint.proceed();

        // 5. 将结果放入缓存，并设置注解中指定的过期时间
        if (actualResult != null) {
            long timeoutMillis = cacheAnnotation.timeoutSeconds() * 1000;
            // `cache.put(key, actualResult, timeoutMillis)`:
            // 将数据存入缓存，并动态地为其指定一个从注解中读取的、毫秒级的过期时间。
            cache.put(key, actualResult, timeoutMillis);
        }
        return actualResult;
    }
}

package com.example.demosystem.service.impl;

import com.example.democommon.annotation.SimpleCache;
import com.example.demosystem.entity.User;
import com.example.demosystem.mapper.UserMapper;
import com.example.demosystem.service.UserService;
import com.example.demosystem.vo.UserVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
@Slf4j
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;

    @Override
    // 为方法加上注解，设置 key 前缀和 10 秒的过期时间
    @SimpleCache(key = "user", timeoutSeconds = 10)
    public UserVO findUserById(Long id) {
    }
    
    // ... 其他方法保持不变 ...
}

package com.example.demoframework.aspect;

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

@Aspect
@Component
@Slf4j
public class PerformanceAspect {

//    * 这是本节的核心。我们使用 `execution` 指示符，精确地描述了一个“范围”。
//            * `public *`: 匹配所有 `public` 方法，返回任意类型。
//            * `com.example.demosystem.service..`: 匹配 `service` 包 及其所有子包。这里的 `..` 至关重要。
//            * `*.*(..)`: 匹配所有类的所有方法，接受任意参数。
    @Pointcut("execution(public * com.example.demosystem.service..*.*(..))")
    public void serviceMethods() {}

    @Around("serviceMethods()")
    public Object profile(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        // 获取被拦截的目标对象的类名。
        String className = pjp.getTarget().getClass().getSimpleName();
        // 获取被拦截的方法名。
        String methodName = pjp.getSignature().getName();

        // 执行原始方法
        Object result = pjp.proceed();
        long end = System.currentTimeMillis();
        log.info("PERFMON: {}.{} 执行耗时: {} ms", className, methodName, (end - start));
        return result;
    }
}