从HelloWorld到企业级项目Java Spring框架入门到精通完整学习路线带你避开Bean配置混乱循环依赖等常见坑

为什么学Spring？

先说说我一开始学Spring时的样子。2017年，我一个做Java Web的程序员，还在用SSM（Spring+Spring MVC+MyBatis）三板斧糊弄项目。每天面对的就是XML配置写到怀疑人生，Bean注入乱成一锅粥，循环依赖搞得debug一整天都找不到头绪。

说实话，Spring就像是一个超级大的工具箱。你一开始觉得它笨重，用着用着发现——咦，这个工具真好用，那个工具也真顺手。等你真正理解了Spring的核心思想之后，你会发现它不只是个框架，而是一种设计哲学。

这篇文章我会从零开始，带你一步步走通Spring的学习之路，中间踩过的坑我都帮你标好了，你不需要再踩一遍。

第一部分：Spring的基础认知

什么是Spring框架？

Spring框架是一个开源的Java平台，它的核心思想有两个：控制反转（IoC）和面向切面编程（AOP）。

让我用一个生活化的例子来解释。

假设你在经营一家餐厅。传统的做法是：每来一个客人，你都要亲自去厨房炒菜、上菜、结账。这就像传统的Java开发——每个类都自己管理依赖，代码耦合严重。

Spring的做法是：你只需要告诉餐厅”我需要一个炒菜的服务”，餐厅（Spring容器）会自动帮你找到合适的厨师，把菜端上来。这个”自动帮你找”的过程，就是IoC。

// 没有Spring的时候，你自己创建依赖
public class Restaurant {
    private Chef chef = new ChineseChef();  // 你自己new出来，耦合严重
    
    public void serve() {
        chef.cook("红烧肉");
    }
}

// 有了Spring之后，Spring帮你管理依赖
@Service
public class Restaurant {
    @Autowired  // Spring自动注入，你不需要管怎么创建
    private Chef chef;
    
    public void serve() {
        chef.cook("红烧肉");
    }
}

IoC容器到底是什么？

IoC（Inversion of Control）翻译成”控制反转”，听起来很高级，其实说白了就是：把对象的创建和管理权，从代码里交出来，交给Spring容器。

Spring容器就像一个超级管家，你告诉它你需要什么，它就帮你准备好。你不需要自己去new对象，不需要自己管理生命周期。

Spring有两个核心容器：

BeanFactory：最基础的容器，按需加载Bean
ApplicationContext：功能更强大的容器，启动时就加载所有Bean

// 使用BeanFactory，比较底层
BeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml"));
UserService userService = (UserService) factory.getBean("userService");

// 使用ApplicationContext，推荐的方式
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) context.getBean(UserService.class);

实际项目中几乎都用ApplicationContext，因为它提供了更多企业级功能，比如事件发布、国际化支持、AOP集成等。

第二部分：Bean的配置方式演进

第一阶段：XML配置（古老但有用）

最早期的Spring完全依赖XML配置文件来管理Bean。那时候的项目，一个applicationContext.xml动不动就几百行，光看配置就头疼。

<!-- beans.xml -->
<beans>
    <!-- 定义一个Bean -->
    <bean id="userDao" class="com.example.dao.UserDaoImpl"/>
    
    <!-- 定义Service，注入Dao -->
    <bean id="userService" class="com.example.service.UserService">
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

XML配置的问题很明显：

配置量大，难以维护
没有编译时检查，写错了也不知道
重构困难，改个类名可能整个项目都跑不起来

第二阶段：注解配置（现在的主流）

Spring 2.5引入了注解，极大地简化了配置。你只需要加上几个注解，Spring就能自动识别和管理Bean。

// 用注解代替XML配置
@Component  // 告诉Spring这是一个Bean
public class UserDaoImpl implements UserDao {
    // ...
}

@Service  // 表示这是一个Service层的Bean
public class UserService {
    @Autowired  // 自动注入依赖
    private UserDao userDao;
    
    public void addUser(String name) {
        userDao.insert(name);
    }
}

常用的注解有：

@Component：通用Bean注解
@Service：Service层Bean
@Repository：DAO层Bean（带异常转换）
@Controller：Controller层Bean
@Autowired：自动注入
@Resource：JDK标准注入注解
@Configuration：配置类
@Bean：方法级别的Bean定义

第三阶段：Java Config配置（现代推荐）

Spring 3.0引入了基于Java的配置，让配置代码和Java代码融为一体，类型安全，支持重构。

@Configuration  // 标记这是一个配置类
public class AppConfig {
    
