本文章是为想要学习springboot的人而编写的教程，旨在用简单易懂的语言来讲解，帮助广大学生了解javaweb，学习springboot之前应该先了解spring famework。

本文章适合有一定java基础的同学阅读，作者之后还会出java教程。

一、SpringFramework 概述

了解一门技术，先要了解它是什么，了解这些方式最直接的方式是借助官方文档，我们打开spring的官方文档，以下是网址

Spring Frameworkhttps://spring.io/projects/spring-framework

我们可以看到这样的描述：

Spring 框架为现代基于 Java 的企业级应用，提供一套完备的编程与配置模型，可适配任意部署平台。

Spring 的核心优势之一，是在应用层提供完善的基础设施支撑：Spring 专注处理企业应用的底层通用基建，让开发团队只需聚焦业务逻辑开发，无需与特定部署环境强耦合、受其束缚。

1、SpringFramework的组成结构

SpringFramework是一个分层的架构，它包含一系列的要素并且分为若干个模块，下面简单描述这些核心模块的含义和作用。

（1）IOC

控制反转，把对象的创建和调用权交给Spring容器管理，而不是在代码中手动new对象。

（2）AOP

是基于面向对象编程的补充，可以支持开发者定义一些方法的切入点和增强器，用于将一些通用逻辑代码与业务功能代码相分离，降低其耦合度。

（3）数据访问

（4）web

（5）测试

2、开发环境准备

JDK：17及以上

Maven：3.6+

IDEA：2023.2.5Ultimate及以上

以上都是准备工作，接下来我们正式开始。

二、什么是IOC？

控制反转（Inverse of Control IOC）对于刚开始学习Spring Framework的同学可能不是那么容易理解，我将从一个场景开始推导IOC思想的实现过程。

项目结构如下

可能有的同学连MVC都不是很了解，我在这里简单的说明一下。其实我们这里列举的例子更偏向于更早的Java Web三层架构

1.项目分析

1.servlet（控制层Controller）

我们想象一下，一个用户前来，我们的控制层就相当于一个接待员，直接面对用户（浏览器）。它负责接收请求，并决定给用户什么响应。（告诉前端 / 用户：我们系统提供哪些功能、哪些接口、能干哪些事） 具体工作：接收参数，调用 Service，响应结果。  具体代码：

package org.example.servlet;
import org.example.service.UserService;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.*;
import java.io.IOException;

@WebServlet("/user")
public class UserServlet extends HttpServlet {
    // ❌ 痛点2：Servlet 必须知道 UserService 的具体类名
    private UserService userService = new UserService();

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        resp.setContentType("text/html;charset=UTF-8");
        System.out.println("【Servlet】收到注册请求");
        userService.register();
        resp.getWriter().println("<h1>注册成功！(传统方式)</h1>");
    }
}

2.service（业务层）

package org.example.service;
import org.example.dao.UserDao;

public class UserService {
    // ❌ 痛点1：Service 必须知道 UserDao 的具体类名
    private UserDao userDao = new UserDao(); 

    public void register() {
        System.out.println("【Service】正在校验用户信息...");
        userDao.save();
    }
}

3.Dao层（数据层）

package org.example.dao;

public class UserDao {
    public void save() {
        System.out.println("【Dao】用户数据已存入 MySQL");
    }
}

好了，其实你现在已经能发现问题了，dao和service层都是自己new的,代码写死了依赖关系，改一个地方，全链路都要改。，这就暴露出了最致命的问题，这就是IOC要解决的痛点。

我们想想该怎么改进。如果我们把对象的创建，依赖的注入交给外部容器控制，是不是能解决呢？

可以试着做一下——不要自己new，让别人传给你，这就是IOC的核心，控制反转。，要实现，我们需要接口。

2.改进

不要直接依赖实现类，依赖接口，这样实现不用改代码。

新建Dao接口

package org.example.dao;
public interface IUserDao {
    void save();
}

(让 UserDao 实现这个接口：public class UserDao implements IUserDao)

Service层，依赖接口，不再new实现类

Servlet层，同样依赖接口

最后，我们手动实现一个简易的IOC容器，IOC容器干两件事，创建所有对象，（servlet，service，dao），自动把依赖注入进去。

package org.example.service;
import org.example.dao.IUserDao;

public class UserService {
    private IUserDao userDao; // ✅ 改进1：只依赖接口

    // ✅ 改进2：提供 Setter，等待外部注入
    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }

    public void register() {
        System.out.println("【Service】正在校验用户信息...");
        userDao.save();
    }
}

手写IOC容器

package org.example.container;

import org.example.dao.IUserDao;
import org.example.dao.impl.UserDao;
import org.example.service.UserService;
import org.example.servlet.UserServlet;

public class SimpleIOC {
    public static void main(String[] args) {
        System.out.println("--- 启动自定义 IOC 容器 ---");

        // 1. 【对象的创建权】交给容器
        IUserDao userDao = new UserDao();
        UserService userService = new UserService();
        UserServlet userServlet = new UserServlet();

        // 2. 【依赖的管理权】交给容器（这就是控制反转！）
        System.out.println("容器正在组装零件...");
        userService.setUserDao(userDao);       // 容器帮 Service 找 Dao
        userServlet.setUserService(userService); // 容器帮 Servlet 找 Service

        // 3. 交付使用
        userServlet.doGet(null, null);
    }
}

一句话总结：不自己new对象，由ioc容器统一创建、管理对象，并自动注入依赖。控制权从类反转到容器。

两个核心动作：IOC容器管理Bean（对象），DI(依赖注入)：IOC容器把依赖的对象自动赋值给需要的类。   总之，IOC是思想，DI是实现方式。

我们刚刚写的SimleIOC就是Spring IOC的迷你版。