正文

Java程序员从Spring零基础上手到企业级项目开发完整学习路线与实战经验

/0 浏览量
1004

Java程序员从Spring零基础上手到企业级项目开发完整学习路线与实战经验

写给还在纠结”Spring到底该怎么学”的你

说实话，我刚入行的时候也对Spring感到迷茫——框架文档看得头疼，Spring、Spring MVC、Spring Boot、Spring Cloud这些名字混在一起，根本分不清谁是谁。后来踩了不少坑，才慢慢摸清楚学习路径。今天就把我这些年积累的经验和总结出来的路线，毫无保留地分享给你。如果你正好卡在某个阶段，这篇文章应该能帮你找到方向。

一、先搞清楚Spring家族的那些”亲戚”

很多人一开始就被Spring的生态吓到了。别慌，我们把它拆开来理解：

Spring Framework——一切的起点

Spring Framework是最基础的部分，你可以把它理解为”工具库的大杂烩”。它提供了IoC（控制反转）和AOP（面向切面编程）两个核心思想。

IoC是什么？ 用最直白的话说，就是你不用自己new对象了，把对象的创建和依赖管理交给Spring容器。举个例子：

// 没有Spring的时候，你是这样写代码的：
public class UserService {
    private UserDao userDao = new UserDao();  // 你自己new出来的
    // 一旦UserDao的实现变了，你得改整个类
}

// 有了Spring的IoC，你变成这样：
@Component
public class UserService {
    @Autowired
    private UserDao userDao;  // Spring帮你注入，你不用管它从哪来
}

这样改的好处是：未来你想换个UserDao的实现，只需要改配置文件或注解，不用动业务代码。这就是”依赖注入”的核心价值——降低耦合。

AOP又是什么？ 想象一下你要给多个方法加日志、加事务、加权限校验，总不能每个方法都写一遍吧？AOP就是让你把这类”横向”的逻辑抽出来，统一配置。比如事务管理：

@Transactional  // 加上这个注解，Spring自动帮你管理事务
public void transferMoney(String from, String to, BigDecimal amount) {
    accountDao.decrease(from, amount);
    accountDao.increase(to, amount);
    // 如果中间出错，Spring自动回滚，不用你手动写try-catch
}

Spring Framework的学习不需要死记硬背所有API，重点是把IoC和AOP两个思想吃透，后续所有的框架都是在这两个基础上长出来的。

Spring MVC——处理Web请求的”管家”

如果说Spring Framework是底层的基础设施，那Spring MVC就是专门用来处理Web请求的框架。它的核心职责是：收到HTTP请求 → 路由到对应Controller → 调用Service → 返回结果。

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
}

这段代码展示了Spring MVC最典型的结构。@RestController告诉Spring这个类处理HTTP请求，@RequestMapping指定了基础路径，@GetMapping和@PostMapping区分了请求方法。

你不需要一次性记住所有注解，先把”请求进来 → 路由 → 处理 → 返回”这个流程跑通，后面遇到具体的细节再去查文档，效率高得多。

Spring Boot——让一切变简单的”加速器”

这才是大多数企业项目实际使用的框架。Spring Boot的本质是一个”约定优于配置”的工具——它帮你自动配置了大量原本需要手写XML的繁琐工作。

没有Spring Boot的时代：

<!-- 传统的Spring项目，你需要自己配一大堆东西 -->
<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</bean>

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!-- 还有 DispatcherServlet、HandlerMapping、ViewResolver 等等... -->

有了Spring Boot之后：

# 只需要一个application.yml就够
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

// 启动类加个@SpringBootApplication就够了
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

就这几行，Spring Boot自动帮你配好了数据源、事务管理器、HTTP服务器（内嵌Tomcat）、日志框架等等。你不用关心底层怎么实现的，只需要专注写业务代码。

为什么企业项目几乎都用Spring Boot？ 因为它省去了90%的配置工作，让你能快速启动项目、快速迭代。面试时也基本只问Spring Boot相关的，不考你手写XML配置。

Spring Cloud——微服务的”瑞士军刀”

