Spring MVC 基础教程

Spring MVC 一次请求的处理流程：

1. 浏览器发起 HTTP 请求
2. DispatcherServlet（前端控制器）接收请求
3. HandlerMapping 根据 URL 找到对应的 Controller 方法
4. HandlerAdapter 调用 Controller 方法执行业务
5. Controller 返回 ModelAndView（模型数据 + 视图名）
6. ViewResolver 解析视图名 → 定位 JSP/Thymeleaf 模板
7. View 渲染模型数据生成 HTML
8. 响应返回浏览器

核心组件：
- DispatcherServlet：总控分发
- HandlerMapping：URL → 处理器映射
- HandlerAdapter：处理器适配执行
- ViewResolver：视图解析器
- View：视图渲染

<!-- pom.xml -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.3.39</version>
</dependency>

<!-- springmvc.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

  <context:component-scan base-package="com.example.controller"/>
  <mvc:annotation-driven/>

  <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>
  </bean>
</beans>

<!-- HelloController -->
@Controller
public class HelloController {

    @RequestMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("msg", "Hello Spring MVC");
        return "hello";
    }
}

package com.example.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example.controller")
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver resolver =
                new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        return resolver;
    }
}

package com.example.controller;

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

@RestController
@RequestMapping("/api/books")
public class BookController {

    @GetMapping
    public String list() {
        return "查询全部图书";
    }

    @GetMapping("/{id}")
    public String detail(@PathVariable Long id) {
        return "查询图书：" + id;
    }

    @PostMapping
    public String create() {
        return "新增图书";
    }

    @PutMapping("/{id}")
    public String update(@PathVariable Long id) {
        return "修改图书：" + id;
    }

    @DeleteMapping("/{id}")
    public String delete(@PathVariable Long id) {
        return "删除图书：" + id;
    }
}

package com.example.controller;

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

import java.util.Arrays;
import java.util.List;

@RestController
public class ParamController {

    @GetMapping("/search")
    public String search(
            @RequestParam(value = "keyword", required = false,
                          defaultValue = "spring") String keyword,
            @RequestParam(value = "tags", required = false)
                    List<String> tags) {
        return "关键词：" + keyword + "，标签：" + tags;
    }
}

// 请求示例
// GET /search?keyword=mvc&tags=a&tags=b
// 返回：关键词：mvc，标签：[a, b]

package com.example.entity;

import jakarta.validation.constraints.*;

public class User {
    @NotBlank(message = "姓名不能为空")
    private String name;

    @Min(value = 1, message = "年龄最小为 1")
    @Max(value = 150, message = "年龄最大为 150")
    private Integer age;

    @Email(message = "邮箱格式不正确")
    private String email;

    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; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

package com.example.controller;

import com.example.entity.User;
import jakarta.validation.Valid;
import org.springframework.web.bind.annotation.*;

@RestController
public class UserController {

    @PostMapping("/users")
    public User create(@Valid @RequestBody User user) {
        return user;
    }
}

package com.example.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class DataController {

    // 方式一：Model 参数
    @GetMapping("/data/model")
    public String withModel(Model model) {
        model.addAttribute("msg", "通过 Model 传递");
        return "show";
    }

    // 方式二：ModelAndView
    @GetMapping("/data/mav")
    public ModelAndView withModelAndView() {
        ModelAndView mv = new ModelAndView("show");
        mv.addObject("msg", "通过 ModelAndView 传递");
        return mv;
    }
}

<%-- show.jsp --%>
<%@ page contentType="text/html;charset=UTF-8" %>
<html>
<body><h1>${msg}</h1></body>
</html>

package com.example.entity;

public class Result {
    private int code;
    private String message;
    private Object data;

    public Result(int code, String message, Object data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }

    public static Result ok(Object data) {
        return new Result(200, "success", data);
    }

    public int getCode() { return code; }
    public void setCode(int code) { this.code = code; }
    public String getMessage() { return message; }
    public void setMessage(String message) { this.message = message; }
    public Object getData() { return data; }
    public void setData(Object data) { this.data = data; }
}

package com.example.controller;

import com.example.entity.Result;
import org.springframework.web.bind.annotation.*;

import java.util.Arrays;
import java.util.List;

@RestController
public class JsonController {

