深入解析 Spring IOC AOP：原理、源码与实战

深入解析 Spring IOC & AOP：原理、源码与实战

Spring 框架的核心在于 IOC（控制反转） 和 AOP（面向切面编程）。今天，我们将深入剖析它们的原理，结合源码解析，并通过 Java 代码实战来掌握这两个核心概念。

📌 1. 什么是 IOC（控制反转）？

IOC（Inversion of Control）是 Spring 的核心思想，它将对象的创建和依赖关系的管理交给 Spring 容器，避免了传统的 new 关键字实例化方式。

🔥 1.1 IOC 机制

Spring 使用 BeanFactory 和 ApplicationContext 管理 Bean 的生命周期，主要流程如下：

读取配置（XML 或注解）
实例化 Bean（通过 BeanFactory）
依赖注入（通过 @Autowired）
Bean 生命周期管理

📌 2. 手写简易 IOC 容器

我们用 Java 代码手写一个简化版的 IOC 容器，模拟 Spring 依赖注入的实现。

📝 代码示例：

import java.util.HashMap;
import java.util.Map;// 模拟 Spring 容器
class SimpleIOC {private Map<String, Object> beanContainer = new HashMap<>();// 注册 Beanpublic void registerBean(String name, Object obj) {beanContainer.put(name, obj);}// 获取 Beanpublic Object getBean(String name) {return beanContainer.get(name);}
}// 测试 IOC 容器
class UserService {public void sayHello() {System.out.println("Hello, Spring IOC!");}
}public class TestIOC {public static void main(String[] args) {SimpleIOC ioc = new SimpleIOC();ioc.registerBean("userService", new UserService());UserService userService = (UserService) ioc.getBean("userService");userService.sayHello();}
}

🔍 运行结果

Hello, Spring IOC!

✅ 分析：

SimpleIOC 充当 Spring 容器，存储和管理 Bean 实例。
registerBean() 方法模拟 ApplicationContext 注册 Bean 的功能。
getBean() 方法模拟 getBean(Class<T> clazz) 获取对象。

📌 3. 什么是 AOP（面向切面编程）？

AOP（Aspect-Oriented Programming）通过 动态代理 在方法执行前后加入额外逻辑，常用于 日志、事务、权限控制 等场景。

🔥 3.1 AOP 机制

Spring AOP 主要通过 JDK 动态代理（基于接口）和 CGLIB（基于子类）实现。

📖 3.2 Spring AOP 代理模式

Spring AOP 主要使用 代理模式，在目标方法执行前后执行增强逻辑，如：

@Before（前置通知）
@AfterReturning（后置通知）
@Around（环绕通知）

📌 4. 手写 AOP 代理（JDK 动态代理）

我们使用 JDK 动态代理 实现 AOP，模拟 Spring @Transactional 事务管理。

📝 代码示例：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;// 业务接口
interface UserService {void createUser();
}// 业务实现类
class UserServiceImpl implements UserService {public void createUser() {System.out.println("创建用户...");}
}// AOP 代理类
class AOPProxy implements InvocationHandler {private Object target;public AOPProxy(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("开启事务...");Object result = method.invoke(target, args);System.out.println("提交事务...");return result;}// 生成代理对象public static Object getProxy(Object target) {return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),new AOPProxy(target));}
}// 测试 AOP 代理
public class TestAOP {public static void main(String[] args) {UserService userService = new UserServiceImpl();UserService proxyService = (UserService) AOPProxy.getProxy(userService);proxyService.createUser();}
}

🔍 运行结果

开启事务...
创建用户...
提交事务...

✅ 分析：

AOPProxy 通过 JDK 动态代理 在方法调用前后加入事务逻辑。
getProxy() 生成代理对象，并拦截 UserService 的方法调用。
运行后，createUser() 方法被代理增强，实现 AOP 事务管理功能。

📌 5. Spring AOP 实战（@Aspect）

在 Spring 中，我们可以使用 @Aspect 和 @Around 注解实现 AOP 事务管理。

📝 代码示例：

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;@Aspect
@Component
public class TransactionAspect {@Before("execution(* com.service.*.*(..))")public void beginTransaction() {System.out.println("开启事务...");}@After("execution(* com.service.*.*(..))")public void commitTransaction() {System.out.println("提交事务...");}
}