Spring框架入门到精通完整教程2024版零基础Java开发必学

嘿，朋友！既然你点开了这篇文章，说明你已经在Java开发的路上迈出了一大步，现在正站在Spring框架的大门口，既好奇又有点担心它会不会像那些老旧的XML配置一样让人头大。别紧张，我见过太多初学者在这里迷路，但只要你跟着我的节奏，这一关其实很好过。咱们不整那些晦涩的教科书语言，就把Spring当作一个帮你打理“杂乱房间”的超级管家来聊，这样你就能理解它到底在做什么了。

为什么Java离不开Spring？先聊聊那个“噩梦”时代

在2004年之前，Java企业级开发是什么样子？想象一下，你要写一个简单的用户注册功能，你需要自己引入一堆JAR包，手动管理对象的生命周期，还要处理事务、日志、安全等等。更糟糕的是，如果你想换个数据库，或者想把日志从打印到控制台改成写入文件，你得改几十个文件。那感觉就像是你家里每个灯泡的开关都装在房子的不同角落，而且没有图纸。

Spring的出现，本质上就是为了解决这种“混乱”。它的核心思想非常朴素：解耦。

我们可以用一个生活中的例子来理解。假设你要开一家餐厅（开发一个应用）。

没有Spring时：你得自己买食材（依赖第三方库）、自己洗菜、自己炒菜、自己端盘子、自己收银。如果洗碗机坏了，你还得自己修，整个餐厅就瘫痪了。
有了Spring后：你只需要专注于“做菜”（写业务逻辑）。餐厅的装修、水电、收银系统、甚至洗碗工，Spring都帮你打理好了。你只需要告诉Spring：“我要个厨师”、“我要个收银员”，它就会帮你把这些角色组装起来，并且确保他们各司其职。

这就是Spring的IOC（控制反转）和AOP（面向切面编程）最直观的解释。

第一部分：IoC容器——你的私人物品收纳盒

1.1 什么是IoC（控制反转）？

在传统开发中，对象是由你自己创建的。比如：

public class UserService {
    private UserDao userDao = new UserDaoImpl(); // 自己new，自己管
    
    public void register(String username) {
        userDao.save(username);
    }
}

你看，UserService 和 UserDaoImpl 紧紧耦合在一起。如果有一天老板说：“我们需要把用户存到MongoDB，而不是MySQL”，你就得修改 UserService 的代码，甚至可能要重新编译整个项目。

IoC的做法是：不再由程序本身来控制对象的创建和依赖，而是将这一权利交给一个第三方容器——Spring容器。

@Service
public class UserService {
    
    // 只需要声明依赖，Spring会自动帮你注入
    @Autowired
    private UserDao userDao; 
    
    public void register(String username) {
        userDao.save(username);
    }
}

这里，你不再关心 UserDao 是怎么创建的，Spring会在后台帮你创建好，然后“注入”到你需要的地方。这就好比你去餐厅，只需要点菜（声明依赖），厨师怎么炒、用什么锅，你不需要关心，餐厅（Spring容器）会搞定。

1.2 Bean的定义与管理

在Spring中，被容器管理的对象叫做 Bean。你可以把Bean想象成餐厅里的各种角色：厨师、服务员、收银员。每个角色都有特定的职责（方法），并且需要依赖其他角色（依赖注入）。

如何定义一个Bean？

最现代、最推荐的方式是使用注解。在Spring Boot时代，我们几乎不需要再写繁琐的XML配置了。

// 1. 这是一个Bean，Spring会管理它的生命周期
@Component // 通用组件
public class UserDaoImpl implements UserDao {
    
    @Override
    public void save(String username) {
        System.out.println("用户 " + username + " 已保存到数据库");
    }
}

或者，如果这是一个业务服务：

@Service // 专门用于业务层
public class UserService {
    
    @Autowired // 自动注入依赖
    private UserDao userDao;
    