    @GetMapping("/api/list")
    public Result list() {
        List<String> data = Arrays.asList("Java", "Spring", "MVC");
        return Result.ok(data);
    }
}

package com.example.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class ForwardRedirectController {

    // 服务器内部转发：地址栏不变，一次请求
    @GetMapping("/go/forward")
    public String forward() {
        return "forward:/hello";
    }

    // 浏览器重定向：地址栏变化，两次请求
    @GetMapping("/go/redirect")
    public String redirect() {
        return "redirect:/hello";
    }

    // 带参数重定向（Flash 属性）
    @GetMapping("/go/redirect-attr")
    public String redirectWithAttr(
            RedirectAttributes attributes) {
        attributes.addFlashAttribute("tip", "操作成功");
        return "redirect:/hello";
    }
}

package com.example.controller;

import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.util.UUID;

@RestController
public class UploadController {

    @PostMapping("/upload")
    public String upload(@RequestParam("file") MultipartFile file)
            throws Exception {
        // 原始文件名
        String original = file.getOriginalFilename();
        // 生成唯一文件名防覆盖
        String ext = original.substring(original.lastIndexOf('.'));
        String filename = UUID.randomUUID().toString() + ext;

        File dir = new File("/tmp/upload");
        if (!dir.exists()) dir.mkdirs();
        file.transferTo(new File(dir, filename));
        return "上传成功：" + filename;
    }
}

# application.properties
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=20MB

package com.example.controller;

import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

@RestController
public class UploadController {

    @PostMapping("/upload/many")
    public List<String> uploadMany(
            @RequestParam("files") MultipartFile[] files)
            throws Exception {
        List<String> names = new ArrayList<>();
        for (MultipartFile file : files) {
            if (file.isEmpty()) continue;
            String name = System.currentTimeMillis()
                    + "_" + file.getOriginalFilename();
            file.transferTo(new File("/tmp/upload", name));
            names.add(name);
        }
        return names;
    }
}

<!-- 前端表单 -->
<form method="post" action="/upload/many"
      enctype="multipart/form-data">
  <input type="file" name="files" multiple/>
  <button>提交</button>
</form>

package com.example.controller;

import org.springframework.core.io.FileSystemResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.io.File;

@RestController
public class DownloadController {

    @GetMapping("/download/{name}")
    public ResponseEntity<FileSystemResource> download(
            @PathVariable String name) {
        File file = new File("/tmp/upload/" + name);
        if (!file.exists()) {
            return ResponseEntity.notFound().build();
        }
        HttpHeaders headers = new HttpHeaders();
        headers.add(HttpHeaders.CONTENT_DISPOSITION,
                "attachment; filename=" + name);
        return ResponseEntity.ok()
                .headers(headers)
                .contentType(MediaType.APPLICATION_OCTET_STREAM)
                .body(new FileSystemResource(file));
    }
}

package com.example.interceptor;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class LogInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        System.out.println("[1] preHandle 请求前");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler,
                           ModelAndView modelAndView) throws Exception {
        System.out.println("[2] postHandle 视图渲染前");
    }

    @Override
    public void afterCompletion(HttpServletRequest request,
                                HttpServletResponse response,
                                Object handler,
                                Exception ex) throws Exception {
        System.out.println("[3] afterCompletion 请求完成");
    }
}

package com.example.interceptor;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;

public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        Object user = request.getSession().getAttribute("loginUser");
        if (user == null) {
            response.sendRedirect("/login");
            return false;
        }
        return true;
    }
}

package com.example.config;

import com.example.interceptor.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.*;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns(
                        "/login",
                        "/register",
                        "/css/**",
                        "/js/**",
                        "/images/**");
    }
}

Filter 与 HandlerInterceptor 对比：

| 维度 | Filter | HandlerInterceptor |
|------|--------|--------------------|
| 规范 | Servlet 规范 | Spring MVC 框架 |
| 执行时机 | DispatcherServlet 之前 | 处理器执行前后 |
| 访问能力 | 只能操作 request/response | 可访问 Handler、ModelAndView |
| 依赖容器 | 无需 Spring 容器 | 依赖 Spring 容器 |
| 典型场景 | 编码、跨域、压缩 | 登录校验、权限、日志 |

执行链顺序：
Request → Filter → DispatcherServlet → Interceptor.preHandle
→ Controller → Interceptor.postHandle → 视图渲染
→ Interceptor.afterCompletion → Response

RESTful 用户资源接口设计：

| 方法 | 路径 | 语义 | 成功状态码 |
|------|------|------|-----------|
| GET  | /users | 查询用户列表 | 200 OK |
| GET  | /users/{id} | 查询单个用户 | 200 OK |
| POST | /users | 新增用户 | 201 Created |
| PUT  | /users/{id} | 全量更新 | 200 OK |
| PATCH| /users/{id} | 部分更新 | 200 OK |
| DELETE| /users/{id} | 删除用户 | 204 No Content |