当你单靠一个服务撑不住高并发，或者需要拆分成多个独立部署的服务时，Spring Cloud就派上用场了。它提供了一整套微服务解决方案：

  • 服务注册与发现（Eureka/Nacos）：服务之间怎么找到对方
  • 负载均衡（Ribbon/LoadBalancer）：请求怎么均匀分发到多个实例
  • 熔断降级（Hystrix/Sentinel）：某个服务挂了，怎么不影响整个系统
  • 网关（Spring Cloud Gateway）：所有请求的统一入口，做鉴权、限流
  • 配置中心（Nacos/Apollo）：配置统一管理，不用每次改配置都重启服务

这部分不需要一开始就精通，等你真正面临微服务架构的问题时，再针对性地学习会事半功倍。

二、循序渐进的学习路线（附具体步骤和时间建议）

下面我按照从零基础到能独立做企业项目的路径，给你规划一下。不用太死板，根据自己的节奏调整。

阶段一：Java基础打牢（预计2-4周）

Spring是Java生态的框架，Java基础不牢，学Spring会很痛苦。重点检查这些：

// 1. 面向对象——理解类、对象、继承、多态
public abstract class Animal {
    private String name;
    public abstract void speak();  // 抽象方法，子类必须实现
}

public class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("汪汪！");
    }
}

// 2. 集合框架——List、Map、Set的区别和使用场景
List<String> names = new ArrayList<>();      // 有序、可重复
Set<String> uniqueNames = new HashSet<>();   // 无序、去重
Map<String, Integer> ageMap = new HashMap<>(); // 键值对

// 3. 异常处理——了解Checked Exception和Unchecked Exception
public void riskyOperation() throws IOException {
    try {
        // 可能抛出异常的操作
    } catch (IOException e) {
        // 处理异常
    } finally {
        // 无论是否异常都执行
    }
}

// 4. 泛型——理解<T>是什么意思
public class Box<T> {
    private T content;
    public void set(T content) { this.content = content; }
    public T get() { return content; }
}

// 5. 接口与Lambda——Spring很多注解和函数式编程都基于此
interface UserService {
    User findById(Long id);
    void save(User user);
}

// Lambda简化写法
List<String> list = Arrays.asList("Alice", "Bob", "Charlie");
list.stream()
    .filter(name -> name.length() > 3)  // Lambda表达式
    .forEach(name -> System.out.println(name));

Java基础不是要背语法，而是能熟练写出常用的代码。建议每天至少写100行Java代码，从控制台程序开始练手。

阶段二：Maven/Gradle构建工具（预计3-5天）

企业项目都是用Maven或Gradle管理依赖的，你需要掌握：

Maven的核心概念——pom.xml：

<project>
    <!-- 项目坐标，相当于身份证号 -->
    <groupId>com.example</groupId>
    <artifactId>my-project</artifactId>
    <version>1.0.0</version>
    
    <!-- 依赖管理 -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
    </dependencies>
    
    <!-- 插件 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

重点理解：坐标（groupId+artifactId+version）、依赖scope（compile/test/provided）、Maven仓库（本地/中央/私有）。不需要一次记住所有命令，mvn clean package、mvn install、mvn dependency:tree这些常用命令会用就行。

阶段三：Spring Boot核心入门（预计1-2周）

这是最重要的阶段。建议按以下顺序学习：

1. 第一个Spring Boot项目

从官网start.spring.io新建项目，选Web依赖，直接能跑起来：

@SpringBootApplication
public class HelloApplication {
    public static void main(String[] args) {
        SpringApplication.run(HelloApplication.class, args);
    }
}

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

点击运行，访问http://localhost:8080/hello，看到输出就说明环境没问题。

2. 核心注解逐个理解

// @Component/@Service/@Controller/@Repository——标记Spring管理的Bean
@Service
public class OrderService {
    // Spring会扫描到这个类，并自动创建它的实例
}

// @Autowired——依赖注入
@Service
public class PaymentService {
    @Autowired
    private OrderService orderService;  // Spring自动把OrderService的实例塞进来
}

// @Configuration——配置类，替代XML配置
@Configuration
public class AppConfig {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

// @Value——注入配置值
@Component
public class MailSender {
    @Value("${mail.smtp.host}")
    private String smtpHost;
    
