Spring事务管理@Transactional注解最佳实践

实例化
  ↓
属性赋值 (populateBean)
  ↓
BeanNameAware (setBeanName)
  ↓
BeanFactoryAware (setBeanFactory)
  ↓
ApplicationContextAware (setApplicationContext)
  ↓
BeanPostProcessor前置 (postProcessBeforeInitialization)
  ↓
InitializingBean (afterPropertiesSet)
  ↓
init-method (自定义初始化方法)
  ↓
BeanPostProcessor后置 (postProcessAfterInitialization)
  ↓
使用Bean (ready for use)
  ↓
DisposableBean (destroy)
  ↓
destroy-method (自定义销毁方法)

// 1. 构造器注入（推荐）
@Component
public class UserService {
    private final UserRepository userRepository;
    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}
// 2. Setter注入
@Component
public class UserService {
    private UserRepository userRepository;
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}
// 3. 字段注入（不推荐）
@Component
public class UserService {
    @Autowired
    private UserRepository userRepository;
}

@Aspect
@Component
public class LoggingAspect {
    // 前置通知
    @Before("execution(* com.example.service.*.*(..))")
    public void beforeMethod(JoinPoint joinPoint) {
        System.out.println("Before: " + joinPoint.getSignature());
    }
    // 后置通知
    @After("execution(* com.example.service.*.*(..))")
    public void afterMethod(JoinPoint joinPoint) {
        System.out.println("After: " + joinPoint.getSignature());
    }
    // 返回通知
    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))",
                     returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("AfterReturning: " + result);
    }
    // 异常通知
    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))",
                   throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Exception ex) {
        System.out.println("AfterThrowing: " + ex.getMessage());
    }
    // 环绕通知
    @Around("execution(* com.example.service.*.*(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Around Before");
        Object result = joinPoint.proceed();
        System.out.println("Around After");
        return result;
    }
}

@Service
public class OrderService {
    // 声明式事务
    @Transactional(
        propagation = Propagation.REQUIRED,  // 传播行为
        isolation = Isolation.READ_COMMITTED,  // 隔离级别
        timeout = 30,  // 超时时间
        readOnly = false,  // 只读
        rollbackFor = Exception.class  // 回滚异常
    )
    public void createOrder(Order order) {
        // 业务逻辑
    }
}

// @EnableAutoConfiguration 注解
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    String[] excludeName() default {};
}
// 自动配置类示例
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(DataSource.class)
@ConditionalOnProperty(prefix = "spring.datasource", name = "url")
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {
    // 配置逻辑
}

// 条件注解
@ConditionalOnClass        // 类路径下存在指定类
@ConditionalOnMissingClass  // 类路径下不存在指定类
@ConditionalOnBean         // 容器中存在指定Bean
@ConditionalOnMissingBean   // 容器中不存在指定Bean
@ConditionalOnProperty      // 配置属性满足条件
@ConditionalOnWebApplication  // Web环境

// 三级缓存
1. singletonObjects          // 一级缓存：完整的Bean
2. earlySingletonObjects     // 二级缓存：提前暴露的Bean
3. singletonFactories        // 三级缓存：Bean的工厂
// 解决流程
1. A实例化后，放入三级缓存
2. A注入B，B需要A
3. B从三级缓存获取A的工厂，创建A的代理对象
4. B注入A的代理对象，B完成初始化
5. A继续初始化，注入B，完成初始化