    public void register(String username) {
        if (username == null || username.isEmpty()) {
            throw new IllegalArgumentException("用户名不能为空");
        }
        userDao.save(username);
        System.out.println("注册成功");
    }
}

Bean的作用域

有时候，你可能希望每次请求都创建一个新的对象（比如处理用户购物车），有时候又希望整个应用只用一个实例（比如缓存管理器）。Spring提供了多种作用域：

Singleton（单例，默认）：整个应用中只有一个Bean实例。性能好，但要注意线程安全。
Prototype（原型）：每次请求都创建一个新实例。适用于有状态的Bean。
Request：每个HTTP请求创建一个实例。
Session：每个HTTP Session创建一个实例。

@Service
@Scope("prototype") // 每次注入都会创建新实例
public class ShoppingCart {
    private List<String> items = new ArrayList<>();
    
    public void addItem(String item) {
        items.add(item);
    }
    
    public List<String> getItems() {
        return items;
    }
}

1.3 如何启动Spring容器？

现在有了Bean，怎么让它们运行起来？你需要一个启动类。

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {
    public static void main(String[] args) {
        // 启动Spring容器，扫描当前包及其子包下的所有注解
        AnnotationConfigApplicationContext context = 
            new AnnotationConfigApplicationContext("com.example.demo");
        
        // 从容器中获取Bean
        UserService userService = context.getBean(UserService.class);
        
        // 调用业务方法
        userService.register("张三");
        
        // 关闭容器
        context.close();
    }
}

关键点：AnnotationConfigApplicationContext 是Spring的核心容器，它负责扫描、创建和管理所有Bean。@ComponentScan 注解可以指定扫描路径，确保Spring能找到你的Bean。

第二部分：DI依赖注入——Spring的“牵线搭桥”

刚才提到了 @Autowired，这就是依赖注入（DI）的核心机制。DI是IoC的具体实现方式，意思是：你不主动去创建依赖对象，而是由容器在运行时“注入”给你。

2.1 三种注入方式

方式一：构造器注入（推荐）

这是最安全、最清晰的注入方式。Spring官方强烈推荐，因为它能确保依赖在Bean创建时就已经准备好，且不可变。

@Service
public class OrderService {
    
    private final PaymentService paymentService;
    private final NotificationService notificationService;
    
    // Spring会自动通过构造函数注入依赖
    // 必须加上 @Autowired，除非只有一个构造函数
    @Autowired
    public OrderService(PaymentService paymentService, 
                        NotificationService notificationService) {
        this.paymentService = paymentService;
        this.notificationService = notificationService;
    }
    
    public void placeOrder(String orderId, double amount) {
        paymentService.charge(amount);
        notificationService.sendNotification(orderId);
        System.out.println("订单 " + orderId + " 处理完成");
    }
}

为什么推荐构造器注入？

不可变性：依赖可以在构造时初始化，然后标记为 final，防止后续被篡改。
强制依赖：如果某些依赖是必需的，构造器注入能确保它们不被遗漏。
便于测试：单元测试时，你可以直接 new OrderService(mockPayment, mockNotification)，无需启动Spring容器。

方式二：Setter注入

适用于可选依赖。当某个依赖不是必需的，或者需要在运行时动态改变时，可以使用Setter注入。

@Service
public class UserService {
    
    private String defaultEmail;
    
    @Autowired(required = false) // 表示这个依赖是可选的
    public void setDefaultEmail(String defaultEmail) {
        this.defaultEmail = defaultEmail;
    }
    
    public void sendEmail(String to, String content) {
        String from = defaultEmail != null ? defaultEmail : "admin@example.com";
        System.out.println("发送邮件: " + content + " from " + from + " to " + to);
    }
}

方式三：字段注入（不推荐）

这是最常见的方式，代码简洁，但存在问题：依赖关系不明显，且难以进行单元测试。

@Service
public class UserService {
    
