Sprint 1-2：创建第一个 Spring Boot Module（user-service）

一、内容包括：

• 创建 Maven Module
• 引入 spring-boot-starter-web
• 创建启动类
• 启动 Spring Boot
• 写第一个 Controller
• 理解 IoC 容器

一、为什么必须先做 user-service

minishop-user

└── src/main/java

└── com/minishop/user

├── controller

├── service

├── mapper

├── domain

└── UserApplication.java

user- service------用户服务（登录、注册、用户信息）

企业微服务的顺序通常是：

用户系统（User）

→ 商品系统（Product）

→ 订单系统（Order）

→ 支付系统（Payment）

1.1 构建UserApplication.java

在src/main/java中New → Package，输入com.minishop.user，在此package中创建UserApplication.java。完整路径===minishop-user/src/main/java/com/minishop/user/UserApplication.java

1、User的pom.xml需要添加 Spring Boot Web依赖。

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

2、UserApplication.java

package com.minishop.user;

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

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

二、Sprint 1-3：企业级分层架构（Controller / Service / Mapper）

二、标准三层架构

在 minishop-user 中，我们定义：

Controller → Service → Mapper

1）Controller（接口层）

职责：

• 接收 HTTP 请求
• 参数校验（简单）
• 返回结果
• 不写业务逻辑 ❌

2）Service（业务层）

职责：

• 核心业务逻辑
• 事务控制
• 调用多个 Mapper / Redis / Kafka

3）Mapper（数据层）

职责：

• 只负责数据库操作
• MyBatis SQL
• 不写业务逻辑

1.1 构建user第一个接口

构建 controller 软件包：/Java_work/minishop/minishop-user/src/main/java/com/minishop/user/controller

创建UserController.java

✅ @GetMapping ≈ FastAPI 的 @app.get("/path")------把 HTTP GET 请求映射到某个 Java 方法

✅ @RestController ≈ FastAPI 的 APIRouter + JSON Response 模式，=Controller + ResponseBody 的合体=@Controller + @ResponseBody=这个类里的所有方法，返回值都会直接写入 HTTP Response Body

package com.minishop.user.controller;

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

@RestController
public class UserController {

    @GetMapping("/user/hello")
    public String hello() {
        return "hello minishop user service";
    }
}
/**同等于python如下写法
from fastapi import FastAPI

app = FastAPI()

@app.get("/user/hello")
def hello():
    return {"msg": "hello"}
*/

注解	对应 HTTP
@GetMapping	GET
@PostMapping	POST
@PutMapping	PUT
@DeleteMapping	DELETE

1.1.1 规范返回

1.1中的输出是String，但是我们一般需要采用Json进行规范输出。

{
  "code": 0,
  "message": "success",
  "data": {}
}

Step 1：创建包

minishop-common
└── src/main/java/com/minishop/common
创建com.minishop.common.result

Step 2：创建 Result.java

Serializable------标记接口 （Marker Interface），告诉 JVM：这个类的对象可以被"序列化（把Java对象从内存对象--**让该对象跨进程传输能力，**转为字节流byte ，用于网络传输、redis存储、Kafka消息、文件持久化）；

class Result<T>------ 泛型结构；private T data的类型由调用者决定。

**static------**不需要new 对象，就可以直接调用。static <T> 就是泛型方法，调用时自动推导类型。

private------定义后的对象仅内部访问，外部无法更改，例成功的code就一定是0；DTO = private + getter/setter。

public Result------方法重载（overload）， 当无输出Result时，JSON中需要返回null，即采用无参Result，有输出就采用有参Result。也可以不写空的Result，但这样controller处就必须

package com.minishop.common.result;

import java.io.Serializable;

public class Result<T> implements Serializable {

    private Integer code;
    private String message;
    private T data;

    public Result() {}

    public Result(Integer code, String message, T data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }

    // 成功
    public static <T> Result<T> success(T data) {
        return new Result<>(0, "success", data);
    }

    public static <T> Result<T> success() {
        return new Result<>(0, "success", null);
    }

    // 失败
    public static <T> Result<T> fail(Integer code, String message) {
        return new Result<>(code, message, null);
    }

    public Integer getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }

    public T getData() {
        return data;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public void setData(T data) {
        this.data = data;
    }
}

S3、在 user-service 中使用------在Controller中实现Result接口

package com.minishop.user.controller;

import com.minishop.common.result.Result;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @GetMapping("/user/hello")
    public Result<String> hello() {
        return Result.success("hello minishop user");
    }
}

S4、添加common依赖

在user的pom.xml中的依赖项中添加common依赖

<dependencies>
    <dependency>
        <groupId>com.minishop</groupId>
        <artifactId>minishop-common</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </dependency>

</dependencies>

测试：http://localhost:8080/user/hello

返回即JSON

Spring MVC 核心执行链路

1. 前端
2. Tomcat【接单】（内嵌服务器，接收 HTTP → 封装 HttpServletRequest，然后交给DispatcherServlet）
3. DispatcherServlet【总调度】（本质Servlet，接受请求并分发）
4. HandlerMapping【找人】（找控制器）
5. HandlerAdapter【执行】（执行方法的"适配器"）
6. Controller【业务】
7. ReturnValueHandler【包装】（返回值处理器，判断返回值是对象 → 需要转换 JSON）
8. HttpMessageConverter【输出控制】（JSON转换器）
9. 写回 HTTP Response【响应】（写入 response body → 返回前端）