    @Bean  // 定义一个Bean
    public UserDao userDao() {
        return new UserDaoImpl();
    }
    
    @Bean
    public UserService userService() {
        UserService service = new UserService();
        service.setUserDao(userDao());  // 可以直接调用其他Bean
        return service;
    }
}

Java Config的优势：

类型安全，IDE可以检查错误
支持条件化配置（@Conditional）
可以写复杂逻辑
重构友好

实际项目中的混合使用

真实的Spring项目通常是三种方式混合使用的：

@Configuration
@ComponentScan(basePackages = "com.example")  // 扫描注解
@PropertySource("classpath:jdbc.properties")   // 加载属性文件
public class RootConfig {
    
    @Bean
    public DataSource dataSource() {
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl(env.getProperty("jdbc.url"));
        ds.setUsername(env.getProperty("jdbc.username"));
        ds.setPassword(env.getProperty("jdbc.password"));
        return ds;
    }
    
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource ds) throws Exception {
        SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
        factory.setDataSource(ds);
        return factory.getObject();
    }
}

第三部分：依赖注入的常见坑

坑一：循环依赖

这是Spring开发中最经典的问题。简单来说，就是A依赖B，B又依赖A，形成了一个死循环。

// 有循环依赖的代码
@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;  // A依赖B
}

@Service
public class ServiceB {
    @Autowired
    private ServiceA serviceA;  // B依赖A，循环了！
}

Spring默认情况下不支持循环依赖，启动时会抛出BeanCurrentlyInCreationException。

为什么Spring不支持循环依赖？

想象一下这个场景：你要创建ServiceA，Spring发现它需要ServiceB，于是去创建ServiceB；创建ServiceB时发现它需要ServiceA，又回去创建ServiceA；创建ServiceA又需要ServiceB……这就是死循环。

Spring的Bean创建过程有三个阶段：

实例化（Instantiation）：用构造函数创建对象，此时属性还是空的
属性填充（Population）：注入依赖的属性
初始化（Initialization）：执行@PostConstruct等方法

Spring解决循环依赖的前提是：Bean必须是单例（singleton）且是属性注入（setter或字段注入），不是构造器注入。

解决方案一：使用`@Lazy`延迟注入

@Service
public class ServiceA {
    @Autowired
    @Lazy  // 延迟加载，先创建一个代理对象
    private ServiceB serviceB;
}

@Lazy会让Spring在第一次使用时才去创建依赖的对象，这样就打破了循环。

解决方案二：提取公共接口

// 提取一个接口
public interface CommonService {
    void doSomething();
}

@Service
public class ServiceA implements CommonService {
    @Autowired
    private ServiceB serviceB;
}

@Service
public class ServiceB implements CommonService {
    @Autowired
    private ServiceA serviceA;
}

解决方案三：使用Setter注入代替构造器注入

@Service
public class ServiceA {
    private ServiceB serviceB;
    
    // 用Setter注入，Spring可以在实例化后注入
    @Autowired
    public void setServiceB(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
}

最佳实践：循环依赖本质上说明你的设计有问题。最好的做法是重构代码，提取公共依赖，打破循环。

坑二：Bean的Scope搞混

Spring Bean有几种作用域：

Scope	说明
`singleton`	单例，默认值，整个容器只有一个实例
`prototype`	每次获取都创建新实例
`request`	每次HTTP请求创建一个实例（Web环境）
`session`	每个HTTP Session创建一个实例
`application`	每个ServletContext一个实例

@Scope("prototype")  // 明确指定作用域
@Service
public class UserService {
    // ...
}

常见错误：把一个有状态的Bean声明为单例，导致多线程并发问题。

// 错误示范：有状态的Bean用单例
@Singleton  // 默认就是单例
@Component
public class OrderService {
    private int orderCount = 0;  // 状态数据！单例下多线程共享会出问题
    
    public void createOrder() {
        orderCount++;
        // ...
    }
}

// 正确做法：有状态的Bean用prototype
@Scope("prototype")
@Component
public class OrderService {
    private int orderCount = 0;
    
    public void createOrder() {
        orderCount++;
    }
}

坑三：@Autowired和@Resource混用

@Autowired是Spring的注解，@Resource是JDK的注解。两者都能实现注入，但行为有差异：

// @Autowired按类型注入
@Autowired
private UserDao userDao;

// @Resource默认按名称注入，找不到再按类型
@Resource(name = "userDao")
private UserDao userDao;

@Autowired：必须找到匹配的类型，找不到就报错；可以用required=false让它可选
@Resource：先按名称匹配，找不到再按类型匹配

// @Autowired可选注入
@Autowired(required = false)
private UserDao userDao;  // 找不到时注入null，不会报错

坑四：字段注入 vs 构造器注入

这是Spring社区争论很久的话题。

// 字段注入（常见但有问题）
@Service
public class UserService {
    @Autowired
    private UserDao userDao;  // 无法保证不可变，无法单元测试
}

// 构造器注入（推荐）
@Service
public class UserService {
    private final UserDao userDao;
    