设计要点：
1. 资源命名用名词复数，不用动词
2. 通过 HTTP 方法表达 CRUD
3. 使用嵌套表达关系：/users/{id}/orders
4. 分页：/users?page=1&size=10
5. 过滤：/users?status=active

package com.example.common;

public class BusinessException extends RuntimeException {
    private final int code;

    public BusinessException(int code, String message) {
        super(message);
        this.code = code;
    }

    public int getCode() { return code; }
}

package com.example.common;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(BusinessException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public Result<Void> handleBusiness(BusinessException e) {
        return Result.error(e.getCode(), e.getMessage());
    }

    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public Result<Void> handleException(Exception e) {
        return Result.error(500, "系统异常：" + e.getMessage());
    }
}

package com.example.controller;

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

// 方式一：路径版本（简单直观）
@RestController
@RequestMapping("/api/v1/users")
public class UserV1Controller {

    @GetMapping("/{id}")
    public String getUserV1(@PathVariable Long id) {
        return "v1 用户：" + id;
    }
}

// 方式二：请求头版本
@RestController
@RequestMapping("/api/users")
public class UserV2Controller {

    @GetMapping(value = "/{id}", headers = "X-API-Version=2")
    public String getUserV2(@PathVariable Long id) {
        return "v2 用户：" + id;
    }
}

// 调用示例：
// GET /api/v1/users/1 → v1
// GET /api/users/1 + X-API-Version: 2 → v2

package com.example.entity;

import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;

public class User {
    private String name;
    private Integer age;

    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthday;

    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; }
    public Date getBirthday() { return birthday; }
    public void setBirthday(Date birthday) { this.birthday = birthday; }
}

package com.example.controller;

import com.example.entity.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

@Controller
public class FormController {

    @GetMapping("/form")
    public String form() {
        return "form";
    }

    @PostMapping("/form/submit")
    public String submit(@ModelAttribute User user, Model model) {
        model.addAttribute("user", user);
        return "result";
    }
}

<!-- form.jsp -->
<form method="post" action="/form/submit">
  姓名：<input name="name"/><br/>
  年龄：<input name="age"/><br/>
  生日：<input name="birthday" placeholder="2024-01-01"/><br/>
  <button>提交</button>
</form>

package com.example.controller;

import org.springframework.beans.propertyeditors.StringTrimmerEditor;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.*;

import java.beans.PropertyEditorSupport;

@Controller
public class BaseController {

    @InitBinder
    public void initBinder(WebDataBinder binder) {
        // 去除字符串前后空格
        binder.registerCustomEditor(String.class,
                new StringTrimmerEditor(true));

        // 自定义敏感词过滤编辑器
        binder.registerCustomEditor(String.class, "comment",
                new PropertyEditorSupport() {
                    @Override
                    public void setAsText(String text) {
                        setValue(text == null ? "" :
                                text.replace("敏感词", "***"));
                    }
                });
    }
}

package com.example.controller;

import com.example.entity.User;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.web.bind.annotation.*;

import java.util.Date;
import java.util.List;

// User 增加序列化格式
class UserVo {
    public String name;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    public Date createTime;
}

@RestController
public class JsonBindController {

    // 接收 JSON 数组
    @PostMapping("/api/batch")
    public int batch(@RequestBody List<User> users) {
        return users.size();
    }

    // 返回 JSON 日期格式化
    @GetMapping("/api/now")
    public UserVo now() {
        UserVo vo = new UserVo();
        vo.name = "demo";
        vo.createTime = new Date();
        return vo;
    }
}

// POST /api/batch
// [{"name":"a","age":20},{"name":"b","age":21}] → 2

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

<!-- src/main/resources/templates/hello.html -->
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>Hello</title></head>
<body>
  <h1 th:text="${msg}">默认文本</h1>
  <p>当前时间：<span th:text="${#dates.format(now, 'yyyy-MM-dd')}"></span></p>
</body>
</html>

package com.example.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import java.util.Date;

@Controller
public class PageController {

    @GetMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("msg", "Hello Thymeleaf");
        model.addAttribute("now", new Date());
        return "hello";
    }
}

package com.example.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import java.util.Arrays;
import java.util.List;

@Controller
public class UserPageController {