    @Value("${mail.smtp.port:587}")  // 冒号后面是默认值
    private String smtpPort;
}

// @ConditionalOn——条件装配，根据条件决定是否创建Bean
@Bean
@ConditionalOnProperty(name = "feature.pay.enabled", havingValue = "true")
public PaymentService paymentService() {
    return new PaymentService();
}

不用死记这些注解，边写边用，遇到不懂的查文档，比死记硬背效率高多了。

3. 配置文件application.yml/properties

# application.yml示例
server:
  port: 8080
  
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/shop_db
    username: root
    password: ${DB_PASSWORD}  # 从环境变量读取，安全
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update  # 开发环境自动建表，生产环境改成none
    show-sql: true       # 打印SQL，方便调试
  messages:
    basename: i18n.messages  # 国际化配置

# 自定义配置
app:
  version: 1.0.0
  description: 商城系统

这里注意一个重要的实战经验：敏感信息（数据库密码、API Key）永远不要硬编码在配置文件里，用环境变量或密钥管理服务。

阶段四：数据访问层（预计1-2周）

Spring Boot提供了多种方式访问数据库，重点掌握这两种：

方式一：Spring Data JPA（推荐入门）

// 实体类——对应数据库表
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, length = 50)
    private String username;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    @Column(name = "created_at")
    private LocalDateTime createdAt;
}

//  Repository——不需要写任何实现，Spring自动帮你生成
public interface UserRepository extends JpaRepository<User, Long> {
    // 方法名自动映射SQL，Spring Data的神奇之处
    Optional<User> findByEmail(String email);
    List<User> findByUsernameContaining(String keyword);
    boolean existsByEmail(String email);
    
    // 复杂查询用@Query注解
    @Query("SELECT u FROM User u WHERE u.createdAt > :date")
    List<User> findUsersCreatedAfter(@Param("date") LocalDateTime date);
}

// Service层
@Service
@Transactional  // 事务管理，方法内所有数据库操作要么全部成功要么全部回滚
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public User createUser(String username, String email) {
        // 业务校验
        if (userRepository.existsByEmail(email)) {
            throw new BusinessException("邮箱已被注册");
        }
        
        User user = new User();
        user.setUsername(username);
        user.setEmail(email);
        user.setCreatedAt(LocalDateTime.now());
        
        return userRepository.save(user);
    }
    
    public User getUserById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new BusinessException("用户不存在"));
    }
}

方式二：MyBatis / MyBatis-Plus（国内企业项目更常用）

<!-- MyBatis Mapper XML -->
<mapper namespace="com.example.mapper.UserMapper">
    
    <resultMap id="userMap" type="com.example.entity.User">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="email" property="email"/>
    </resultMap>
    
    <select id="findByEmail" resultMap="userMap">
        SELECT * FROM users WHERE email = #{email}
    </select>
    
    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO users (username, email, created_at)
        VALUES (#{username}, #{email}, #{createdAt})
    </insert>
    
</mapper>

// Mapper接口
public interface UserMapper extends BaseMapper<User> {  // MyBatis-Plus提供的基础方法
    List<User> findByEmail(@Param("email") String email);
}

// 使用
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
    
    public User findByEmail(String email) {
        return userMapper.selectOne(
            new LambdaQueryWrapper<User>()
                .eq(User::getEmail, email)
        );
    }
}

MyBatis-Plus的优势在于它继承了MyBatis的灵活性，又提供了类似JPA的简洁API，国内大量项目用这个组合。

阶段五：RESTful API设计与实现（预计3-5天）

企业项目的核心是对外提供接口。一个规范的RESTful API应该这样设计：

@RestController
@RequestMapping("/api/v1/orders")
@Validated
public class OrderController {

    @Autowired
    private OrderService orderService;

    // GET /api/v1/orders/{id} —— 查询单个订单
    @GetMapping("/{id}")
    public ApiResponse<OrderVO> getOrder(@PathVariable Long id) {
        Order order = orderService.findById(id);
        return ApiResponse.success(OrderVO.from(order));
    }

    // GET /api/v1/orders —— 分页查询订单列表
    @GetMapping
    public ApiResponse<PageResult<OrderVO>> listOrders(
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(defaultValue = "20") int size,
            @RequestParam(required = false) String status) {
        
        PageResult<OrderVO> result = orderService.pageQuery(page, size, status);
        return ApiResponse.success(result);
    }