    @Autowired
    private UserDao userDao; // 字段注入
    
    public void save(User user) {
        userDao.save(user);
    }
}

我的建议：除非你有非常特殊的理由，否则请使用构造器注入。它能让你和团队成员更清楚地看到类依赖了哪些组件，也让代码更易维护。

2.2 @Autowired 与 @Resource 的区别

这两个注解都能实现依赖注入，但有细微差别：

@Autowired：Spring提供的注解，默认按类型（byType）注入。如果存在多个相同类型的Bean，会按名称（byName）匹配。可以通过 required = false 设置为可选。
@Resource：JDK提供的注解（JSR-250），默认按名称（byName）注入。如果找不到匹配的Bean，会按类型回退。

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

// @Resource 按名称注入，如果Bean名称是"userDao"则匹配成功
@Resource(name = "userDao")
private UserDao userDao;

2.3 解决“多个相同类型Bean”的冲突

如果Spring容器中存在两个 UserDao 的实现，比如 MySqlUserDao 和 OracleUserDao，@Autowired 会报错，因为它不知道该注入哪一个。这时可以使用 @Qualifier 来指定具体名称。

@Service
public class UserService {
    
    @Autowired
    @Qualifier("mySqlUserDao") // 明确指定注入哪个Bean
    private UserDao userDao;
    
    public void save(User user) {
        userDao.save(user);
    }
}

或者，你可以为其中一个Bean指定 @Primary，让它成为默认注入对象。

@Component
@Primary // 默认注入这个
public class MySqlUserDao implements UserDao { ... }

@Component
public class OracleUserDao implements UserDao { ... }

第三部分：Spring MVC——处理Web请求的“前台接待”

如果你要开发Web应用，Spring MVC是Spring框架中负责处理HTTP请求的部分。它的核心思想是控制器（Controller），每个方法对应一个URL路径，接收参数，返回结果。

3.1 一个简单的Web应用

假设你要开发一个简单的REST API，实现用户查询功能。

步骤一：添加依赖

在Maven项目中，添加以下依赖：

<dependencies>
    <!-- Spring Web MVC -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- 测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

步骤二：创建实体类

public class User {
    private Long id;
    private String name;
    private Integer age;
    
    // 构造器、getter、setter省略
    public User(Long id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    
    public Long getId() { return id; }
    public String getName() { return name; }
    public Integer getAge() { return age; }
}

步骤三：创建Controller

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

@RestController // 表示这是一个控制器，且所有方法的返回值都会直接作为HTTP响应体
@RequestMapping("/api/users") // 类级别的请求路径前缀
public class UserController {
    
    // 模拟数据库
    private static final Map<Long, User> users = new HashMap<>();
    static {
        users.put(1L, new User(1L, "张三", 25));
        users.put(2L, new User(2L, "李四", 30));
    }
    
    // GET: 查询所有用户
    @GetMapping
    public List<User> getAllUsers() {
        return new ArrayList<>(users.values());
    }
    
    // GET: 根据ID查询单个用户
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return users.get(id);
    }
    
    // POST: 创建新用户
    @PostMapping
    public User createUser(@RequestBody User user) {
        user.setId((long) (users.size() + 1));
        users.put(user.getId(), user);
        return user;
    }
    
    // PUT: 更新用户
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        if (!users.containsKey(id)) {
            return null; // 实际项目中应返回404
        }
        user.setId(id);
        users.put(id, user);
        return user;
    }
    
    // DELETE: 删除用户
    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable Long id) {
        users.remove(id);
        return "Deleted";
    }
}

步骤四：创建启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

步骤五：运行与测试

启动应用后，访问 http://localhost:8080/api/users，你会看到返回的JSON数据：

[
  {"id":1,"name":"张三","age":25},
  {"id":2,"name":"李四","age":30}
]

3.2 核心注解详解

