殷龙飞的博客

Java技术专家面试专题系列（四）：Spring框架核心

 面试/技术专家  2041  5 分钟

Spring框架是Java开发的基石，以其轻量级和模块化设计广泛应用于企业级开发。本篇将从IOC容器、AOP机制、Spring Boot自动配置到事务管理和MVC流程，系统讲解Spring的核心内容，助你在面试中展现框架掌握度和问题解决能力。

1. IOC容器与依赖注入

IOC（Inversion of Control，控制反转）是Spring的核心，通过依赖注入（DI）解耦组件。

  • IOC原理

    • 将对象创建和管理交给容器，开发者只需声明依赖。
    • 实现方式：XML配置、注解（@Autowired）、Java Config。

  • Bean生命周期

    1. 实例化。
    2. 属性填充（依赖注入）。
    3. 初始化（@PostConstruct或InitializingBean）。
    4. 使用。
    5. 销毁（@PreDestroy或DisposableBean）。

示例: 注解方式依赖注入

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import org.springframework.context.annotation.*;
import org.springframework.stereotype.Component;

@Component
class UserService {
    public String getUser() {
        return "User: Alice";
    }
}

@Component
class OrderService {
    private final UserService userService;

    @Autowired
    public OrderService(UserService userService) {
        this.userService = userService;
    }

    public String getOrder() {
        return "Order with " + userService.getUser();
    }
}

@Configuration
@ComponentScan("com.example")
class AppConfig {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        OrderService orderService = context.getBean(OrderService.class);
        System.out.println(orderService.getOrder()); // 输出: Order with User: Alice
        context.close();
    }
}

面试问题:

  • 问题: Bean的生命周期有哪些扩展点？
  • 答案: 可通过BeanPostProcessor在实例化和初始化前后干预，或用@PostConstruct和@PreDestroy自定义逻辑。

2. AOP实现机制

AOP（Aspect-Oriented Programming，面向切面编程）用于处理横切关注点（如日志、事务）。

  • 核心概念

    • 切面（Aspect）: 封装横切逻辑。
    • 切点（Pointcut）: 定义拦截规则。
    • 通知（Advice）: 前置、后置、环绕等。

  • 实现原理

    • 动态代理: JDK代理（基于接口）、CGLIB（基于类）。
    • Spring默认使用JDK代理，若无接口则用CGLIB。

示例: AOP日志

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
@Component
class LoggingAspect {
    @Before("execution(* com.example.OrderService.getOrder(..))")
    public void logBefore() {
        System.out.println("Before calling getOrder");
    }

    @AfterReturning(pointcut = "execution(* com.example.OrderService.getOrder(..))", returning = "result")
    public void logAfter(String result) {
        System.out.println("After returning: " + result);
    }
}

// 配置类需启用AOP
@Configuration
@ComponentScan("com.example")
@EnableAspectJAutoProxy
class AppConfig {
    // 同上
}

面试问题:

  • 问题: AOP的底层如何实现？
  • 答案: 通过动态代理实现，JDK代理基于接口生成代理类，CGLIB通过字节码生成子类，Spring根据目标类是否实现接口选择。

3. Spring Boot自动配置

Spring Boot简化了Spring开发，通过自动配置提升效率。

  • 原理

    • @SpringBootApplication包含@EnableAutoConfiguration，加载spring.factories中的配置类。
    • 条件注解（如@ConditionalOnClass）决定是否生效。

  • 自定义配置

    • 通过application.properties或自定义@Configuration覆盖默认配置。

示例: 自定义属性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "app")
class AppProperties {
    private String name;

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

@SpringBootApplication
class SpringBootDemo {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootDemo.class, args);
        ApplicationContext context = SpringApplication.run(SpringBootDemo.class, args);
        AppProperties props = context.getBean(AppProperties.class);
        System.out.println("App Name: " + props.getName());
    }
}

application.properties:

app.name=MyApp

面试问题:

  • 问题: Spring Boot自动配置的原理是什么？
  • 答案: 通过@EnableAutoConfiguration加载spring.factories中的配置类，结合条件注解动态装配Bean。

4. Spring事务管理

Spring通过声明式事务简化事务处理。

  • 传播行为

    • REQUIRED（默认）：加入当前事务或创建新事务。
    • NESTED：嵌套事务，支持回滚。

  • 隔离级别

    • READ_COMMITTED：防止脏读。
    • REPEATABLE_READ：防止不可重复读。

示例: 声明式事务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Service;

@Service
class AccountService {
    @Transactional(rollbackOn = Exception.class)
    public void transfer(Account from, Account to, double amount) {
        from.decrease(amount);
        if (amount > 100) {
            throw new RuntimeException("Amount too large");
        }
        to.increase(amount);
    }
}

class Account {
    private double balance;
    public void decrease(double amount) { this.balance -= amount; }
    public void increase(double amount) { this.balance += amount; }
}

面试问题:

  • 问题: @Transactional失效的场景有哪些？
  • 答案: 非public方法、自我调用、异常未抛出或未被捕获、数据库不支持事务等。

5. Spring MVC请求处理流程

Spring MVC是Spring的Web框架，处理HTTP请求。

  • 核心组件

    • DispatcherServlet: 前端控制器，分发请求。
    • HandlerMapping: 映射请求到控制器。
    • Controller: 处理业务逻辑。

  • 请求流程

    1. 请求到达DispatcherServlet。
    2. HandlerMapping定位处理方法。
    3. 调用Controller，返回ModelAndView。
    4. 视图解析器渲染页面。

示例: 简单控制器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
class UserController {
    @GetMapping("/user/{id}")
    public String getUser(@PathVariable int id) {
        return "User ID: " + id;
    }
}

面试问题:

  • 问题: Spring MVC如何处理请求？
  • 答案: DispatcherServlet接收请求，HandlerMapping定位控制器，执行方法后由视图解析器渲染结果。

6. 学习与面试建议

  • 实践: 搭建Spring Boot项目，实验AOP和事务。
  • 深入: 阅读AbstractApplicationContext源码，理解IOC初始化。
  • 表达: 用流程图解释Spring MVC或事务传播。

结语

Spring框架是Java开发的利器，掌握IOC、AOP和Spring Boot，能让你在面试中自信应对复杂问题。下一专题将探讨数据库与持久化，敬请期待！

updatedupdated2025-04-172025-04-17

相关文章：