    // 构造器注入，保证依赖不可变
    @Autowired
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
}

构造器注入的好处：

依赖不可变，更安全
可以强制要求依赖存在（构造器没有required=false）
更容易进行单元测试
能检测循环依赖（构造器注入的循环依赖会直接报错）

第四部分：Spring的核心机制

Bean的生命周期

理解Bean的生命周期是避免各种坑的关键。

1. 实例化（Instantiation）
   └── 调用构造函数创建对象

2. 属性填充（Populate）
   └── 注入依赖（@Autowired等）

3. 初始化（Initialization）
   ├── 执行Aware接口方法（BeanNameAware、BeanFactoryAware等）
   ├── 执行BeanPostProcessor前置处理（postProcessBeforeInitialization）
   ├── 执行@PostConstruct标注的方法
   ├── 执行InitializingBean接口的afterPropertiesSet方法
   └── 执行自定义init-method

4. Bean可用

5. 销毁（Destruction）
   ├── 执行DisposableBean接口的destroy方法
   ├── 执行自定义destroy-method
   └── 执行@PreDestroy标注的方法

@Component
public class MyBean implements InitializingBean {
    
    @PostConstruct
    public void init() {
        System.out.println("初始化方法1");
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("初始化方法2");
    }
    
    @PreDestroy
    public void destroy() {
        System.out.println("销毁方法");
    }
}

实际开发中，@PostConstruct是最常用的初始化方式，简单直观。

BeanPostProcessor：Spring的扩展点

BeanPostProcessor是Spring中最强大的扩展点之一。它可以在Bean初始化前后进行拦截和处理。

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // Bean初始化前的处理
        if (beanName.startsWith("user")) {
            System.out.println("用户Bean初始化前处理: " + beanName);
        }
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // Bean初始化后的处理
        // 比如创建代理对象（AOP就是在这里做的）
        return bean;
    }
}

Spring的AOP、@PostConstruct、@PreDestroy等功能都是基于BeanPostProcessor实现的。理解了它，你就理解了Spring的很多核心机制。

Spring的事件机制

Spring提供了ApplicationEvent和ApplicationListener事件机制，实现了组件之间的解耦。

// 定义事件
public class UserRegisteredEvent extends ApplicationEvent {
    private final String username;
    
    public UserRegisteredEvent(Object source, String username) {
        super(source);
        this.username = username;
    }
    
    public String getUsername() {
        return username;
    }
}

// 发布事件
@Service
public class UserService {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    public void register(String username) {
        // ... 注册逻辑
        publisher.publishEvent(new UserRegisteredEvent(this, username));
    }
}

// 监听事件
@Component
public class EmailListener {
    @EventListener
    public void onUserRegistered(UserRegisteredEvent event) {
        sendWelcomeEmail(event.getUsername());
    }
}

事件机制适合处理一些解耦的业务场景，比如注册成功后发送欢迎邮件、记录日志等。

第五部分：Spring MVC入门

Spring MVC的工作流程

用户请求 → DispatcherServlet（前端控制器）
         → HandlerMapping（查找处理器）
         → Controller（处理请求）
         → ModelAndView（返回模型和视图）
         → ViewResolver（解析视图）
         → 渲染视图 → 响应给用户

最简单的Controller

@RestController  // 等于@Controller + @ResponseBody
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
    
    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userService.create(user);
    }
    
    @GetMapping("/health")
    public String health() {
        return "OK";
    }
}

RESTful API的最佳实践

@RestController
@RequestMapping("/api/users")  // 统一前缀
public class UserController {
    
    @Autowired
    private UserService userService;
    
    // 查询所有用户
    @GetMapping
    public List<User> list(
        @RequestParam(defaultValue = "0") int page,
        @RequestParam(defaultValue = "10") int size
    ) {
        return userService.list(page, size);
    }
    
    // 查询单个用户
    @GetMapping("/{id}")
    public ResponseEntity<User> get(@PathVariable Long id) {
        return userService.findById(id)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }
    
