Java AOP：六大常见场景，轻松搞定权限控制和异常处理

2022-11-01 17:16:38

Java AOP：提升权限，化解异常，代码更优雅

在 Java 应用程序中，权限控制和异常处理至关重要，但手动实现却繁琐且易出错。本文将介绍 AOP（面向切面编程）在解决这些问题中的强大作用，让你的代码更优雅、更条理清晰。

权限控制：细粒度管理，安全无忧

为了确保用户只能执行授权操作，我们需要对权限进行控制。使用 AOP，你可以通过注解标记受保护的方法（例如，@RequiresPermissions），创建一个切面类来拦截这些方法，并在执行前进行权限检查。如果用户没有权限，则抛出异常。

@RequiresPermissions("user:read")
public void readUser(Long id) {
    // ...
}

@Aspect
@Order(1)
public class PermissionsAspect {

    @Around("@annotation(RequiresPermissions)")
    public Object checkPermissions(ProceedingJoinPoint joinPoint) throws Throwable {
        // 检查用户是否有权限
        if (!hasPermission(joinPoint)) {
            throw new AccessDeniedException("无权限！");
        }
        
        // 继续执行方法
        return joinPoint.proceed();
    }

}

异常处理：全局守护，尽在掌握

异常是应用程序不可避免的一部分。通过使用 AOP，你可以全局处理异常，确保应用程序能够继续正常运行。为需要异常处理的方法添加一个注解（例如，@GlobalExceptionHandler），创建一个切面类来拦截这些方法，并在方法执行前后进行异常处理。

@GlobalExceptionHandler
public void handleException(Throwable t) {
    // 记录异常信息
    logger.error("发生了异常", t);
    // ...
}

日志记录：事无巨细，洞察全局

日志记录对于了解应用程序行为至关重要。使用 AOP，你可以通过注解（例如，@LogExecution）标记需要记录的方法，创建一个切面类来拦截这些方法，并在方法执行前后添加日志记录语句。这样，无论方法是否成功执行，你都可以记录下方法执行信息，以便后续分析和排查问题。

@LogExecution
public void createUser(User user) {
    // ...
}

@Aspect
@Order(2)
public class LoggingAspect {

    @Around("@annotation(LogExecution)")
    public Object logExecution(ProceedingJoinPoint joinPoint) throws Throwable {
        // 方法执行前记录日志
        logger.info("方法 {} 开始执行，参数为 {}", joinPoint.getSignature(), joinPoint.getArgs());
        
        try {
            // 执行方法
            return joinPoint.proceed();
        } catch (Throwable t) {
            // 方法执行失败，记录异常
            logger.error("方法 {} 执行失败，原因：{}", joinPoint.getSignature(), t);
            throw t;
        } finally {
            // 方法执行后记录日志
            logger.info("方法 {} 执行结束，返回值为 {}", joinPoint.getSignature(), joinPoint.proceed());
        }
    }

}

性能监控：瓶颈探查，优化之道

性能监控对于发现应用程序性能瓶颈至关重要。使用 AOP，你可以通过注解（例如，@PerformanceMonitor）标记需要监控的方法，创建一个切面类来拦截这些方法，并在方法执行前后记录方法执行时间。这样，你就可以轻松地找出应用程序的性能瓶颈，并进行优化。

@PerformanceMonitor
public void processData(List<Data> data) {
    // ...
}

@Aspect
@Order(3)
public class PerformanceMonitoringAspect {

    @Around("@annotation(PerformanceMonitor)")
    public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
        // 方法执行前记录开始时间
        long startTime = System.currentTimeMillis();
        
        try {
            // 执行方法
            return joinPoint.proceed();
        } catch (Throwable t) {
            // 方法执行失败，记录异常
            logger.error("方法 {} 执行失败，原因：{}", joinPoint.getSignature(), t);
            throw t;
        } finally {
            // 方法执行后记录结束时间和执行时间
            long endTime = System.currentTimeMillis();
            logger.info("方法 {} 执行耗时 {} ms", joinPoint.getSignature(), (endTime - startTime));
        }
    }

}

事务管理：确保一致，有条不紊

事务管理对于确保数据完整性至关重要。使用 AOP，你可以通过注解（例如，@Transactional）标记需要事务管理的方法，创建一个切面类来拦截这些方法，并在方法执行前后进行事务管理。这样，你可以轻松地确保应用程序中的多个操作要么全部成功，要么全部失败。

@Transactional
public void transferMoney(Long fromAccountId, Long toAccountId, BigDecimal amount) {
    // ...
}

@Aspect
@Order(4)
public class TransactionManagementAspect {

    @Around("@annotation(Transactional)")
    public Object manageTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取事务管理器
        TransactionManager transactionManager = getTransactionManager();
        
        // 创建事务
        Transaction transaction = transactionManager.getTransaction();
        try {
            // 执行方法
            return joinPoint.proceed();
        } catch (Throwable t) {
            // 回滚事务
            if (transaction.isActive()) {
                transactionManager.rollback(transaction);
            }
            
            // 抛出异常
            throw t;
        } finally {
            // 提交事务
            if (transaction.isActive()) {
                transactionManager.commit(transaction);
            }
        }
    }

}

缓存管理：提升性能，妙不可言

缓存管理对于提升应用程序性能至关重要。使用 AOP，你可以通过注解（例如，@Cacheable）标记需要缓存的方法，创建一个切面类来拦截这些方法，并在方法执行前后进行缓存管理。这样，你就可以将经常使用的数据存储在内存中，以便下次使用时可以快速访问。

@Cacheable(cacheName = "users")
public User getUser(Long id) {
    // ...
}

@Aspect
@Order(5)
public class CacheManagementAspect {

    @Around("@annotation(Cacheable)")
    public Object manageCache(ProceedingJoinPoint joinPoint) throws Throwable {
        // 从缓存中获取数据
        Object cachedValue = getCachedValue(joinPoint.getSignature().toLongString());
        if (cachedValue != null) {
            // 直接返回缓存数据
            return cachedValue;
        }
        
        // 执行方法获取数据
        Object result = joinPoint.proceed();
        
        // 将数据放入缓存
        putCachedValue(joinPoint.getSignature().toLongString(), result);
        
        // 返回数据
        return result;
    }

}