第6章 Spring生态系统

面试重要程度：⭐⭐⭐⭐⭐

常见提问方式：Spring IOC原理、AOP实现、循环依赖解决

预计阅读时间：45分钟

开场白

兄弟，Spring绝对是Java后端面试的重中之重！我敢说，99%的Java面试都会问到Spring相关的问题。不管是IOC、AOP，还是Spring Boot，这些都是必考内容。

今天我们就把Spring的核心原理彻底搞清楚，让你在面试中展现出对Spring框架的深度理解。

🌱 6.1 Spring Boot 3.0+新特性

GraalVM原生镜像支持

面试热点：

面试官："Spring Boot 3.0有什么重要的新特性？GraalVM原生镜像有什么优势？"

核心特性：

// 1. 支持AOT（Ahead-of-Time）编译
@SpringBootApplication
public class NativeApplication {
    public static void main(String[] args) {
        SpringApplication.run(NativeApplication.class, args);
    }
}

// 2. 构建原生镜像
// mvn -Pnative native:compile
// 或者使用Docker
// docker build -f Dockerfile.native -t myapp-native .

原生镜像的优势：

启动时间：从秒级降到毫秒级（50-100ms）
内存占用：从几百MB降到几十MB
镜像大小：从几百MB降到几十MB
冷启动：适合Serverless和容器化场景

实际对比：

# 传统JVM应用
启动时间：2-5秒
内存占用：200-500MB
镜像大小：200-300MB

# GraalVM原生镜像
启动时间：50-100ms
内存占用：20-50MB  
镜像大小：50-100MB

响应式编程WebFlux

面试重点：

// 传统的Spring MVC（阻塞式）
@RestController
public class TraditionalController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id); // 阻塞调用
    }
}

// Spring WebFlux（响应式）
@RestController
public class ReactiveController {
    
    @Autowired
    private ReactiveUserService userService;
    
    @GetMapping("/users/{id}")
    public Mono<User> getUser(@PathVariable Long id) {
        return userService.findById(id); // 非阻塞调用
    }
    
    @GetMapping("/users")
    public Flux<User> getAllUsers() {
        return userService.findAll()
            .delayElements(Duration.ofMillis(100)); // 背压处理
    }
}

响应式编程的优势：

// 高并发处理能力
@Service
public class ReactiveUserService {
    
    @Autowired
    private ReactiveUserRepository repository;
    
    public Flux<User> findAll() {
        return repository.findAll()
            .publishOn(Schedulers.parallel()) // 并行处理
            .map(this::enrichUser)           // 数据增强
            .filter(user -> user.isActive()) // 过滤
            .onErrorResume(ex -> {           // 错误处理
                log.error("Error processing user", ex);
                return Flux.empty();
            });
    }
    
    private User enrichUser(User user) {
        // 异步调用其他服务
        return user;
    }
}

🏗️ 6.2 IOC容器核心原理

Bean生命周期详解

面试必问：

面试官："说说Spring Bean的生命周期，每个阶段都做什么？"

完整生命周期：

@Component
public class LifecycleBean implements BeanNameAware, BeanFactoryAware, 
    ApplicationContextAware, InitializingBean, DisposableBean {
    
    private String beanName;
    private BeanFactory beanFactory;
    private ApplicationContext applicationContext;
    
    // 1. 构造器
    public LifecycleBean() {
        System.out.println("1. 构造器执行");
    }
    
    // 2. 设置属性
    @Value("${app.name:default}")
    private String appName;
    
    // 3. Aware接口回调
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("3. setBeanName: " + name);
    }
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
        System.out.println("3. setBeanFactory");
    }
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
        System.out.println("3. setApplicationContext");
    }
    
    // 4. BeanPostProcessor前置处理
    // 由框架调用，这里只是说明
    
    // 5. InitializingBean接口
    @Override
    public void afterPropertiesSet() {
        System.out.println("5. afterPropertiesSet");
    }
    
    // 6. 自定义初始化方法
    @PostConstruct
    public void customInit() {
        System.out.println("6. @PostConstruct");
    }
    
    // 7. BeanPostProcessor后置处理
    // 由框架调用，这里只是说明
    
    // 8. Bean可以使用了
    public void doSomething() {
        System.out.println("8. Bean正在工作...");
    }
    
    // 9. DisposableBean接口
    @Override
    public void destroy() {
        System.out.println("9. destroy");
    }
    
    // 10. 自定义销毁方法
    @PreDestroy
    public void customDestroy() {
        System.out.println("10. @PreDestroy");
    }
}

自定义BeanPostProcessor：

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if (bean instanceof LifecycleBean) {
            System.out.println("4. BeanPostProcessor前置处理: " + beanName);
        }
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof LifecycleBean) {
            System.out.println("7. BeanPostProcessor后置处理: " + beanName);
        }
        return bean;
    }
}

循环依赖三级缓存解决方案

面试高频：

面试官："Spring是如何解决循环依赖的？三级缓存是什么？"

循环依赖场景：

@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
    
    public void methodA() {
        serviceB.methodB();
    }
}

@Service
public class ServiceB {
    @Autowired
    private ServiceA serviceA;
    
