🔗 Spring 生态因果链

// ✅ IoC：不再自己new，让Spring容器给你 @Service public class UserService { @Autowired // Spring自动注入，不再new private UserDao userDao; // 接口！不是实现类！ public User getUser(Long id) { return userDao.findById(id); } } @Repository public class UserDaoImpl implements UserDao { ... } // 想换实现？新写一个类加@Repository就行，不用改UserService！

// Spring IoC 底层原理（简化版） public class SimpleIocContainer { private Map<String, Object> singletonObjects = new ConcurrentHashMap<>(); public void registerBean(String name, Class<?> clazz) throws Exception { // 反射创建实例 Object instance = clazz.getDeclaredConstructor().newInstance(); singletonObjects.put(name, instance); } public Object getBean(String name) { return singletonObjects.get(name); } } // 使用 SimpleIocContainer container = new SimpleIocContainer(); container.registerBean("userService", UserService.class); UserService service = (UserService) container.getBean("userService");

// 方式1：构造器注入（✅ Spring推荐） @Service public class UserService { private final UserDao userDao; private final EmailService emailService; @Autowired // 构造器只有一个参数时可省略 public UserService(UserDao userDao, EmailService emailService) { this.userDao = userDao; this.emailService = emailService; } } // 方式2：Setter注入 @Service public class OrderService { private PaymentService paymentService; @Autowired public void setPaymentService(PaymentService paymentService) { this.paymentService = paymentService; } } // 方式3：字段注入（❌ 不推荐，但最常见） @Service public class ProductService { @Autowired // 反射直接注入字段 private ProductDao productDao; }

// AOP 切面：自动加日志 @Aspect @Component public class LogAspect { @Around("execution(* com.example.service..*.*(..))") public Object logAround(ProceedingJoinPoint pjp) throws Throwable { String methodName = pjp.getSignature().getName(); log.info("开始执行: {}", methodName); try { Object result = pjp.proceed(); // 执行真正的方法 log.info("执行成功: {}", methodName); return result; } catch (Exception e) { log.error("执行失败: {}", methodName, e); throw e; } } } // 业务代码终于干净了！ @Service public class OrderService { public void createOrder(OrderDTO dto) { orderDao.insert(dto); // 只有业务逻辑！ } }

// ✅ 一个注解代替20行事务代码 @Transactional public void transfer(Long from, Long to, BigDecimal amount) { accountDao.debit(from, amount); accountDao.credit(to, amount); // 出异常自动回滚！ }

// Spring Boot 自动装配的因果链： // 1. @SpringBootApplication 包含 @EnableAutoConfiguration // 2. @EnableAutoConfiguration 通过 @Import 加载 AutoConfigurationImportSelector // 3. AutoConfigurationImportSelector 读取 META-INF/spring.factories // 4. spring.factories 里列出了所有自动配置类 // 5. 每个自动配置类用 @Conditional 系列注解判断是否生效 // 自动配置类示例 @AutoConfiguration @ConditionalOnClass(DataSource.class) // 因为classpath有DataSource @ConditionalOnMissingBean(DataSource.class) // 因为没有手动配DataSource public class DataSourceAutoConfiguration { @Bean @ConfigurationProperties(prefix = "spring.datasource") public DataSource dataSource() { return DataSourceBuilder.create().build(); } } // 所以：只要引入依赖 + 写配置文件，Bean就自动创建了！

// 自定义Starter结构 my-redis-spring-boot-starter/ ├── pom.xml // 依赖 spring-boot-starter + redis客户端 └── src/main/resources/ └── META-INF/ └── spring.factories // 声明自动配置类 └── src/main/java/ └── com/example/redis/ ├── RedisAutoConfiguration.java // 自动配置类 ├── RedisProperties.java // 配置属性 └── RedisService.java // 封装好的Redis操作 // RedisAutoConfiguration @AutoConfiguration @ConditionalOnClass(RedisTemplate.class) @EnableConfigurationProperties(RedisProperties.class) public class RedisAutoConfiguration { @Bean @ConditionalOnMissingBean public RedisTemplate<String, Object> redisTemplate( RedisConnectionFactory factory, RedisProperties props) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(factory); // 默认用Jackson序列化 template.setDefaultSerializer(new GenericJackson2JsonRedisSerializer()); return template; } } // 使用方只需： // 1. pom.xml 加 <dependency>my-redis-spring-boot-starter</dependency> // 2. application.yml 加 spring.redis.host=xxx // 完事！RedisTemplate直接@Autowired注入

// Spring 三级缓存解决循环依赖 // 一级缓存：singletonObjects → 完整的Bean // 二级缓存：earlySingletonObjects → 早期引用（可能被AOP代理） // 三级缓存：singletonFactories → Bean工厂（用于生成代理） // 创建流程（A → B → A循环）： // 1. 创建A，实例化后放入三级缓存（ObjectFactory） // 2. A发现需要B，去创建B // 3. B发现需要A，从三级缓存获取A的早期引用 // （如果A需要AOP代理，ObjectFactory会提前生成代理对象） // 4. B拿到A的早期引用，完成创建 // 5. A拿到B，完成创建 // 6. A和B都创建完毕 // 为什么需要三级？二级不够吗？ // 因为AOP！如果A需要代理，ObjectFactory才能生成代理对象 // 二级缓存只存引用，不能判断是否需要代理 // 三级缓存的ObjectFactory调用时才决定：普通Bean直接返回，AOP Bean返回代理

@Component public class MyBean implements InitializingBean, DisposableBean, BeanNameAware, ApplicationContextAware { @Autowired private SomeDependency dep; // 第2步：属性赋值 @Override public void setBeanName(String name) { // 第3步：Aware回调 log.info("我的名字是: {}", name); } @Override public void setApplicationContext(ApplicationContext ctx) { log.info("拿到了ApplicationContext"); } @PostConstruct // 第6步：自定义初始化 public void init() { log.info("@PostConstruct 初始化"); } @Override public void afterPropertiesSet() { // 第5步：接口初始化 log.info("afterPropertiesSet 初始化"); } @PreDestroy // 第9步：销毁前 public void cleanup() { log.info("@PreDestroy 清理资源"); } @Override public void destroy() { log.info("DisposableBean 销毁"); } } // 输出顺序： // 1. 实例化 (构造器) // 2. 属性赋值 (@Autowired) // 3. setBeanName // 4. setApplicationContext // 5. @PostConstruct // 6. afterPropertiesSet // 7. BeanPostProcessor后置处理 (AOP代理在这里) // -- Bean就绪，可使用 -- // 8. @PreDestroy // 9. destroy