    // POST /api/v1/orders —— 创建订单
    @PostMapping
    public ApiResponse<OrderVO> createOrder(
            @Valid @RequestBody CreateOrderRequest request) {
        
        Order order = orderService.create(request);
        return ApiResponse.success(OrderVO.from(order));
    }

    // PUT /api/v1/orders/{id} —— 更新订单
    @PutMapping("/{id}")
    public ApiResponse<OrderVO> updateOrder(
            @PathVariable Long id,
            @Valid @RequestBody UpdateOrderRequest request) {
        
        Order order = orderService.update(id, request);
        return ApiResponse.success(OrderVO.from(order));
    }

    // DELETE /api/v1/orders/{id} —— 删除订单
    @DeleteMapping("/{id}")
    public ApiResponse<Void> deleteOrder(@PathVariable Long id) {
        orderService.delete(id);
        return ApiResponse.success(null);
    }
}

统一响应格式：

public class ApiResponse<T> {
    private int code;      // 业务状态码
    private String message; // 提示信息
    private T data;        // 返回数据
    
    public static <T> ApiResponse<T> success(T data) {
        ApiResponse<T> response = new ApiResponse<>();
        response.code = 200;
        response.message = "success";
        response.data = data;
        return response;
    }
    
    public static <T> ApiResponse<T> error(int code, String message) {
        ApiResponse<T> response = new ApiResponse<>();
        response.code = code;
        response.message = message;
        return response;
    }
}

统一响应格式让前后端联调更高效，避免每个接口返回结构不一样。

阶段六：参数校验与安全（预计3-5天）

参数校验——用注解代替手动if判断：

// 请求DTO
public class CreateUserRequest {
    @NotBlank(message = "用户名不能为空")
    @Size(min = 2, max = 20, message = "用户名长度2-20位")
    private String username;
    
    @Email(message = "邮箱格式不正确")
    @NotBlank(message = "邮箱不能为空")
    private String email;
    
    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
    @NotBlank(message = "手机号不能为空")
    private String phone;
    
    @Size(min = 6, max = 20, message = "密码长度6-20位")
    @NotBlank(message = "密码不能为空")
    private String password;
}

// Controller中使用@Valid触发校验
@PostMapping
public ApiResponse<UserVO> createUser(@Valid @RequestBody CreateUserRequest request) {
    // 如果校验失败，Spring会自动抛MethodArgumentNotValidException
    User user = userService.create(request);
    return ApiResponse.success(UserVO.from(user));
}

全局异常处理：

@RestControllerAdvice
public class GlobalExceptionHandler {

    // 参数校验失败
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ApiResponse<Void> handleValidationException(MethodArgumentNotValidException e) {
        String message = e.getBindingResult().getFieldError().getDefaultMessage();
        return ApiResponse.error(400, message);
    }
    
    // 业务异常
    @ExceptionHandler(BusinessException.class)
    public ApiResponse<Void> handleBusinessException(BusinessException e) {
        return ApiResponse.error(e.getCode(), e.getMessage());
    }
    
    // 未知异常
    @ExceptionHandler(Exception.class)
    public ApiResponse<Void> handleException(Exception e) {
        log.error("系统异常", e);
        return ApiResponse.error(500, "系统繁忙，请稍后重试");
    }
}

阶段七：事务管理与性能优化（预计1周）

事务的正确用法——嵌套事务和传播行为：

@Service
public class OrderService {
    
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private InventoryService inventoryService;
    @Autowired
    private NotificationService notificationService;

    // REQUIRED：默认传播行为，加入当前事务
    @Transactional(rollbackFor = Exception.class)
    public Long createOrder(CreateOrderRequest request) {
        // 1. 扣库存
        inventoryService.deductStock(request.getProductId(), request.getQuantity());
        
        // 2. 创建订单
        Order order = buildOrder(request);
        orderMapper.insert(order);
        
        // 3. 发送通知（这一步建议异步，不影响主事务）
        notificationService.sendOrderCreatedNotification(order);
        
        return order.getId();
    }
}

// 库存服务——嵌套事务，独立提交
@Service
public class InventoryService {
    
    @Autowired
    private InventoryMapper inventoryMapper;