    @GetMapping("/users/page")
    public String page(Model model) {
        List<String> users = Arrays.asList("张三", "李四", "王五");
        model.addAttribute("users", users);
        return "user-list";
    }
}

<!-- templates/user-list.html -->
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<body>
  <h1>用户列表</h1>
  <ul>
    <li th:each="u, st : ${users}"
        th:class="${st.odd} ? 'odd' : 'even'"
        th:text="|${st.count}. ${u}|"></li>
  </ul>
  <p th:if="${#lists.isEmpty(users)}">暂无用户</p>
  <p th:unless="${#lists.isEmpty(users)}">共 3 位用户</p>
</body>
</html>

<!-- templates/fragments/header.html -->
<header th:fragment="nav(title)">
  <nav>
    <span th:text="${title}">默认标题</span>
    <a th:href="@{/}">首页</a>
    <a th:href="@{/users/page}">用户</a>
    <a th:href="@{/about}">关于</a>
  </nav>
</header>

<!-- templates/user-list.html -->
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <title>用户列表</title>
</head>
<body>
  <div th:insert="~{fragments/header :: nav('用户管理')}"></div>

  <h1>用户列表</h1>
  <ul>
    <li th:each="u : ${users}">
      <a th:href="@{/users/{id}(id=${u.id})}"
         th:text="${u.name}">姓名</a>
    </li>
  </ul>
</body>
</html>

package com.example.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AsyncConfig {
}

package com.example.service;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class MailService {

    @Async
    public void sendMail(String to, String content) throws InterruptedException {
        // 模拟耗时 3 秒的邮件发送
        Thread.sleep(3000);
        System.out.println("已发送邮件给：" + to);
    }
}

package com.example.controller;

import com.example.service.MailService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AsyncController {

    private final MailService mailService;

    public AsyncController(MailService mailService) {
        this.mailService = mailService;
    }

    @GetMapping("/send-mail")
    public String send() {
        mailService.sendMail("a@b.com", "Hello");
        return "邮件已进入发送队列（立即返回）";
    }
}

package com.example.controller;

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

@RestController
@CrossOrigin(origins = "http://localhost:5173",
             maxAge = 3600)
public class CorsController {

    @GetMapping("/api/info")
    public String info() {
        return "跨域数据";
    }

    // 方法级配置优先级更高
    @PostMapping("/api/save")
    @CrossOrigin(origins = {"http://localhost:5173",
                            "https://example.com"},
                 methods = {RequestMethod.POST})
    public String save() {
        return "已保存";
    }
}

package com.example.controller;

import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import java.io.IOException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@RestController
public class SseController {

    @GetMapping(value = "/stream", produces = "text/event-stream")
    public SseEmitter stream() {
        SseEmitter emitter = new SseEmitter(30_000L);
        ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
        pool.scheduleAtFixedRate(() -> {
            try {
                emitter.send(SseEmitter.event()
                        .name("tick")
                        .data("当前时间：" + System.currentTimeMillis()));
            } catch (IOException e) {
                emitter.completeWithError(e);
                pool.shutdown();
            }
        }, 0, 1, TimeUnit.SECONDS);
        return emitter;
    }
}

spring-boot-starter-web 自动配置内容：
- DispatcherServlet：前端控制器
- HandlerMapping / HandlerAdapter
- Jackson JSON 序列化
- 静态资源映射（classpath:/static/）
- 错误页处理（/error）
- 内嵌 Tomcat
- ContentNegotiation（内容协商）

