深入理解Spring核心：IOC/DI原理与AOP事务管理

程序员Bears

于 2025-05-23 09:59:04 发布

阅读量1.4k

点赞数 28

分类专栏： Java全栈成长笔记文章标签： spring 数据库 java

本文链接：https://blog.csdn.net/qq_57755194/article/details/148156863

版权

Java全栈成长笔记专栏收录该内容

25 篇文章

订阅专栏

前言

Spring框架作为Java企业级开发的"事实标准"，其核心思想与设计理念深刻影响了现代Java应用的架构方式。本文将深入剖析Spring的两大核心特性：IOC/DI（控制反转/依赖注入）和AOP（面向切面编程）的事务管理机制，帮助开发者不仅知其然，更知其所以然。

一、Spring IOC/DI原理深度解析

1.1 什么是控制反转(IOC)

控制反转(Inversion of Control)是一种设计原则，它将传统上由程序代码直接操控的对象调用权转移给容器管理。简而言之，就是"不要调用我，我会调用你"。

传统开发模式：

// 传统方式：由开发者主动创建依赖对象
public class UserService {
    private UserRepository userRepository = new UserRepositoryImpl();
    
    public void saveUser(User user) {
        userRepository.save(user);
    }
}

IOC模式：

// IOC方式：依赖由容器注入
public class UserService {
    private UserRepository userRepository;
    
    // 依赖通过构造器注入
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public void saveUser(User user) {
        userRepository.save(user);
    }
}

1.2 依赖注入(DI)的三种方式

Spring提供了三种主要的依赖注入方式：

构造器注入（推荐方式）

@Controller
public class UserController {
    private final UserService userService;
    
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }
}

Setter注入

@Controller
public class UserController {
    private UserService userService;
    
    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
}

字段注入（不推荐，仅用于简单场景）

@Controller
public class UserController {
    @Autowired
    private UserService userService;
}

1.3 Spring容器核心实现原理

Spring容器的核心是BeanFactory接口及其实现类，最常用的是ApplicationContext。容器的工作流程大致如下：

资源定位：通过ResourceLoader加载配置文件
Bean定义解析：BeanDefinitionReader解析配置为BeanDefinition
Bean注册：将BeanDefinition注册到BeanFactory
依赖注入：解决Bean之间的依赖关系
初始化：调用初始化方法(@PostConstruct、InitializingBean等)

// 简单模拟BeanFactory核心逻辑
public class SimpleBeanFactory {
    private Map<String, Object> beanMap = new HashMap<>();
    
    public void registerBean(String name, Object bean) {
        beanMap.put(name, bean);
    }
    
    public Object getBean(String name) {
        return beanMap.get(name);
    }
}

1.4 循环依赖问题及解决方案

Spring通过三级缓存解决循环依赖问题：

一级缓存：存放完全初始化好的Bean
二级缓存：存放早期暴露的Bean（已实例化但未初始化）
三级缓存：存放Bean工厂，用于生成早期引用

// 伪代码展示三级缓存解决循环依赖
public Object getBean(String name) {
    // 1. 检查一级缓存
    Object bean = singletonObjects.get(name);
    if (bean != null) return bean;
    
    // 2. 检查二级缓存
    bean = earlySingletonObjects.get(name);
    if (bean != null) return bean;
    
    // 3. 创建Bean实例
    ObjectFactory<?> singletonFactory = singletonFactories.get(name);
    if (singletonFactory != null) {
        bean = singletonFactory.getObject();
        earlySingletonObjects.put(name, bean);
        singletonFactories.remove(name);
        return bean;
    }
    
    // 完整创建过程...
}

二、Spring AOP与事务管理

2.1 AOP核心概念

AOP（Aspect-Oriented Programming）面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护。

核心术语：

Aspect（切面）：跨越多个类的关注点的模块化
Join Point（连接点）：程序执行过程中的特定点
Advice（通知）：在特定连接点执行的动作
Pointcut（切点）：匹配连接点的谓词
Target Object（目标对象）：被一个或多个切面通知的对象
AOP Proxy：由AOP框架创建的对象，用于实现切面契约

2.2 Spring AOP实现原理

Spring AOP主要通过两种方式实现动态代理：

JDK动态代理（基于接口）

public class JdkDynamicProxy implements InvocationHandler {
    private Object target;
    
    public JdkDynamicProxy(Object target) {
        this.target = target;
    }
    
