正文

从Hello World到项目实战零基础学Java开发框架Spring入门指南及常见坑点解析

/0 浏览量
0904

如果你刚接触Java后端开发，可能会觉得“Spring”这个词无处不在，但具体它到底是什么、为什么要用它、以及它怎么让你从“写代码的人”变成“设计系统的人”，可能还是一头雾水。别担心，这篇文章就是专门为你准备的。我们不讲枯燥的教科书定义，而是像老司机带新人一样，带你一步步跨过那个最难的门槛——从写出第一行Spring代码，到真正理解它背后的逻辑，最后避开那些会让新手崩溃的“坑”。

为什么是Spring？先搞清楚它在Java世界里的地位

在Spring出现之前，Java企业级开发是一种什么样的体验？想象一下，你要写一个Web应用，需要自己处理Servlet、手动管理数据库连接、用EJB（企业JavaBean）来写业务逻辑——那简直就是噩梦。代码冗长、配置复杂、部署困难。

Spring的出现，就像在混乱的工地里请来了一位全能的项目经理。它的核心思想是IoC（控制反转）和AOP（面向切面编程）。

  • IoC：以前是你自己去new对象（new UserService()），现在Spring帮你管这些对象。你只需要告诉Spring“我需要这个服务”，它就给你。这就像你去餐厅吃饭，以前是自己买菜、洗菜、做饭，现在是点菜，厨师（Spring）帮你做好端上来。
  • AOP：处理那些“横切关注点”，比如日志、事务、权限。以前你需要在每个方法里重复写日志代码，现在只需定义一次，Spring自动在合适的位置“织入”这些逻辑。

理解这两个概念，你就理解了Spring 80% 的核心价值。

环境准备：别被依赖配置劝退

很多新手在第一关就放弃了，因为Maven依赖配不对。别急，我们用最新的Spring Boot来简化这一切。Spring Boot是Spring的“快速启动器”，它默认配置好了大部分东西，你只需要关注业务。

第一步：安装JDK和IDEA

  • 下载并安装JDK 17或21（推荐LTS版本）。
  • 安装IntelliJ IDEA Community或Ultimate版本。社区版免费，功能足够学习。

第二步：创建项目 打开IDEA，选择“Create New Project”，左边选“Spring Initializr”，右边URL保持默认。点击Next。

填写基本信息：

  • Group: com.example
  • Artifact: demo
  • Java Version: 17 或 21
  • Dependencies: 勾选 Spring Web, Spring Data JPA, MySQL Driver, Lombok

点击Finish，等待Maven下载依赖。这个过程可能有点慢，耐心等待。

第三步：项目结构解析 创建好后，你会看到这样的结构：

src/main/java/com/example/demo/
├── DemoApplication.java          // 主启动类
├── controller/                   // 控制器层
├── service/                      // 服务层
├── repository/                   // 数据访问层
├── entity/                       // 实体类
└── config/                       // 配置类（可选）

src/main/resources/ 下有 application.properties 或 application.yml，这是配置文件的核心。

第一个Spring Boot应用：Hello World

让我们从最经典的Hello World开始。这次，我们创建一个RESTful API，返回“Hello, Spring!”。

1. 创建控制器 在controller包下新建HelloController.java：

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

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

关键点解释：

  • @RestController：这是一个组合注解，等价于@Controller + @ResponseBody。它告诉Spring，这个类里的方法返回的数据不是页面，而是直接写在HTTP响应体里（通常是JSON或纯文本）。
  • @GetMapping("/hello")：映射HTTP GET请求到/hello路径。

2. 启动应用 找到DemoApplication.java，右键点击main方法，选择“Run”。你会看到控制台输出：

Started DemoApplication in 2.5 seconds (process running for 3.2)

打开浏览器，访问 http://localhost:8080/hello，页面显示：Hello, Spring!

恭喜你，你已经迈出了第一步。但这只是皮毛，接下来我们要深入理解Spring是如何“管理”这些对象的。

深入IoC：理解Bean和依赖注入

为什么我们需要Spring来管理对象？假设你有一个UserService，它依赖一个UserRepository。在普通Java里，你会这样写：

public class UserService {
    private UserRepository repository = new UserRepository(); // 耦合度高，难以测试
    // ...
}

这样写的问题在于：

  1. 耦合严重：UserService紧紧绑定UserRepository，如果未来要换一种实现（比如从MySQL换到MongoDB），你需要改代码。
  2. 难以测试：单元测试时，你需要一个真实的数据库连接，否则new UserRepository()会失败。

Spring的IoC容器解决了这个问题。我们使用依赖注入（DI）：

package com.example.demo.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {

    private final UserRepository userRepository;

    // 构造器注入：Spring会自动查找UserRepository类型的Bean并传入
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public String findUserById(Long id) {
        return "User " + id + " from " + userRepository.getClass().getSimpleName();
    }
}

