企业官网建设流程全解析

一、先搞懂：为什么需要 AOP？（解决什么痛点）

先看一个典型问题：假如你有 3 个业务方法（用户注册、订单创建、支付），每个方法都需要加「日志记录」「权限校验」「异常处理」逻辑，传统写法会这样：

java

运行

// 传统写法：通用逻辑和业务逻辑耦合 public void registerUser() { // 1. 日志记录（通用逻辑） log.info("开始执行用户注册"); // 2. 权限校验（通用逻辑） if (!hasPermission()) { throw new NoPermissionException(); } try { // 3. 核心业务逻辑 userService.save(); } catch (Exception e) { // 4. 异常处理（通用逻辑） log.error("注册失败", e); throw e; } } public void createOrder() { // 重复的日志、权限、异常逻辑... orderService.save(); }

痛点：通用逻辑（日志、权限）重复写，代码冗余，维护成本高（比如要改日志格式，得改所有方法）。

AOP 的解决思路：把日志、权限这些通用逻辑抽成「切面」，在不修改业务代码的前提下，自动 “织入” 到业务方法的执行环节（比如执行前、执行后、抛出异常时）。

二、AOP 核心概念（新手必记）

用 “切蛋糕” 类比：业务逻辑是蛋糕的主体，AOP 是 “刀”，按指定规则（切点）切到蛋糕的指定位置（连接点），把切面逻辑（奶油 / 水果）加进去。

常见的通知类型（核心）：

1. 前置通知（Before）：业务方法执行前执行（比如权限校验）；
2. 后置通知（After）：业务方法执行后执行（无论是否异常，比如清理资源）；
3. 返回通知（AfterReturning）：业务方法正常返回后执行（比如记录方法返回值）；
4. 异常通知（AfterThrowing）：业务方法抛出异常后执行（比如异常日志）；
5. 环绕通知（Around）：包裹业务方法执行（可控制方法是否执行、修改参数 / 返回值，最灵活）。

三、AOP 实现原理（两种核心方式）

AOP 本身是思想，主流实现有两种：

1. 静态代理（编译期织入）

• 原理：通过修改字节码实现（比如 AspectJ），编译时直接把切面逻辑编译到业务类的字节码中；
• 特点：性能高（运行时无额外开销），但需要特殊编译器；
• 适用：对性能要求极高的场景。

2. 动态代理（运行期织入）

• 原理：运行时动态生成业务类的代理对象，调用业务方法时先执行切面逻辑（Spring AOP 默认方式）；
• 两种实现：
  • JDK 动态代理：基于接口，只能代理实现了接口的类；
  • CGLIB 动态代理：基于继承，可代理任意类（即使没实现接口）；
• 特点：无需修改字节码，灵活，但运行时有轻微性能损耗（可忽略）；
• 适用：大部分业务场景（Spring AOP 首选）。

四、Spring AOP 实战示例（新手能跑通）

Spring AOP 是最常用的 AOP 框架，下面用「日志切面」演示核心用法：

前置条件

1. 引入 Spring AOP 依赖（Maven）：

xml

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

步骤 1：定义切面类（核心）

java

运行

import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; // 1. 标记为组件（Spring扫描）+ 标记为切面 @Component @Aspect public class LogAspect { // 2. 定义切点：匹配com.example.service包下所有类的所有方法 @Pointcut("execution(* com.example.service.*.*(..))") public void servicePointcut() {} // 3. 前置通知：方法执行前打日志 @Before("servicePointcut()") public void beforeAdvice(JoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName(); // 获取方法名 Object[] args = joinPoint.getArgs(); // 获取方法参数 System.out.println("前置通知：执行方法[" + methodName + "]，参数：" + args); } // 4. 环绕通知：统计方法执行耗时 @Around("servicePointcut()") public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable { long start = System.currentTimeMillis(); // 执行原业务方法 Object result = joinPoint.proceed(); long cost = System.currentTimeMillis() - start; System.out.println("环绕通知：方法[" + joinPoint.getSignature().getName() + "]耗时" + cost + "ms"); return result; } // 5. 异常通知：方法抛异常时打日志 @AfterThrowing(pointcut = "servicePointcut()", throwing = "e") public void afterThrowingAdvice(JoinPoint joinPoint, Exception e) { String methodName = joinPoint.getSignature().getName(); System.out.println("异常通知：方法[" + methodName + "]抛出异常：" + e.getMessage()); } }

步骤 2：定义业务类

java

运行

import org.springframework.stereotype.Service; @Service public class UserService { public void register(String username) { System.out.println("核心业务：用户[" + username + "]注册成功"); // 模拟异常（可注释测试） // if (username.isEmpty()) { // throw new RuntimeException("用户名不能为空"); // } } }

步骤 3：测试执行

java

运行

import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.ConfigurableApplicationContext; @SpringBootApplication public class AopDemoApplication { public static void main(String[] args) { ConfigurableApplicationContext context = SpringApplication.run(AopDemoApplication.class, args); UserService userService = context.getBean(UserService.class); userService.register("张三"); // 调用业务方法 } }

输出结果

plaintext

前置通知：执行方法[register]，参数：[张三] 核心业务：用户[张三]注册成功 环绕通知：方法[register]耗时1ms

五、AOP 典型使用场景

1. 日志记录：接口调用日志、方法执行日志、异常日志（最常用）；
2. 权限校验：接口访问前校验用户权限，无权限则拦截；
3. 事务管理：方法执行前开启事务，执行成功提交，失败回滚（Spring 事务底层就是 AOP）；
4. 性能监控：统计方法执行耗时、接口响应时间；
5. 缓存控制：方法执行前查缓存，有则返回，无则执行方法并缓存结果；
6. 异常统一处理：集中捕获业务异常，统一返回格式。

总结

1. AOP 的核心是解耦：把通用逻辑（日志、权限）从业务逻辑中抽离，实现 “一处定义，处处使用”；
2. Spring AOP 是主流实现，基于动态代理，通过「切面 + 切点 + 通知」完成逻辑织入；
3. 高频场景：日志、权限、事务、性能监控，是企业级开发的必备技能。