    // REQUIRES_NEW：挂起当前事务，开启新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    public void deductStock(Long productId, int quantity) {
        Inventory inventory = inventoryMapper.selectById(productId);
        if (inventory.getStock() < quantity) {
            throw new BusinessException("库存不足");
        }
        inventory.setStock(inventory.getStock() - quantity);
        inventoryMapper.update(inventory);
        // 这个事务独立提交，即使外层事务回滚，库存也不会回滚（视业务需求而定）
    }
}

常见性能优化点：

// 1. 避免N+1查询问题——使用JOIN查询
@Select("SELECT o.*, u.username FROM orders o JOIN users u ON o.user_id = u.id WHERE o.id = #{id}")
OrderWithUserVO findByIdWithUser(Long id);

// 2. 批量操作代替循环单条插入
@Insert("<script>" +
    "INSERT INTO orders (user_id, product_id, quantity, total_price, created_at) " +
    "VALUES " +
    "<foreach collection='orders' item='o' separator=','>" +
    "(#{o.userId}, #{o.productId}, #{o.quantity}, #{o.totalPrice}, NOW())" +
    "</foreach>" +
    "</script>")
int batchInsert(@Param("orders") List<Order> orders);

// 3. 缓存热点数据
@Cacheable(value = "orders", key = "#id")
public Order findById(Long id) {
    return orderMapper.selectById(id);
}

阶段八：单元测试与CI/CD（预计3-5天）

JUnit 5 + Mockito写测试：

@SpringBootTest
class OrderServiceTest {

    @Autowired
    private OrderService orderService;
    
    @Autowired
    private OrderMapper orderMapper;
    
    @MockBean
    private InventoryService inventoryService;

    @Test
    void createOrder_shouldThrowWhenStockInsufficient() {
        when(inventoryService.deductStock(anyLong(), anyInt()))
            .thenThrow(new BusinessException("库存不足"));
        
        assertThrows(BusinessException.class, () -> {
            orderService.createOrder(buildRequest());
        });
    }
    
    @Test
    @Transactional  // 测试后自动回滚，不影响数据库
    void createOrder_shouldSaveOrderAndDeductStock() {
        Long orderId = orderService.createOrder(buildRequest());
        
        Order order = orderMapper.selectById(orderId);
        assertThat(order).isNotNull();
        assertThat(order.getUserId()).isEqualTo(1L);
        verify(inventoryService).deductStock(100L, 2);
    }
}

三、真实项目实战：从0到1搭建一个商城系统

学完理论，最好找个项目练手。下面我以商城系统为例，讲讲企业级项目的完整结构和开发思路。

项目整体架构

shop-system/
├── shop-common/          # 公共模块：工具类、异常、统一响应
├── shop-api/             # API接口层：Controller
├── shop-service/         # 业务逻辑层：Service + Mapper
├── shop-infrastructure/  # 基础设施：数据库、缓存、消息队列
├── shop-configuration/   # 配置中心：各环境配置
└── shop-gateway/         # 网关层（微服务架构时才有）

分层架构的核心思想是各司其职，每一层只关注自己的职责，通过接口通信。这样的好处是：改底层实现不影响上层，换数据库不用改业务逻辑。

核心业务模块设计

用户模块：

// 实体
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(unique = true, nullable = false)
    private String username;
    
    @Column(unique = true, nullable = false)
    private String email;
    
    @Column(nullable = false)
    private String passwordHash;  // 存储加密后的密码，不是明文！
    
    @Enumerated(EnumType.STRING)
    private UserRole role;
    
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

// 密码加密——实战中一定要用BCrypt
@Service
public class PasswordEncoderService {
    private final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
    
    public String encode(String rawPassword) {
        return encoder.encode(rawPassword);
    }
    
    public boolean matches(String rawPassword, String encodedPassword) {
        return encoder.matches(rawPassword, encodedPassword);
    }
}

// 注册接口
@PostMapping("/register")
public ApiResponse<UserVO> register(@Valid @RequestBody RegisterRequest request) {
    // 1. 校验邮箱是否已注册
    if (userService.existsByEmail(request.getEmail())) {
        throw new BusinessException(400, "邮箱已被注册");
    }
    
    // 2. 加密密码
    String passwordHash = passwordEncoder.encode(request.getPassword());
    
    // 3. 保存用户
    User user = userService.register(request.getUsername(), request.getEmail(), passwordHash);
    
    return ApiResponse.success(UserVO.from(user));
}