    public void methodB() {
        serviceA.methodA();
    }
}

三级缓存机制：

public class DefaultSingletonBeanRegistry {
    
    // 一级缓存：完成初始化的单例Bean
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
    // 二级缓存：完成实例化但未初始化的Bean
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
    
    // 三级缓存：单例Bean的工厂
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 1. 从一级缓存获取
        Object singletonObject = this.singletonObjects.get(beanName);
        
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                // 2. 从二级缓存获取
                singletonObject = this.earlySingletonObjects.get(beanName);
                
                if (singletonObject == null && allowEarlyReference) {
                    // 3. 从三级缓存获取
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        // 放入二级缓存
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        // 从三级缓存移除
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }
}

解决过程详解：

// 循环依赖解决过程
// 1. 创建ServiceA
//    - 实例化ServiceA（构造器）
//    - 将ServiceA的ObjectFactory放入三级缓存
//    - 填充ServiceA的属性（发现需要ServiceB）

// 2. 创建ServiceB
//    - 实例化ServiceB（构造器）
//    - 将ServiceB的ObjectFactory放入三级缓存
//    - 填充ServiceB的属性（发现需要ServiceA）

// 3. 获取ServiceA
//    - 从三级缓存获取ServiceA的ObjectFactory
//    - 调用ObjectFactory.getObject()获取ServiceA实例
//    - 将ServiceA放入二级缓存，从三级缓存移除

// 4. ServiceB初始化完成
//    - ServiceB获得ServiceA的引用
//    - ServiceB初始化完成，放入一级缓存

// 5. ServiceA初始化完成
//    - ServiceA获得ServiceB的引用
//    - ServiceA初始化完成，放入一级缓存

@Autowired vs @Resource

面试对比：

@Service
public class InjectionDemo {
    
    // @Autowired：Spring注解，按类型注入
    @Autowired
    private UserService userService1;
    
    // @Autowired + @Qualifier：指定Bean名称
    @Autowired
    @Qualifier("userServiceImpl")
    private UserService userService2;
    
    // @Resource：JDK注解，按名称注入
    @Resource(name = "userServiceImpl")
    private UserService userService3;
    
    // @Resource：如果不指定name，按字段名查找
    @Resource
    private UserService userServiceImpl; // 会查找名为userServiceImpl的Bean
}

注入顺序对比：

@Autowired注入顺序：
1. 按类型查找Bean
2. 如果有多个，按@Primary注解
3. 如果没有@Primary，按@Qualifier指定
4. 如果没有@Qualifier，按字段名匹配

@Resource注入顺序：
1. 如果指定name，按name查找
2. 如果没有指定name，按字段名查找
3. 如果按名称找不到，按类型查找
4. 如果按类型找到多个，报错

🎯 6.3 AOP面向切面编程

JDK动态代理 vs CGLIB

面试重点：

面试官："Spring AOP是如何实现的？JDK动态代理和CGLIB有什么区别？"

JDK动态代理实现：

// 1. 目标接口
public interface UserService {
    void saveUser(String username);
    User findUser(Long id);
}

// 2. 目标实现类
@Service
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser(String username) {
        System.out.println("保存用户: " + username);
    }
    
    @Override
    public User findUser(Long id) {
        System.out.println("查找用户: " + id);
        return new User(id, "user" + id);
    }
}

// 3. JDK动态代理
public class JdkProxyDemo {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();
        
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("JDK代理 - 方法执行前: " + method.getName());
                    Object result = method.invoke(target, args);
                    System.out.println("JDK代理 - 方法执行后: " + method.getName());
                    return result;
                }
            }
        );
        
        proxy.saveUser("张三");
    }
}

CGLIB代理实现：

// 1. 目标类（不需要接口）
@Service
public class OrderService {
    public void createOrder(String orderNo) {
        System.out.println("创建订单: " + orderNo);
    }
}

// 2. CGLIB代理
public class CglibProxyDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(OrderService.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                System.out.println("CGLIB代理 - 方法执行前: " + method.getName());
                Object result = proxy.invokeSuper(obj, args);
                System.out.println("CGLIB代理 - 方法执行后: " + method.getName());
                return result;
            }
        });
        
        OrderService proxy = (OrderService) enhancer.create();
        proxy.createOrder("ORDER001");
    }
}

两种代理方式对比：

JDK动态代理：
✅ JDK原生支持，无需额外依赖
✅ 性能较好（方法调用）
❌ 只能代理接口，不能代理类
❌ 目标类必须实现接口

CGLIB代理：
✅ 可以代理类，不需要接口
✅ 功能更强大
❌ 需要额外依赖
❌ 不能代理final类和final方法
❌ 性能稍差（字节码生成）

Spring AOP实现原理

切面定义：

@Aspect
@Component
public class LoggingAspect {
    
    // 切点表达式
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayer() {}
    
    // 前置通知
    @Before("serviceLayer()")
    public void logBefore(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("方法执行前: " + methodName + ", 参数: " + Arrays.toString(args));
    }
    
    // 后置通知
    @After("serviceLayer()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("方法执行后: " + joinPoint.getSignatu