cms项目细节-aop

public CommonResponse<Object> method1() {
      // 业务逻辑
      xxService.method1();
      // 省略具体的业务处理逻辑
      // 日志记录
      ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
      HttpServletRequest request = attributes.getRequest();
      // 省略记录日志的具体逻辑 如：获取各种信息，写入数据库等操作...
      return CommonResponse.success();
}

public CommonResponse<Object> method2() {
      // 业务逻辑
      xxService.method2();
      // 省略具体的业务处理逻辑
      // 日志记录
      ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
      HttpServletRequest request = attributes.getRequest();
      // 省略记录日志的具体逻辑 如：获取各种信息，写入数据库等操作...
      return CommonResponse.success();
}

// ...

// 日志注解
@Target({ElementType.PARAMETER,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {

    /**
     * 描述
     */
    String description() default "";

    /**
     * 方法类型 INSERT DELETE UPDATE OTHER
     */
    MethodType methodType() default MethodType.OTHER;
}

// 日志切面
@Component
@Aspect
public class LogAspect {
  // 切入点，所有被 Log 注解标注的方法
  @Pointcut("@annotation(cn.javaguide.annotation.Log)")
  public void webLog() {
  }

   /**
   * 环绕通知
   */
  @Around("webLog()")
  public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
    // 省略具体的处理逻辑
  }

  // 省略其他代码
}

@Log(description = "method1",methodType = MethodType.INSERT)
public CommonResponse<Object> method1() {
      // 业务逻辑
      xxService.method1();
      // 省略具体的业务处理逻辑
      return CommonResponse.success();
}

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

@Configuration
@EnableAspectJAutoProxy
public class AopConfig {}

public enum MethodType {
    INSERT,   // 新增
    DELETE,   // 删除
    UPDATE,   // 修改
    OTHER     // 其他
}

@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {

    /** 描述：这个操作是干什么的 */
    String description() default "";

    /** 方法类型：INSERT / DELETE / UPDATE / OTHER */
    MethodType methodType() default MethodType.OTHER;
}

@Component
@Aspect
public class LogAspect {

    private static final Logger log = LoggerFactory.getLogger(LogAspect.class);

    /**
     * 切点：所有标了 @Log 的方法
     * 方法体可以为空，它只是一个"命名切点"，方便多个通知复用
     */
    @Pointcut("@annotation(cn.javaguide.annotation.Log)")
    public void webLog() {
    }

    /**
     * 环绕通知
     */
    @Around("webLog()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().getName();
        String description = "";
        MethodType methodType = MethodType.OTHER;

        // 从方法签名上拿到 @Log 注解，读取描述和类型
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Log logAnnotation = signature.getMethod().getAnnotation(Log.class);
        if (logAnnotation != null) {
            description = logAnnotation.description();
            methodType = logAnnotation.methodType();
        }

        try {
            Object result = joinPoint.proceed();   // 执行真正的业务方法
            saveLog(methodName, description, methodType,
                    System.currentTimeMillis() - start, null);
            return result;
        } catch (Throwable e) {
            saveLog(methodName, description, methodType,
                    System.currentTimeMillis() - start, e);
            throw e;    // 一定要继续抛，不能让切面吞掉业务异常
        }
    }

    private void saveLog(String methodName, String description,
                         MethodType methodType, long cost, Throwable error) {
        String user = "anonymous";
        try {
            Authentication auth = SecurityContextHolder.getContext().getAuthentication();
            if (auth != null && auth.getPrincipal() instanceof UserDetails u) {
                user = u.getUsername();
            }
        } catch (Exception ignored) {
        }

        String ip = "";
        try {
            ServletRequestAttributes attrs =
                    (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            if (attrs != null) {
                ip = attrs.getRequest().getRemoteAddr();
            }
        } catch (Exception ignored) {
        }

        String status = error == null ? "SUCCESS" : "FAIL: " + error.getMessage();
        String args = Arrays.toString(joinPointArgs(methodName)); // 参数摘要

        log.info("[AOP LOG] user={}, ip={}, method={}, desc={}, type={}, cost={}ms, args={}, status={}",
                user, ip, methodName, description, methodType, cost, args, status);

        // 生产环境这里通常是：写入数据库/发 MQ/调审计系统
    }
}

// 只记录成功响应，用 AfterReturning 最直观
@AfterReturning(pointcut = "webLog()", returning = "result")
public void logSuccess(JoinPoint joinPoint, Object result) {
    log.info("{} 成功, 返回 {}", joinPoint.getSignature().getName(), result);
}

调用方
  → 代理对象（执行切面逻辑）
      → 真实对象（执行业务）

@Service
public class OrderService {
    public void a() {
        this.b();   // this 是真实对象，不是代理！
    }

    @Transactional
    public void b() { ... }
}

// 我只需要写这个，代理是 Spring 运行时生成的
@Log(description = "查询订单")
public Order getOrder(Long id) { ... }

@Autowired
private ContentController contentController;

@Service
public class OrderService {

    public void a() {
        this.b();   // 这就是自调用
    }

    @Transactional
    public void b() {
        // 要开事务的业务
    }
}

外部 → 代理.a() → 真实对象.a()
                      └→ this.b()      ← this 是真实对象，不经过代理，注解失效

其他类 → 代理.b() → 切面/事务 → 真实对象.b()   ✅

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodCache {
    String key();
    long ttlSeconds() default 60;
}

@Aspect
@Component
public class MethodCacheAspect {

    private final Map<String, CacheEntry> cache = new ConcurrentHashMap<>();

    @Around("@annotation(methodCache)")
    public Object around(ProceedingJoinPoint pjp, MethodCache methodCache) throws Throwable {
        String key = buildKey(pjp, methodCache.key());
        long now = System.currentTimeMillis();
        CacheEntry entry = cache.get(key);

        if (entry != null && now - entry.time < methodCache.ttlSeconds() * 1000L) {
            return entry.value;                    // 命中缓存，不执行原方法
        }

        Object value = pjp.proceed();              // 未命中，执行原方法
        if (value != null) {
            cache.put(key, new CacheEntry(now, value));
        }
        return value;
    }

    public void evictPrefix(String prefix) {
        String start = prefix + ":";
        cache.keySet().removeIf(key -> key.startsWith(start));
    }

    private String buildKey(ProceedingJoinPoint pjp, String prefix) {
        StringBuilder key = new StringBuilder(prefix).append(':');
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        key.append(signature.getMethod().getName());
        for (Object arg : pjp.getArgs()) {
            key.append(':').append(arg == null ? "null" : arg);
        }
        return key.toString();
    }

    private record CacheEntry(long time, Object value) {}
}

String key = buildKey(pjp, methodCache.key());

site:site:cn
nav:nav:cn
site:site:us

StringBuilder key = new StringBuilder(prefix).append(':');   // site:
MethodSignature signature = (MethodSignature) pjp.getSignature(); // 方法信息
key.append(signature.getMethod().getName());                 // site
for (Object arg : pjp.getArgs()) {                            // 遍历所有参数
    key.append(':').append(arg == null ? "null" : arg);       // :cn
}

long now = System.currentTimeMillis();
CacheEntry entry = cache.get(key);

if (entry != null && now - entry.time < methodCache.ttlSeconds() * 1000L) {
    return entry.value;   // 命中
}

Object value = pjp.proceed();   // 真正进入 site() 方法体，查库
if (value != null) {
    cache.put(key, new CacheEntry(now, value));  // 把结果存进缓存
}
return value;

private record CacheEntry(long time, Object value) {}

public void evictPrefix(String prefix) {
    String start = prefix + ":";
    cache.keySet().removeIf(key -> key.startsWith(start));
}

缓存 Map（就在服务器内存里）
  key = "site:site:cn"
  value = Site{title="国科环宇", logo="/static/...", ...}
  附带时间 = 写入时刻

@MethodCache(key = "site", ttlSeconds = 60)
public Site site(String acode) { ... }

@MethodCache(key = "nav", ttlSeconds = 60)
public List<ContentSortTreeVO> nav(String acode) { ... }

// 保存站点后
methodCacheAspect.evictPrefix("site");

// 栏目增删改后
methodCacheAspect.evictPrefix("nav");

服务器 A 缓存了 site
服务器 B 没有这份缓存，自己又查了一次库

两台服务器共享同一个 Redis
A 写入缓存 → B 也能读到
A 删除缓存 → B 的下一次请求也查不到
TTL 由 Redis 统一管理，不用自己存时间戳

权限：Spring Security + 注解/拦截器 + AOP 切面
缓存：Spring Cache 注解 + Redis，热点叠 Caffeine
日志：AOP 切面记录，异步写库/MQ
事务：@Transactional（Spring AOP）