订单模块（体现复杂业务逻辑）：

@Service
public class OrderService {
    
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private OrderItemMapper orderItemMapper;
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private InventoryService inventoryService;
    @Autowired
    private PaymentService paymentService;

    /**
     * 下单流程：
     * 1. 校验库存
     * 2. 扣减库存
     * 3. 创建订单和订单明细
     * 4. 调用支付接口
     */
    @Transactional(rollbackFor = Exception.class)
    public Long createOrder(Long userId, List<OrderItemRequest> items) {
        // 1. 校验库存并预扣减
        for (OrderItemRequest item : items) {
            Product product = productMapper.selectById(item.getProductId());
            if (product.getStock() < item.getQuantity()) {
                throw new BusinessException("商品" + product.getName() + "库存不足");
            }
            // 预扣减库存（等待支付成功后再确认扣减）
            inventoryService.reserveStock(item.getProductId(), item.getQuantity());
        }
        
        // 2. 计算订单总金额
        BigDecimal totalAmount = items.stream()
            .map(item -> {
                Product product = productMapper.selectById(item.getProductId());
                return product.getPrice().multiply(BigDecimal.valueOf(item.getQuantity()));
            })
            .reduce(BigDecimal.ZERO, BigDecimal::add);
        
        // 3. 创建订单
        Order order = new Order();
        order.setUserId(userId);
        order.setTotalAmount(totalAmount);
        order.setStatus(OrderStatus.PENDING_PAYMENT);
        order.setCreatedAt(LocalDateTime.now());
        orderMapper.insert(order);
        
        // 4. 创建订单明细
        for (OrderItemRequest item : items) {
            Product product = productMapper.selectById(item.getProductId());
            OrderItem orderItem = new OrderItem();
            orderItem.setOrderId(order.getId());
            orderItem.setProductId(product.getId());
            orderItem.setProductName(product.getName());
            orderItem.setQuantity(item.getQuantity());
            orderItem.setPrice(product.getPrice());
            orderItemMapper.insert(orderItem);
        }
        
        // 5. 调用支付
        PaymentResult paymentResult = paymentService.createPayment(order.getId(), totalAmount);
        order.setPaymentNo(paymentResult.getPaymentNo());
        order.setStatus(OrderStatus.PAID);
        orderMapper.updateById(order);
        
        return order.getId();
    }
    
    /**
     * 订单超时取消——使用定时任务
     */
    @Scheduled(cron = "0 */5 * * * *")  // 每5分钟执行一次
    public void cancelTimeoutOrders() {
        LocalDateTime expireTime = LocalDateTime.now().minusMinutes(30);
        List<Order> timeoutOrders = orderMapper.selectTimeoutOrders(expireTime);
        
        for (Order order : timeoutOrders) {
            // 1. 恢复库存
            List<OrderItem> items = orderItemMapper.selectByOrderId(order.getId());
            for (OrderItem item : items) {
                inventoryService.releaseReservedStock(item.getProductId(), item.getQuantity());
            }
            
            // 2. 更新订单状态
            order.setStatus(OrderStatus.CANCELLED);
            orderMapper.updateById(order);
        }
    }
}

四、企业级项目中的常见坑与踩坑经验

坑一：N+1查询导致性能问题

// ❌ 错误写法——查出订单列表后，再逐条查询用户信息，产生N+1查询
List<Order> orders = orderMapper.selectAll();
for (Order order : orders) {
    User user = userMapper.selectById(order.getUserId());  // 每次循环都查一次数据库
    order.setUser(user);
}

// ✅ 正确写法——使用JOIN一次查完
@Select("SELECT o.*, u.username, u.email FROM orders o LEFT JOIN users u ON o.user_id = u.id")
List<OrderWithUserVO> selectAllWithUser();

坑二：事务边界设置不当