    // 创建用户
    @PostMapping
    public ResponseEntity<User> create(@Valid @RequestBody CreateUserRequest request) {
        User user = userService.create(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
    
    // 更新用户
    @PutMapping("/{id}")
    public ResponseEntity<User> update(
        @PathVariable Long id,
        @Valid @RequestBody UpdateUserRequest request
    ) {
        return ResponseEntity.ok(userService.update(id, request));
    }
    
    // 删除用户
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> delete(@PathVariable Long id) {
        userService.delete(id);
        return ResponseEntity.noContent().build();
    }
}

统一异常处理

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(UserNotFoundException.class)
    public ApiResponse handleUserNotFound(UserNotFoundException e) {
        return ApiResponse.error(404, e.getMessage());
    }
    
    @ExceptionHandler(IllegalArgumentException.class)
    public ApiResponse handleIllegalArgument(IllegalArgumentException e) {
        return ApiResponse.error(400, e.getMessage());
    }
    
    @ExceptionHandler(Exception.class)
    public ApiResponse handleUnknownException(Exception e) {
        return ApiResponse.error(500, "服务器内部错误");
    }
}

第六部分：Spring与事务管理

声明式事务

Spring的事务管理是最大的卖点之一。你只需要加一个注解，Spring就会自动帮你管理事务。

@Service
public class OrderService {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private InventoryService inventoryService;
    
    @Transactional  // 开启事务
    public Order createOrder(Long userId, List<OrderItem> items) {
        // 创建订单
        Order order = new Order();
        order.setUserId(userId);
        order.setTotalAmount(calculateTotal(items));
        orderRepository.save(order);
        
        // 扣减库存（如果这里失败，整个事务回滚）
        for (OrderItem item : items) {
            inventoryService.deductStock(item.getProductId(), item.getQuantity());
        }
        
        return order;
    }
}

事务的传播行为

@Transactional有一个很重要的属性propagation，控制事务的传播行为：

传播行为	说明
`REQUIRED`	默认值，有事务就加入，没有就新建
`REQUIRES_NEW`	总是新建事务，挂起当前事务
`SUPPORTS`	有事务就加入，没有就以非事务方式执行
`NOT_SUPPORTED`	以非事务方式执行，挂起当前事务
`MANDATORY`	必须在事务中执行，否则报错
`NEVER`	不能在事务中执行，否则报错
`NESTED`	嵌套事务，有事务就创建保存点

@Service
public class PaymentService {
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processPayment(Order order) {
        // 这个方法会开启新事务
        // 即使外层事务回滚，这个事务也会提交
        paymentGateway.charge(order.getAmount());
    }
}

事务失效的常见原因

方法不是public的

@Transactional  // 无效！方法不是public
private void updateOrder() { }

@Transactional  // 有效
public void updateOrder() { }

同类方法调用

@Service
public class OrderService {
    
    public void methodA() {
        methodB();  // 直接调用，事务不生效！
    }
    
    @Transactional
    public void methodB() {
        // 事务逻辑
    }
}

解决方法：注入自身或使用AopContext.currentProxy()。

异常被捕获但没有抛出

@Transactional
public void updateOrder() {
    try {
        // 可能出错的代码
    } catch (Exception e) {
        // 吞掉了异常，事务不会回滚！
    }
}

// 正确做法
@Transactional
public void updateOrder() {
    try {
        // 可能出错的代码
    } catch (Exception e) {
        throw new RuntimeException(e);  // 重新抛出，让事务回滚
    }
}

第七部分：Spring Boot：Spring的现代化封装

为什么需要Spring Boot？

传统的Spring项目配置非常繁琐：

需要配置大量的XML
需要手动管理依赖版本
需要部署到外部Tomcat

Spring Boot解决了这些问题：

自动配置：根据你的依赖自动配置Spring
起步依赖：用starter一站式解决依赖
内嵌容器：自带Tomcat/Undertow，直接运行

第一个Spring Boot应用

@SpringBootApplication  // 组合注解：@SpringBootConfiguration + @EnableAutoConfiguration + @ComponentScan
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@RestController
public class HelloController {
    
    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}

Maven依赖

<dependencies>
    <!-- Web开发 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- 数据访问 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <!-- 测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

配置文件

# application.yml
server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true

logging:
  level:
    com.example: DEBUG
    org.springframework: INFO

第八部分：企业级项目的最佳实践

分层架构

┌─────────────────────────────────────┐
│           Controller Layer          │  接收请求，参数校验，调用Service
├─────────────────────────────────────┤
│           Service Layer             │  业务逻辑，事务管理
├─────────────────────────────────────┤
│         Repository Layer            │  数据访问，ORM映射
├─────────────────────────────────────┤
│           Database                  │  MySQL / PostgreSQL
└─────────────────────────────────────┘

// Controller层：薄，只做请求处理
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @PostMapping
    public ResponseEntity<UserDTO> create(@Valid @RequestBody CreateUserRequest request) {
        return ResponseEntity.ok(userService.create(request));
    }
}