# 常用 MVC 属性
spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp
spring.mvc.static-path-pattern=/static/**

# 自定义增强：实现 WebMvcConfigurer 而不是
# 使用 @EnableWebMvc（会关闭自动配置）

package com.example.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class ResourceConfig implements WebMvcConfigurer {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        // 本地磁盘图片目录映射
        registry.addResourceHandler("/files/**")
                .addResourceLocations("file:/data/upload/");

        // 自定义 classpath 静态目录
        registry.addResourceHandler("/assets/**")
                .addResourceLocations("classpath:/assets/");
    }
}

// 访问：http://localhost:8080/files/a.jpg
// 实际读取：/data/upload/a.jpg

package com.example.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.List;

@Configuration
public class ConverterConfig implements WebMvcConfigurer {

    @Override
    public void extendMessageConverters(
            List<HttpMessageConverter<?>> converters) {
        // 添加 Jackson XML 转换器
        converters.add(new MappingJackson2XmlHttpMessageConverter());
    }
}

// 引入依赖
// <dependency>
//   <groupId>com.fasterxml.jackson.dataformat</groupId>
//   <artifactId>jackson-dataformat-xml</artifactId>
// </dependency>

// 请求头 Accept: application/xml → 返回 XML
// 请求头 Accept: application/json → 返回 JSON

package com.example.controller;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@WebMvcTest(HelloController.class)
public class HelloControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void helloReturnsOk() throws Exception {
        mockMvc.perform(get("/hello"))
                .andExpect(status().isOk())
                .andExpect(content().string("Hello, Spring MVC!"));
    }

    @Test
    void listReturnsJson() throws Exception {
        mockMvc.perform(get("/api/list"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.code").value(200));
    }
}

# application.properties
# Gzip 压缩
server.compression.enabled=true
server.compression.mime-types=application/json,text/html,text/css,application/javascript
server.compression.min-response-size=1024

# 静态资源缓存
spring.web.resources.cache.cachecontrol.max-age=30d
spring.web.resources.cache.cachecontrol.cache-public=true

# 自定义响应头（拦截器中设置）
package com.example.config;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;

public class CacheInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) {
        response.setHeader("X-Content-Type-Options", "nosniff");
        return true;
    }
}

# Tomcat 线程池调优
server:
  port: 8080
  tomcat:
    threads:
      max: 200          # 最大工作线程数（默认 200）
      min-spare: 20     # 最小空闲线程数
    max-connections: 10000   # 最大连接数
    accept-count: 100        # 等待队列长度
    connection-timeout: 20000

# 压测验证
ab -n 10000 -c 100 http://localhost:8080/hello

# 调优原则：
# - 线程数不宜过大，避免上下文切换开销
# - 结合 QPS/RT 指标迭代调整
# - 数据库连接池上限要匹配（默认 HikariCP 10）

package com.example.entity;

public class Book {
    private Long id;
    private String title;
    private String author;
    private Double price;
    private Integer stock;

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    public String getAuthor() { return author; }
    public void setAuthor(String author) { this.author = author; }
    public Double getPrice() { return price; }
    public void setPrice(Double price) { this.price = price; }
    public Integer getStock() { return stock; }
    public void setStock(Integer stock) { this.stock = stock; }
}

package com.example.repository;

import com.example.entity.Book;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class BookRepository {

    private final JdbcTemplate jdbcTemplate;

    public BookRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public List<Book> findAll() {
        return jdbcTemplate.query(
            "SELECT * FROM book",
            (rs, i) -> {
                Book b = new Book();
                b.setId(rs.getLong("id"));
                b.setTitle(rs.getString("title"));
                b.setAuthor(rs.getString("author"));
                b.setPrice(rs.getDouble("price"));
                b.setStock(rs.getInt("stock"));
                return b;
            });
    }
}

package com.example.controller;

import com.example.entity.Book;
import com.example.repository.BookRepository;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/books")
public class BookController {

    private final BookRepository repository;

    public BookController(BookRepository repository) {
        this.repository = repository;
    }

    @GetMapping
    public PageResult<Book> page(
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(defaultValue = "10") int size,
            @RequestParam(required = false) String keyword) {
        List<Book> list = repository.search(keyword,
                (page - 1) * size, size);
        long total = repository.count(keyword);
        return new PageResult<>(page, size, total, list);
    }
}

class PageResult<T> {
    public int page;
    public int size;
    public long total;
    public List<T> list;

    public PageResult(int page, int size, long total, List<T> list) {
        this.page = page;
        this.size = size;
        this.total = total;
        this.list = list;
    }
}

package com.example.service;

import com.example.common.BusinessException;
import com.example.repository.BookRepository;
import com.example.repository.BorrowRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BorrowService {

    private final BookRepository bookRepository;
    private final BorrowRepository borrowRepository;

    public BorrowService(BookRepository bookRepository,
                         BorrowRepository borrowRepository) {
        this.bookRepository = bookRepository;
        this.borrowRepository = borrowRepository;
    }

    @Transactional(rollbackFor = Exception.class)
    public void borrow(Long bookId, Long userId) {
        // 原子扣减：库存大于 0 才扣减成功，防止超卖
        int rows = bookRepository.deductStock(bookId);
        if (rows == 0) {
            throw new BusinessException(400, "库存不足");
        }
        // 生成借阅记录
        borrowRepository.insert(bookId, userId);
    }
}

// SQL
// UPDATE book SET stock = stock - 1
//  WHERE id = #{id} AND stock > 0