// ❌ 错误——@Transactional标注在Controller层，且包含了HTTP请求和响应处理
@Transactional
@GetMapping("/orders")
public List<Order> getOrders() {
    List<Order> orders = orderService.listAll();
    // 这里如果调用了外部接口（比如发送通知），事务还没提交，外部接口就报错了
    sendNotification(orders);
    return orders;
}

// ✅ 正确——事务只包裹数据库操作，通知等外部调用放到事务外
@GetMapping("/orders")
public List<Order> getOrders() {
    List<Order> orders = orderService.listAll();
    sendNotification(orders);  // 事务已提交后才执行
    return orders;
}

坑三：异常被吞掉

// ❌ 错误——catch住异常后不处理，导致错误被静默忽略
try {
    orderService.createOrder(request);
} catch (Exception e) {
    // 什么都不做，日志也没打
}

// ✅ 正确——至少打日志，让问题可追踪
try {
    orderService.createOrder(request);
} catch (Exception e) {
    log.error("创建订单失败，请求参数：{}", request, e);
    throw new BusinessException("订单创建失败，请稍后重试");
}

坑四：大事务导致的数据库连接阻塞

// ❌ 错误——大事务，执行了很多耗时的非数据库操作
@Transactional
public void processBatch() {
    List<Order> orders = orderMapper.selectAllUnpaid();
    for (Order order : orders) {
        // 这里调用了耗时1秒的外部API
        paymentService.charge(order);
        orderMapper.updateStatus(order.getId(), PAID);
    }
}

// ✅ 正确——小事务，非数据库操作放到事务外
public void processBatch() {
    List<Order> orders = orderMapper.selectAllUnpaid();
    for (Order order : orders) {
        // 事务只包裹数据库操作，外部调用在外面
        paymentService.charge(order);  // 不占用数据库连接
        markAsPaid(order.getId());     // 小事务
    }
}

五、实战建议：怎么学才能最快上手企业项目

1. 不要只看不练

看视频、看文档是输入，写代码是输出。看懂了不代表会写了。我建议你每学一个知识点，就马上写一个小demo验证。比如学完Spring MVC，就写一个完整的CRUD接口；学完MyBatis，就连接真实数据库跑通查询。

2. 用Git管理你的代码

从第一天开始就用Git，养成提交commit的习惯。企业项目不会有人让你直接用本地文件。学会基本操作：

git init                    # 初始化仓库
git add .                   # 暂存所有变更
git commit -m "feat: 完成用户注册接口"
git push origin main        # 推送到远程
git pull origin main        # 拉取最新代码
git branch feature/pay      # 创建功能分支
git checkout feature/pay    # 切换到功能分支

3. 学会读官方文档

遇到不懂的，优先查Spring官方文档，比搜索引擎上的二手信息准确得多：

4. 参与真实项目

学完基础后，找一个真实的企业项目（开源项目或公司内部项目）跟着做。纸上得来终觉浅，绝知此事要躬行。遇到报错不要怕，每个错误都是学习的机会。

六、进阶方向：根据你的职业目标选择

当你掌握了Spring Boot基础，可以根据职业规划选择进阶方向：

后端开发方向：

  • Spring Cloud微服务架构
  • 消息队列（RabbitMQ/Kafka）
  • 分布式缓存（Redis）
  • 搜索引擎（Elasticsearch）
  • 分布式事务（Seata）

全栈开发方向：

  • 前端框架（Vue/React）
  • 前后端分离架构
  • Swagger接口文档
  • Docker容器化部署

DevOps方向：

  • Jenkins持续集成
  • Kubernetes容器编排
  • Nginx反向代理
  • Linux服务器运维

最后的话

学Spring这件事，没有捷径，但有方法。我把路线给你梳理清楚了，但真正走这条路的是你自己。不要试图一口气学完所有东西，那样容易半途而废。建议采用”学习→实践→总结→再学习”的循环，每学完一个模块就做一个小项目巩固。

记住，我刚开始学的时候也看不懂注解、配不通环境、调不通事务，但是每解决一个问题，就离能独立做项目更近一步。你现在遇到的困难，都是正常的学习曲线的一部分。遇到问题多搜多问，代码要自己动手写，不要只看不练。

祝你学习顺利，早日成为能独当一面的Java开发者！如果在学习过程中遇到具体的问题，随时可以来问我，我会尽力帮你解答。

-- 展开阅读全文 --