    public Object getProxy() {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            this);
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置增强
        System.out.println("Before method: " + method.getName());
        
        // 执行目标方法
        Object result = method.invoke(target, args);
        
        // 后置增强
        System.out.println("After method: " + method.getName());
        return result;
    }
}

CGLIB动态代理（基于类）

public class CglibProxy implements MethodInterceptor {
    public Object getProxy(Class<?> clazz) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 前置增强
        System.out.println("Before method: " + method.getName());
        
        // 执行目标方法
        Object result = proxy.invokeSuper(obj, args);
        
        // 后置增强
        System.out.println("After method: " + method.getName());
        return result;
    }
}

2.3 Spring事务管理机制

Spring事务管理的核心接口是PlatformTransactionManager，其主要实现类包括：

DataSourceTransactionManager：用于JDBC和MyBatis
HibernateTransactionManager：用于Hibernate
JpaTransactionManager：用于JPA

声明式事务配置：

@Configuration
@EnableTransactionManagement
public class AppConfig {
    
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

事务传播行为：

REQUIRED（默认）：如果当前没有事务，就新建一个事务
SUPPORTS：如果当前有事务，就加入该事务
MANDATORY：必须在一个已有的事务中执行
REQUIRES_NEW：新建事务，如果当前有事务则挂起
NOT_SUPPORTED：以非事务方式执行，如果当前有事务则挂起
NEVER：以非事务方式执行，如果当前有事务则抛出异常
NESTED：如果当前有事务，则在嵌套事务内执行

2.4 事务失效的常见场景及解决方案

方法非public：Spring AOP要求代理方法必须是public

// 错误示例
@Transactional
private void updateData() {
    // ...
}

自调用问题：同一个类中方法调用不会经过代理

public class UserService {
    public void updateUser() {
        // 不会触发事务
        this.updateProfile();
    }
    
    @Transactional
    public void updateProfile() {
        // ...
    }
}

异常被捕获：默认只对RuntimeException回滚

@Transactional
public void update() {
    try {
        // 数据库操作
    } catch (Exception e) {
        // 异常被捕获，事务不会回滚
    }
}

数据库引擎不支持：如MyISAM不支持事务

三、最佳实践与性能优化

3.1 IOC/DI最佳实践

优先使用构造器注入

保证依赖不可变（final字段）
避免循环依赖问题
更易于测试

合理使用懒加载

@Component
@Lazy
public class HeavyService {
    // 该Bean将在首次请求时初始化
}

注意Bean的作用域

singleton（默认）：每个容器一个实例
prototype：每次请求新实例
request：每个HTTP请求新实例
session：每个HTTP会话新实例

3.2 AOP性能优化建议

精确配置切点表达式：避免过于宽泛的切点

// 不推荐
@Pointcut("execution(* com.example..*.*(..))")

// 推荐
@Pointcut("execution(* com.example.service.*.*(..))")

合理使用@Around：避免在切面中执行耗时操作

缓存代理对象：避免频繁创建代理对象

3.3 事务优化策略

设置合适的事务隔离级别

READ_UNCOMMITTED：可能脏读
READ_COMMITTED（默认）：避免脏读
REPEATABLE_READ：避免不可重复读
SERIALIZABLE：最高隔离级别

控制事务粒度：避免大事务

// 不推荐
@Transactional
public void processBatch() {
    // 处理大量数据
}

// 推荐
public void processBatch() {
    List<Data> dataList = fetchData();
    for (Data data : dataList) {
        processSingle(data);
    }
}

@Transactional
public void processSingle(Data data) {
    // 处理单个数据
}

只读事务优化

@Transactional(readOnly = true)
public List<User> queryUsers() {
    // 查询操作
}

结语

Spring框架的IOC/DI和AOP机制是其核心竞争力的关键所在。理解这些原理不仅能够帮助我们更好地使用Spring，还能在遇到问题时快速定位和解决。希望本文能够帮助读者深入理解Spring的核心机制，在实际开发中更加得心应手。

思考题：

在微服务架构下，Spring的事务管理有哪些局限性？如何解决分布式事务问题？
除了事务管理，AOP还能应用于哪些常见场景？
如何基于Spring的扩展点实现自定义的Bean生命周期管理？

欢迎在评论区留下你的见解和问题，我们一起探讨Spring的更多奥秘！