关键点：

  • @Service：告诉Spring，这是一个服务组件，要把它交给容器管理。
  • 构造器注入：推荐用private final字段 + 构造器注入。这比字段注入（@Autowired在字段上）更清晰，更符合单一职责原则，也便于单元测试。

再看UserRepository：

package com.example.demo.repository;

import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {
    public String findName(Long id) {
        return "Name_" + id;
    }
}

关键点：

  • @Repository：标记数据访问层组件。Spring会用它做异常翻译（把数据库异常转为Spring的统一异常体系）。

现在，Spring容器里有了两个Bean：userService和userRepository。当你调用userService.findUserById(1L)时，Spring已经自动把userRepository注入进去了。你不需要再new任何东西。

Spring MVC：处理HTTP请求

回到我们的控制器。刚才的HelloController很简单，但如果我们要处理用户登录、查询数据呢？这就需要Spring MVC的知识。

1. 接收请求参数

@PostMapping("/login")
public String login(@RequestParam String username, @RequestParam String password) {
    // 业务逻辑
    return "Login successful: " + username;
}

2. 接收JSON请求体（推荐） 现代Web开发大多用JSON。我们可以定义一个请求DTO：

package com.example.demo.dto;

import lombok.Data;

@Data
public class LoginRequest {
    private String username;
    private String password;
}

然后控制器：

@PostMapping("/login/json")
public String loginJson(@RequestBody LoginRequest request) {
    return "Login JSON successful: " + request.getUsername();
}

3. 返回JSON响应 Spring MVC默认使用Jackson库将对象序列化为JSON。我们只需要返回一个对象：

@GetMapping("/user/{id}")
public UserDto getUser(@PathVariable Long id) {
    // 假设这里查询了数据库
    UserDto dto = new UserDto();
    dto.setId(id);
    dto.setName("Alice");
    return dto; // Spring自动转为JSON
}

UserDto：

package com.example.demo.dto;

import lombok.Data;

@Data
public class UserDto {
    private Long id;
    private String name;
}

关键点：

  • @PathVariable：映射URL路径变量，如/user/123中的123。
  • @RequestBody：将HTTP请求体（JSON）反序列化为Java对象。
  • @Data：Lombok注解，自动生成getter、setter、toString、equals、hashCode，减少样板代码。

数据持久化：Spring Data JPA入门

现在，我们要把用户信息存进数据库。Spring Data JPA让这件事变得极其简单。

1. 配置文件application.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/testdb?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
    username: root
    password: your_password
  jpa:
    hibernate:
      ddl-auto: update  # 自动创建/更新表结构（仅开发环境使用）
    show-sql: true      # 打印SQL语句，方便调试

2. 实体类User.java

package com.example.demo.entity;

import jakarta.persistence.*;
import lombok.Data;

@Data
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;

    @Column(nullable = false)
    private String password;

    @Column(nullable = false)
    private String email;
}

关键点：

  • @Entity：标记为JPA实体，对应数据库表。
  • @Id + @GeneratedValue：主键，自增。
  • @Column：映射列属性，nullable=false表示非空。

3. Repository接口

package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    // 无需实现任何方法！Spring Data JPA自动生成实现
    User findByUsername(String username); // 方法名约定，自动生成SQL
}

关键点：

  • 继承JpaRepository<User, Long>，第一个泛型是实体类型，第二个是主键类型。
  • 方法名findByUsername会被Spring Data解析为SELECT * FROM users WHERE username = ?。
  • 你不需要写任何实现代码！这就是“约定优于配置”的力量。

4. 在Service中使用

@Service
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User saveUser(User user) {
        return userRepository.save(user);
    }

    public User getUserById(Long id) {
        return userRepository.findById(id).orElseThrow(() -> new RuntimeException("User not found"));
    }

    public User findByUsername(String username) {
        return userRepository.findByUsername(username);
    }
}

事务管理：保证数据一致性

当我们需要同时更新多张表时，必须保证要么全部成功，要么全部失败。这就是事务。Spring用@Transactional注解轻松搞定。

示例：转账操作

@Service
public class AccountService {
    private final AccountRepository accountRepository;

    public AccountService(AccountRepository accountRepository) {
        this.accountRepository = accountRepository;
    }

    // 加@Transactional，声明这是一个事务方法
    @Transactional
    public void transfer(Long fromId, Long toId, Double amount) {
        Account from = accountRepository.findById(fromId).orElseThrow();
        Account to = accountRepository.findById(toId).orElseThrow();

        if (from.getBalance() < amount) {
            throw new RuntimeException("Insufficient balance");
        }

        from.setBalance(from.getBalance() - amount);
        to.setBalance(to.getBalance() + amount);

        accountRepository.save(from);
        accountRepository.save(to);
        // 如果上面任何一步抛异常，整个事务回滚，数据不变
    }
}