// Service层：核心业务逻辑
@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private EventPublisher eventPublisher;
    
    @Transactional
    public UserDTO create(CreateUserRequest request) {
        User user = new User(request.getName(), request.getEmail());
        userRepository.save(user);
        eventPublisher.publish(new UserCreatedEvent(user.getId()));
        return UserDTO.from(user);
    }
}

// Repository层：数据访问
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    boolean existsByEmail(String email);
}

依赖注入的最佳实践

优先使用构造器注入
依赖声明为final
接口作为依赖类型，而不是实现类

// 正确做法
@Service
public class OrderService {
    
    private final OrderRepository orderRepository;
    private final InventoryClient inventoryClient;
    
    @Autowired
    public OrderService(OrderRepository orderRepository, InventoryClient inventoryClient) {
        this.orderRepository = orderRepository;
        this.inventoryClient = inventoryClient;
    }
}

避免Spring Bean配置混乱的几条规则

统一使用Java Config，少用XML
使用@ComponentScan统一管理扫描范围
用@Profile区分不同环境的配置
Bean的命名要有语义，避免通用名称
复杂Bean用@Bean方法定义，简单Bean用注解

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    
    @Bean
    @Profile("prod")  // 只在生产环境生效
    public DataSource prodDataSource() {
        // 生产环境数据源配置
    }
    
    @Bean
    @Profile("dev")  // 只在开发环境生效
    public DataSource devDataSource() {
        // 开发环境数据源配置
    }
}

第九部分：Spring Cloud微服务入门

微服务是什么？

单体应用把整个系统打包成一个部署单元，随着业务增长会变得难以维护。微服务就是把系统拆成多个小服务，每个服务独立部署、独立扩展。

Spring Cloud的核心组件

<!-- Spring Cloud BOM -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2022.0.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

组件	作用
Spring Cloud Gateway	API网关，统一入口
Spring Cloud OpenFeign	声明式HTTP客户端
Spring Cloud CircuitBreaker	熔断器，防止雪崩
Spring Cloud Config	配置中心
Spring Cloud Consul/Eureka	服务注册发现

一个简单的微服务调用

// 服务A：用户服务
@RestController
public class UserController {
    
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
}

// 服务B：订单服务，调用用户服务
@Service
public class OrderService {
    
    @Autowired
    private UserClient userClient;  // Feign客户端
    
    public OrderDTO createOrder(Long userId) {
        User user = userClient.getUser(userId);  // 远程调用
        // ...
    }
}

// Feign客户端
@FeignClient(name = "user-service")
public interface UserClient {
    
    @GetMapping("/users/{id}")
    User getUser(@PathVariable Long id);
}

第十部分：学习路线图

第一阶段：基础（1-2周）

Java基础扎实（集合、泛型、反射、注解）
Maven/Gradle构建工具
HTTP协议基础
一个简单的Spring HelloWorld

第二阶段：Spring核心（2-4周）

IoC容器和Bean管理
依赖注入的多种方式
AOP面向切面编程
事务管理
做一个完整的CRUD项目

第三阶段：Spring Boot（2-3周）

自动配置原理
起步依赖
外部化配置
Actuator监控
做一个REST API项目

第四阶段：Spring MVC（1-2周）

请求映射
参数绑定
拦截器
异常处理
文件上传

第五阶段：数据访问（2-3周）

Spring Data JPA
MyBatis集成
缓存（Spring Cache）
分页和排序

第六阶段：进阶（持续学习）

Spring Security安全框架
Spring Batch批处理
Spring Cloud微服务
源码阅读

最后的话

学Spring不是一蹴而就的事情。我见过太多人一开始就啃源码，结果被复杂的配置和概念吓退了。我的建议是：先会用，再理解，最后研究源码。

从一个简单的HelloWorld开始，逐步添加功能，踩几个坑，解决几个问题，你会发现Spring其实没那么难。当你真正理解了IoC和AOP这两个核心思想之后，其他的都是锦上添花。

记住，最好的学习方式就是动手写代码。理论看得再多，不如亲手搭一个项目来得实在。

祝你学习顺利！如果在路上遇到什么问题，随时回来翻这篇文章，它应该能帮你找到方向。