@RestController：等同于 @Controller + @ResponseBody，表示该类的所有方法返回的数据都会直接写入HTTP响应体，而不是视图名称。
@RequestMapping：映射请求路径，可以放在类或方法上。
@GetMapping、@PostMapping 等：@RequestMapping 的简化版本，更语义化。
@PathVariable：获取URL路径中的变量，如 /{id}。
@RequestParam：获取查询参数，如 ?name=张三。
@RequestBody：将HTTP请求体（通常是JSON）绑定到Java对象。
@ResponseBody：将Java对象转换为JSON响应。

3.3 处理异常

在实际项目中，错误处理至关重要。Spring提供了全局异常处理机制。

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

@RestControllerAdvice // 全局异常处理
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
    
    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<String> handleUserNotFound(UserNotFoundException ex) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ex.getMessage());
    }
    
    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<String> handleBadRequest(IllegalArgumentException ex) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(ex.getMessage());
    }
}

然后，在你的Controller中抛出异常：

@GetMapping("/{id}")
public User getUserById(@PathVariable Long id) {
    User user = users.get(id);
    if (user == null) {
        throw new UserNotFoundException("用户不存在: " + id);
    }
    return user;
}

第四部分：Spring Data JPA——让数据库操作变简单

4.1 什么是JPA？

JPA（Java Persistence API）是Java的持久化标准，它定义了一组接口和注解，用于将Java对象映射到数据库表。Spring Data JPA是Spring提供的一个简化JPA开发的框架，你只需要定义接口，它会自动生成实现。

4.2 创建一个用户管理系统

步骤一：添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

这里我们使用H2内存数据库，方便演示。

步骤二：配置数据源

在 application.properties 中配置：

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

步骤三：定义实体类

import jakarta.persistence.*;

@Entity // 标记为JPA实体
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, length = 50)
    private String name;
    
    @Column
    private Integer age;
    
    // 空构造器是必需的，JPA需要它来反射创建对象
    public User() {}
    
    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
}

步骤四：定义Repository接口

”`java import org.springframework.data.jpa.repository.JpaRepository;

为什么Java离不开Spring？先聊聊那个“噩梦”时代

第一部分：IoC容器——你的私人物品收纳盒

1.1 什么是IoC（控制反转）？

1.2 Bean的定义与管理

如何定义一个Bean？

Bean的作用域

1.3 如何启动Spring容器？

第二部分：DI依赖注入——Spring的“牵线搭桥”

2.1 三种注入方式

方式一：构造器注入（推荐）

方式二：Setter注入

方式三：字段注入（不推荐）

2.2 @Autowired 与 @Resource 的区别

2.3 解决“多个相同类型Bean”的冲突

第三部分：Spring MVC——处理Web请求的“前台接待”

3.1 一个简单的Web应用

步骤一：添加依赖

步骤二：创建实体类

步骤三：创建Controller

步骤四：创建启动类

步骤五：运行与测试

3.2 核心注解详解

3.3 处理异常

第四部分：Spring Data JPA——让数据库操作变简单

4.1 什么是JPA？

4.2 创建一个用户管理系统

步骤一：添加依赖

步骤二：配置数据源

步骤三：定义实体类

步骤四：定义Repository接口

相关阅读

掌握 TypeScript，轻松驾驭前端框架，解锁高效编程新技能

从小白到高手：全面解析Java开发框架Spring必备技能与实战技巧

揭秘Java项目框架：入门到精通，轻松提升开发效率

学会TypeScript，玩转前端框架的秘密武器

如何巧妙运用AJAX与前端框架，提升Web应用性能与用户体验

轻松入门：AJAX技术搭配主流前端框架的实战指南

从零开始，掌握TypeScript与热门前端框架的完美融合

学会MyBatis，轻松实现数据库操作：从入门到精通，高效提升Java开发技能

掌握Web前端开发，这5个框架必学，提升效率，成就精彩项目

学会AJAX，轻松驾驭前端框架：掌握关键技术，打造高效交互网页