关键点：

  • @Transactional可以加在类上（所有public方法都事务化）或方法上（仅该方法）。
  • 默认只在抛运行时异常（RuntimeException）时回滚。如果想检查异常也回滚，需配置：@Transactional(rollbackFor = Exception.class)。
  • 注意：@Transactional在同类内部调用时可能失效（代理机制限制），建议从外部Bean调用。

常见坑点解析：新手最容易踩的雷区

虽然Spring强大，但新手很容易遇到各种奇怪的问题。下面总结几个高频坑点，帮你避坑。

坑点1：@Autowired字段注入 vs 构造器注入

错误做法：

@Service
public class MyService {
    @Autowired
    private UserRepository repository; // 字段注入
}

问题：字段注入难以测试，代码可读性差，且无法保证依赖不可变。 正确做法：始终使用构造器注入。

@Service
public class MyService {
    private final UserRepository repository;

    @Autowired // 只有一个构造器时，@Autowired可省略
    public MyService(UserRepository repository) {
        this.repository = repository;
    }
}

坑点2：循环依赖

场景：ServiceA依赖ServiceB，ServiceB又依赖ServiceA。

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

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

结果：启动报错，BeanCurrentlyInCreationException。 解决：

  1. 重构代码：提取一个ServiceC，让A和B都依赖C（根本解法）。
  2. 使用@Lazy：在其中一个依赖上添加@Lazy，延迟初始化（临时解法）。
  3. Setter注入：Spring可以通过Setter注入解决部分循环依赖，但不推荐依赖此特性。

坑点3：@Transactional不生效

常见原因：

  1. 方法不是public：@Transactional只作用于public方法。
  2. 同类内部调用：this.method()绕过代理，事务不生效。 
    
@Service
public class OrderService {
   public void createOrder() {
       updateInventory(); // 同类调用，事务失效！
   }
   @Transactional
   public void updateInventory() { ... }
}
    解决：将updateInventory提取到另一个Service，或通过ApplicationContext获取自身Bean调用。
  3. 异常被捕获未抛出：如果方法内try-catch吞掉了异常，事务不会回滚。 
    
@Transactional
public void doSomething() {
   try {
       // 可能抛异常
   } catch (Exception e) {
       // 吞掉异常，事务不 rollback
   }
}
    解决：在catch中重新抛出throw new RuntimeException(e)。

坑点4：N+1查询问题

场景：用JPA查询用户列表，每个用户都有orders列表。

@OneToMany(mappedBy = "user")
private List<Order> orders;

如果你遍历用户列表，再对每个用户调用getOrders()，会产生N+1次SQL查询（1次查用户，N次查订单）。 解决：

  1. 使用@EntityGraph： 
    
@EntityGraph(attributePaths = {"orders"})
List<User> findAllWithOrders();
  2. 使用JPQL JOIN FETCH： 
    
@Query("SELECT DISTINCT u FROM User u LEFT JOIN FETCH u.orders")
List<User> findAllWithOrders();

坑点5：全局异常处理不当

新手往往在每个Controller里写try-catch，导致代码重复。Spring提供@ControllerAdvice统一处理。

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntimeException(RuntimeException e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body("Error: " + e.getMessage());
    }

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<String> handleUserNotFoundException(UserNotFoundException e) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
                .body(e.getMessage());
    }
}

关键点：

  • @RestControllerAdvice：对RestController统一异常处理。
  • 根据异常类型返回不同状态码和消息，提升API健壮性。

实战项目：一个简单的用户管理系统

现在，我们把前面学的知识整合起来，做一个完整的用户管理API。

需求：

  • 创建用户（POST /users）
  • 查询所有用户（GET /users）
  • 根据ID查询用户（GET /users/{id}）
  • 更新用户（PUT /users/{id}）
  • 删除用户（DELETE /users/{id}）

1. 实体类User.java（略，见上文）

2. Repository

public interface UserRepository extends JpaRepository<User, Long> {
}

3. Service “`java @Service public class UserService {

private final UserRepository userRepository;

public UserService(UserRepository userRepository) {
    this.userRepository = userRepository;
}

@Transactional
public User create(User user) {
    return userRepository.save(user);
}

public List<User> findAll() {
    return userRepository.findAll();
}

public User findById(Long id) {
    return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException("User not found: " + id));
}

@Transactional
public User update(Long id, User userDetails) {
    User user = findById(id);
    user.setUsername(userDetails.getUsername());
    user.setEmail(userDetails.getEmail());
-- 展开阅读全文 --