企业级Spring MVC高级主题与实用技术讲解

企业级Spring MVC高级主题与实用技术讲解

本手册旨在为具备Spring MVC基础的初学者，体系地讲解企业级应用开辟中常用的高级主题和实用技术，涵盖RESTful API、同一异常处理惩罚、拦截器、文件处理惩罚、国际化、前端集成及Spring Security基础。内容联合JavaConfig和代码示例进行分析，并尝试与之前的图书管理体系案例和基础教程内容衔接。
1. RESTful API 设计与实践

RESTful是一种架构风格，而非强制尺度。它基于HTTP协议，通过同一的接口对资源进行操纵，具有无状态、客户端-服务器分离等特点。在今世企业应用中，特别是在前后端分离架构下，RESTful API是常用的后端接口风格。
焦点设计原则

• 资源 (Resource): Web上的焦点概念，指代某个事物（如用户、图书）。资源通过URI (同一资源标识符) 来唯一标识。
  
  
  
  • 示例URI：/users, /books/123
    
  
  
• URI: 应简洁、直观，描述资源而非操纵。使用名词复数表示集合，名词单数表示个体。避免在URI中使用动词。
  
• HTTP 方法 (HTTP Methods): 使用HTTP方法来表示对资源的操纵：
  
  
  
  • GET: 获取资源。安全且幂等。
    
  • POST: 创建新资源或执行非幂等操纵。
    
  • PUT: 更新或替换资源。幂等。
    
  • DELETE: 删除资源。幂等。
    
  • PATCH: 部分更新资源。
    
  
  
• 状态码 (Status Codes): 使用尺度的HTTP状态码表示请求的处理惩罚结果：
  
  
  
  • 2xx (Success): 200 OK, 201 Created, 204 No Content
    
  • 3xx (Redirection): 301 Moved Permanently, 302 Found
    
  • 4xx (Client Error): 400 Bad Request, 401 Unauthorized, 403 Forbidden, 404 Not Found, 405 Method Not Allowed
    
  • 5xx (Server Error): 500 Internal Server Error
    
  
  
• 表述 (Representation): 资源通过某种格式（如JSON、XML）来表述其状态。客户端和服务器通过这些表述进行数据交换。JSON是如今最流行的格式。
  
• 无状态 (Stateless): 服务器不存储客户端的上下文信息。每个请求都包罗处理惩罚该请求所需的所有信息。
  

Spring 构建 RESTful 服务

Spring MVC通过一系列注解简化RESTful服务的构建。

• @RestController: 标记一个类是RESTful控制器。它是@Controller和@ResponseBody的组合。
  
• @ResponseBody: 标记方法返回值直接写入HTTP响应体，不作为视图名。Spring MVC会根据Accept头和HttpMessageConverter将返回值转换为相应格式（如JSON）。
  
• @RequestBody: 标记方法参数来自HTTP请求体。Spring MVC会根据Content-Type头和HttpMessageConverter将请求体内容转换为方法参数对象。
  
• @GetMapping, @PostMapping, @PutMapping, @DeleteMapping: 对应HTTP方法的请求映射注解，是@RequestMapping的快捷方式。
  
• @PathVariable: 获取URI路径中的变量。
  
• ResponseEntity: 封装响应的完整信息，包括响应体、状态码和头部。可以在方法中返回ResponseEntity来正确控制响应。
  

1. +-------------+     +-----------------+     +---------------------+     +-------------+
2. | User/Client | --> | DispatcherServlet | --> | RequestMappingHandler | --> | Controller  |
3. | (Frontend)  |     +-----------------+     |       Adapter       |     +------v------+
4. |             |     |     HTTP Req    |     +-----------+---------+            | Process Logic
5. |             |     |                 |                 |                      | (Service/Repo)
6. |             |     | GET /api/books/1|                 | Call Method          |
7. |             |     | POST /api/books |                 | with @RequestBody    | Return Object
8. |             |     | { JSON Data }   |                 |                      |
9. +-------------+     +-----------------+     +-----------+---------+     +------^------+
10.                            |                      | Convert to/from JSON   |
11.                            | Look up Handler      | (@RequestBody /        | HttpMessageConverter
12.                            |                      | @ResponseBody)         |
13.                            v                      |                      |
14.                      +-----------------+     +---------------------+     +------+------+
15.                      | HandlerMapping  |     | HttpMessageConverter| <--> | JSON/XML  |
16.                      +-----------------+     +---------------------+     +------+------+
17.                            | Find Handler         | Serialize/Deserialize        | Write to Response
18.                            +----------------------+------------------------------+

复制代码

代码示例 (基于图书管理体系，添加 REST API)

假设在图书管理体系中有Book实体和BookService。新增一个BookRestController：

1. package com.yourcompany.bookmanagement.controller;
3. import com.yourcompany.bookmanagement.entity.Book;
4. import com.yourcompany.bookmanagement.exception.BookNotFoundException; // 复用之前的异常
5. import com.yourcompany.bookmanagement.service.BookService; // 复用之前的 Service
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.http.HttpStatus;
8. import org.springframework.http.ResponseEntity;
9. import org.springframework.web.bind.annotation.*;
11. import java.util.List;
12. import java.util.Optional;
14. @RestController // @RestController = @Controller + @ResponseBody
15. @RequestMapping("/api/v1/books") // REST API 基础路径，v1 表示版本
16. public class BookRestController {
18.     private final BookService bookService;
20.     @Autowired
21.     public BookRestController(BookService bookService) {
22.         this.bookService = bookService;
23.     }
25.     // 获取所有图书列表
26.     // GET /api/v1/books
27.     @GetMapping
28.     public List<Book> getAllBooks() {
29.         // 返回 List 会自动通过 HttpMessageConverter 转换为 JSON 数组
30.         return bookService.findAllBooks();
31.     }
33.     // 获取特定图书详情
34.     // GET /api/v1/books/{id}
35.     @GetMapping("/{id}")
36.     public ResponseEntity<Book> getBookById(@PathVariable Long id) {
37.         Optional<Book> book = bookService.findBookById(id);
38.         // 使用 ResponseEntity 控制状态码
39.         return book.map(value -> new ResponseEntity<>(value, HttpStatus.OK)) // 找到则返回 200 OK
40.                    .orElseThrow(() -> new BookNotFoundException(id)); // 找不到则抛出异常，由全局异常处理器处理
41.     }
43.     // 创建新图书
44.     // POST /api/v1/books
45.     @PostMapping
46.     @ResponseStatus(HttpStatus.CREATED) // 创建成功返回 201 Created
47.     public Book createBook(@RequestBody Book book) { // @RequestBody 将请求体 (JSON) 转换为 Book 对象
48.         // 校验等逻辑可以在 Service 层或通过 Bean Validation 实现 (需要额外配置)
49.         return bookService.saveBook(book); // 保存并返回新创建的图书 (可能包含生成的 ID)
50.     }
52.     // 更新图书
53.     // PUT /api/v1/books/{id}
54.     @PutMapping("/{id}")
55.     public ResponseEntity<Book> updateBook(@PathVariable Long id, @RequestBody Book book) {
56.         // 实际更新逻辑需要先查找，然后更新字段，最后保存
57.         Optional<Book> existingBookOptional = bookService.findBookById(id);
58.         if (existingBookOptional.isPresent()) {
59.             Book existingBook = existingBookOptional.get();
60.             // 假设只更新标题和作者，实际应根据需求更新所有字段
61.             existingBook.setTitle(book.getTitle());
62.             existingBook.setAuthor(book.getAuthor());
63.             existingBook.setIsbn(book.getIsbn());
64.             existingBook.setPublicationDate(book.getPublicationDate());
65.             Book updatedBook = bookService.saveBook(existingBook);
66.             return new ResponseEntity<>(updatedBook, HttpStatus.OK); // 返回更新后的图书和 200 OK
67.         } else {
68.             throw new BookNotFoundException(id); // 找不到则抛异常
69.         }
70.     }
72.     // 删除图书
73.     // DELETE /api/v1/books/{id}
74.     @DeleteMapping("/{id}")
75.     @ResponseStatus(HttpStatus.NO_CONTENT) // 删除成功返回 204 No Content
76.     public void deleteBook(@PathVariable Long id) {
77.         // 可以先检查是否存在，再删除
78.         Optional<Book> book = bookService.findBookById(id);
79.         if (!book.isPresent()) {
80.              throw new BookNotFoundException(id); // 不存在则抛异常
81.         }
82.         bookService.deleteBookById(id); // 调用 Service 删除
83.     }
84. }

复制代码

JSON 数据交互的最佳实践

• 一致的格式: 保持请求和响应JSON结构的命名规范、日期格式等一致。
  
• 符合的 Content-Type: 请求时使用 application/json，响应时服务器返回 application/json。Spring MVC会根据produces和consumes参数、Accept头自动处理惩罚。
  
• 字段命名: 推荐使用小驼峰命名法 (camelCase)，与JavaScript风俗一致。Jackson库默认支持。
  
• 错误响应: 使用同一的错误响应格式，包罗状态码、错误信息等（详见下一节）。
  
• 分页/排序: 对于列表接口，通过查询参数转达分页 (page, size) 和排序 (sort, sortBy) 信息。Spring Data JPA的Pageable很适合。
  
• 版本控制: 在URI (/api/v1/books) 或Header (X-API-Version) 中表现版本，便于API演进。URI版本控制更直观常用。
  
• HATEOAS: (Hypermedia as the Engine of Application State) 一种更高级的RESTful实践，要求资源表述中包罗指向相关资源的链接，使客户端可以无需硬编码URI就能导航API。Spring HATEOAS项目提供了支持。对于初学者，明白概念即可，实现相对复杂，通常在API成熟阶段考虑。
  

版本控制策略

• URI 版本 (URI Versioning): 将版本号放入URI路径中，如 /api/v1/books。最常用且直观。缺点是URI会随着版本变革。
  
• Header 版本 (Header Versioning): 将版本信息放入请求头，如 Accept: application/vnd.myapi.v1+json 或自界说头 X-API-Version: 1.0。URI保持稳定，但客户端调用稍复杂。
  
• 参数版本 (Query Parameter Versioning): 将版本作为查询参数，如 /api/books?version=1.0。不推荐，不符合RESTful风格。
  

选择哪种取决于项目需求和团队偏好，URI版本控制对初学者最友爱。
2. 同一异常处理惩罚机制

精良的异常处理惩罚机制能够提拔应用的健壮性和用户体验。Spring MVC提供了机动的方式实现同一的异常处理惩罚。
使用 @ControllerAdvice 和 @ExceptionHandler

• @ControllerAdvice: 标记一个类是全局的控制器增强器。Spring会扫描这个类，并将其中的@ExceptionHandler, @ModelAttribute, @InitBinder等方法应用到所有（或指定范围）的@Controller和@RestController上。这实现了全局性。
  
• @ExceptionHandler: 标记一个方法用于处理惩罚特定类型的异常。当Controller方法抛出@ExceptionHandler指定类型的异常时，Spring MVC会调用匹配的异常处理惩罚方法。这实现了针对性。
  

代码示例 (基于图书管理体系)

图书管理体系案例中的GlobalExceptionHandler和BookNotFoundException就是很好的示例。

1. package com.yourcompany.bookmanagement.exception;
3. import org.slf4j.Logger;
4. import org.slf4j.LoggerFactory;
5. import org.springframework.http.HttpStatus;
6. import org.springframework.http.ResponseEntity; // 用于 REST API 返回 JSON
7. import org.springframework.web.bind.annotation.ControllerAdvice;
8. import org.springframework.web.bind.annotation.ExceptionHandler;
9. import org.springframework.web.bind.annotation.ResponseBody; // 用于 REST API
10. import org.springframework.web.bind.annotation.ResponseStatus;
11. import org.springframework.web.servlet.ModelAndView; // 用于返回视图
13. // @ControllerAdvice 应用于所有 Controller
14. @ControllerAdvice
15. public class GlobalExceptionHandler {
17.     private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
19.     // --- 针对返回视图的异常处理 (如图书管理系统案例中的 HTML 页面请求) ---
20.     // 处理 BookNotFoundException 异常，返回 404 视图
21.     @ExceptionHandler(BookNotFoundException.class)
22.     @ResponseStatus(HttpStatus.NOT_FOUND) // 设置响应状态码为 404
23.     public ModelAndView handleBookNotFoundForView(BookNotFoundException ex) {
24.         logger.warn("Book not found: " + ex.getMessage());
25.         ModelAndView mav = new ModelAndView("error/404"); // 返回错误视图 error/404.html
26.         mav.addObject("message", ex.getMessage()); // 将错误信息添加到 Model
27.         return mav;
28.     }
30.     // 处理所有其他未捕获的 Exception，返回 500 视图
31.     @ExceptionHandler(Exception.class)
32.     @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR) // 设置响应状态码为 500
33.     public ModelAndView handleAllExceptionsForView(Exception ex) {
34.         logger.error("Internal Server Error: ", ex);
35.         ModelAndView mav = new ModelAndView("error/500"); // 返回错误视图 error/500.html
36.         mav.addObject("message", "Internal Server Error. Please try again later.");
37.         return mav;
38.     }
41.     // --- 针对返回 JSON 的异常处理 (如 RESTful API 请求) ---
42.     // 可以定义一个返回 JSON 格式的异常处理，但需要区分请求类型
43.     // 或者更简单的做法是，如果你的 Controller 是 @RestController，异常处理方法也返回 @ResponseBody
44.     // 这里以 BookNotFoundException 为例，演示返回 JSON 错误
45.     @ExceptionHandler(BookNotFoundException.class)
46.     @ResponseStatus(HttpStatus.NOT_FOUND) // 设置响应状态码为 404
47.     @ResponseBody // 直接写入响应体，由 HttpMessageConverter 处理
48.     public ErrorResponse handleBookNotFoundForRest(BookNotFoundException ex) {
49.         logger.warn("Book not found for REST request: " + ex.getMessage());
50.         // 返回统一的 JSON 错误格式
51.         return new ErrorResponse(HttpStatus.NOT_FOUND.value(), ex.getMessage(), System.currentTimeMillis());
52.     }
54.     // 处理 @RequestBody 参数校验失败异常 (MethodArgumentNotValidException)
55.     // 通常在 REST API 中发生
56.     @ExceptionHandler(org.springframework.web.bind.MethodArgumentNotValidException.class)
57.     @ResponseStatus(HttpStatus.BAD_REQUEST) // 400 Bad Request
58.     @ResponseBody
59.     public ErrorResponse handleValidationExceptions(org.springframework.web.bind.MethodArgumentNotValidException ex) {
60.         // 提取所有校验错误信息
61.         String errorMessage = ex.getBindingResult().getFieldErrors().stream()
62.                 .map(error -> error.getField() + ": " + error.getDefaultMessage())
63.                 .collect(java.util.stream.Collectors.joining(", "));
65.         logger.warn("Validation failed: " + errorMessage);
66.         return new ErrorResponse(HttpStatus.BAD_REQUEST.value(), "Validation Failed: " + errorMessage, System.currentTimeMillis());
67.     }
69.     // 统一错误响应格式 (POJO)
70.     public static class ErrorResponse {
71.         private int status;
72.         private String message;
73.         private long timestamp;
75.         public ErrorResponse(int status, String message, long timestamp) {
76.             this.status = status;
77.             this.message = message;
78.             this.timestamp = timestamp;
79.         }
81.         // Getters for Jackson serialization
82.         public int getStatus() { return status; }
83.         public String getMessage() { return message; }
84.         public long getTimestamp() { return timestamp; }
85.     }
87.     // 自定义异常类 (同图书管理系统案例)
88.     // package com.yourcompany.bookmanagement.exception;
89.     // public class BookNotFoundException extends RuntimeException {
90.     //     public BookNotFoundException(Long id) {
91.     //         super("Book not found with ID: " + id);
92.     //     }
93.     // }
94. }

复制代码

分析：

• 同一个@ControllerAdvice类中，可以界说多个@ExceptionHandler方法处理惩罚差别类型的异常。
  
• @ExceptionHandler方法的参数可以是抛出的异常对象，返回值可以是ModelAndView, String (视图名或重定向), @ResponseBody 返回值, ResponseEntity等。
  
• 通过@ResponseStatus可以设置响应的HTTP状态码。
  
• 为了同时支持返回视图和返回JSON的异常处理惩罚，可以根据请求的Accept头或路径 (/api/**) 进行区分处理惩罚，大概如示例所示，为同一种异常界说两个@ExceptionHandler方法（Spring会根据返回类型等选择更匹配的谁人，大概可以通过@RequestMapping(produces = ...)等进一步限定）。在全RESTful API应用中，通常只返回JSON。
  

自界说异常类

根据业务需求界说自界说异常类，继承自RuntimeException（非查抄型异常）或Exception（查抄型异常）。非查抄型异常通常用于表示编程错误或运行时情况问题，查抄型异常用于表示可预期的、必要调用方显式处理惩罚的业务问题。在Spring的事件管理中，默认只对非查抄型异常进行回滚。

1. package com.yourcompany.bookmanagement.exception;
3. // 业务异常示例：图书库存不足
4. public class InsufficientStockException extends RuntimeException {
5.     private Long bookId;
6.     private int requested;
7.     private int available;
9.     public InsufficientStockException(Long bookId, int requested, int available) {
10.         super("Book " + bookId + " stock insufficient. Requested: " + requested + ", Available: " + available);
11.         this.bookId = bookId;
12.         this.requested = requested;
13.         this.available = available;
14.     }
16.     // Getters for error details
17.     public Long getBookId() { return bookId; }
18.     public int getRequested() { return requested; }
19.     public int getAvailable() { return available; }
20. }

复制代码

然后在@ControllerAdvice中添加对应的@ExceptionHandler处理惩罚方法。
异常处理惩罚策略

• 业务异常: 对于应用步伐的正常流程中大概发生的、可预期的错误（如用户不存在、库存不敷），界说特定的自界说异常。在Service层或Controller层捕获或抛出，由全局异常处理惩罚器返回友爱的错误信息（给用户）和详细的错误代码（给前端/客户端）。
  
• 体系异常: 对于意料之外的错误（如数据库毗连失败、空指针异常），通常抛出RuntimeException或其子类。全局异常处理惩罚器应记录详细日志（给开辟者），并返回通用的错误提示（给用户）和500状态码。避免在生产情况泄露敏感的异常堆栈信息。
  
• 返回格式: 对于面向用户的Web页面，返回错误页面（如404.html, 500.html）。对于RESTful API，返回同一结构的JSON错误响应。
  

3. Spring MVC 拦截器 (Interceptor)

拦截器答应你在请求到达Controller之前、Controller处理惩罚之后、以及整个请求处理惩罚完成后执行自界说逻辑。它工作在DispatcherServlet内部，比Servlet Filter更靠近Spring MVC的焦点流程，能够访问Handler（Controller方法）和ModelAndView等信息。
概念、生命周期与 Filter 的区别

• 概念: 拦截器是Spring MVC提供的请求处理惩罚拦截机制。
  
• 生命周期: 一个请求经过拦截器链的三个阶段：
  
  
  • preHandle(): 在Controller方法执行之前调用。假如返回true，继承执行后续拦截器和Controller；假如返回false，中断整个请求处理惩罚流程。常用于认证、权限校验、日志记录。
    
  • postHandle(): 在Controller方法执行之后，视图渲染之前调用。可以访问ModelAndView，用于修改模型数据、视图名等。注意：假如Controller方法抛出异常，postHandle不会被调用。
    
  • afterCompletion(): 在整个请求处理惩罚完成之后（包括视图渲染完成后），无论是否发生异常，都会调用。用于资源清算等。
    
  
  
• 与 Filter 的区别:
  
  
  
  • Filter是Servlet规范的一部分，工作在Servlet容器层面，在DispatcherServlet之前执行，无法访问Spring MVC的上下文（如Handler）。实用于字符编码、会话管理、静态资源处理惩罚等。
    
  • Interceptor是Spring MVC框架的一部分，工作在DispatcherServlet内部，HandlerMapping之后。能够访问Handler、ModelAndView、Spring容器中的Bean等。实用于更细粒度的、与业务逻辑关联的拦截，如认证、权限、性能监控、日志。
    
  
  

创建和配置拦截器

• 创建拦截器类: 实现HandlerInterceptor接口。该接口界说了preHandle, postHandle, afterCompletion方法。大概，假如只必要实现部分方法，可以继承已废弃的HandlerInterceptorAdapter，但如今推荐直接实现HandlerInterceptor并使用接口的默认方法。
  
• 配置拦截器: 在实现WebMvcConfigurer接口的配置类中，通过重写addInterceptors()方法注册拦截器。
  

代码示例 (基于图书管理体系)

图书管理体系案例中的AuthInterceptor是认证拦截器的示例。

1. package com.yourcompany.bookmanagement.interceptor;
3. import org.springframework.web.servlet.HandlerInterceptor; // 引入接口
4. import org.springframework.web.servlet.ModelAndView;
6. import javax.servlet.http.HttpServletRequest;
7. import javax.servlet.http.HttpServletResponse;
8. import javax.servlet.http.HttpSession;
10. public class AuthInterceptor implements HandlerInterceptor { // 实现 HandlerInterceptor 接口
12.     // 在 Controller 方法执行前调用
13.     @Override
14.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
15.         String requestURI = request.getRequestURI();
16.         System.out.println("AuthInterceptor: Intercepting request: " + requestURI);
18.         HttpSession session = request.getSession();
19.         Object user = session.getAttribute("loggedInUser"); // 检查 Session 中是否有名为 "loggedInUser" 的属性
21.         if (user != null) {
22.             // 用户已登录，放行
23.             System.out.println("AuthInterceptor: User is logged in.");
24.             return true; // 继续执行后续拦截器或 Controller
25.         } else {
26.             // 用户未登录，重定向到登录页面
27.             System.out.println("AuthInterceptor: User is NOT logged in. Redirecting to login page.");
28.             // 获取 contextPath，避免硬编码应用名称
29.             response.sendRedirect(request.getContextPath() + "/login");
30.             return false; // 阻止当前请求继续处理
31.         }
32.     }
34.     // 在 Controller 方法执行后，视图渲染前调用
35.     @Override
36.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
37.         // 可以在这里对 Model 或 View 进行操作
38.         // System.out.println("AuthInterceptor postHandle...");
39.     }
41.     // 在整个请求处理完成后调用
42.     @Override
43.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
44.         // 用于资源清理等
45.         // System.out.println("AuthInterceptor afterCompletion...");
46.     }
47. }

复制代码

拦截器配置 (WebMvcConfig.java):

1. package com.yourcompany.bookmanagement.config;
3. import com.yourcompany.bookmanagement.interceptor.AuthInterceptor; // 引入拦截器类
4. import org.springframework.context.annotation.Bean;
5. import org.springframework.context.annotation.Configuration;
6. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
7. import org.springframework.web.servlet.config.annotation.InterceptorRegistry; // 引入 InterceptorRegistry
8. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; // 引入 WebMvcConfigurer
10. @Configuration
11. @EnableWebMvc
12. // @ComponentScan...
13. public class WebMvcConfig implements WebMvcConfigurer { // 实现 WebMvcConfigurer
15.     // 将拦截器注册为 Spring Bean
16.     @Bean
17.     public AuthInterceptor authInterceptor() {
18.         return new AuthInterceptor();
19.     }
21.     // 重写 addInterceptors 方法配置拦截器
22.     @Override
23.     public void addInterceptors(InterceptorRegistry registry) {
24.         registry.addInterceptor(authInterceptor()) // 添加拦截器实例
25.                 .addPathPatterns("/**") // 配置需要拦截的路径模式，"/**" 表示拦截所有请求
26.                 .excludePathPatterns("/login", "/logout", "/resources/**", "/webjars/**"); // 配置排除的路径模式，登录、注销、静态资源通常需要排除
27.     }
29.     // ... 其他配置，如 ViewResolver, MultipartResolver 等
30. }

复制代码

典型应用场景

• 日志记录: 在preHandle记录请求信息，在afterCompletion记录处理惩罚时间、响应状态等。
  
• 权限校验: 在preHandle查抄用户是否已登录、是否有权访问当前资源。未通过则重定向或返回错误。
  
• 请求预处理惩罚: 在preHandle或postHandle设置一些通用的请求属性、上下文信息等。
  
• 性能监控: 在preHandle记录请求开始时间，在afterCompletion计算并记录总耗时。
  

4. 文件上传与下载

Spring MVC对文件上传和下载提供了内置支持，特别是联合Servlet 3.0+的MultipartRequest API。
文件上传

• 配置 MultipartResolver: Spring MVC必要一个MultipartResolver Bean来解析multipart/form-data请求。
  
  
  
  • StandardServletMultipartResolver: 基于Servlet 3.0+ 尺度。推荐使用，无需额外依靠。
    
  • CommonsMultipartResolver: 基于Apache Commons FileUpload库。必要添加commons-fileupload依靠。
    
  
  
• Controller 中接收文件: 在Controller方法中使用@RequestParam MultipartFile参数接收上传的文件。MultipartFile接口提供了获取文件名、内容类型、文件大小、字节流等方法。
  
• 文件大小限定、类型校验: 可以在MultipartResolver中配置总大小和单个文件大小限定。文件类型校验通常在Controller或Service中根据file.getContentType()和file.getOriginalFilename()进行。
  
• 存储上传文件: 获取到MultipartFile后，可以使用transferTo(File dest)方法将其保存到文件体系，大概获取getInputStream()/getBytes()写入数据库、云存储等。
  

代码示例 (文件上传)

WebMvcConfig.java 配置 StandardServletMultipartResolver:

1. package com.yourcompany.bookmanagement.config;
3. import org.springframework.context.annotation.Bean;
4. import org.springframework.context.annotation.Configuration;
5. import org.springframework.web.multipart.MultipartResolver; // 引入接口
6. import org.springframework.web.multipart.support.StandardServletMultipartResolver; // 引入 Standard 实现
7. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
8. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
10. @Configuration
11. @EnableWebMvc
12. // @ComponentScan...
13. public class WebMvcConfig implements WebMvcConfigurer {
15.     // 配置 StandardServletMultipartResolver
16.     // Servlet 3.0+ 容器会自动提供 MultipartConfigElement，StandardServletMultipartResolver 基于此工作
17.     // 文件大小等限制可以在 Servlet 注册时（例如 MyWebAppInitializer）或通过容器配置实现
18.     @Bean
19.     public MultipartResolver multipartResolver() {
20.         return new StandardServletMultipartResolver();
21.     }
23.     // ... 其他配置
24. }

复制代码

假如在 MyWebAppInitializer.java 中必要配置上传属性 (如文件大小限定)，可以重写 customizeRegistration 方法：

1. package com.yourcompany.bookmanagement.config;
3. import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
5. import javax.servlet.MultipartConfigElement; // 引入
6. import javax.servlet.ServletRegistration; // 引入
8. public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
10.     // ... getRootConfigClasses, getServletConfigClasses, getServletMappings methods
12.     @Override
13.     protected void customizeRegistration(ServletRegistration.Dynamic registration) {
14.         // 配置文件上传属性：临时文件存放路径，最大文件大小，最大请求大小，文件阈值大小
15.         // 这些配置会传递给 StandardServletMultipartResolver
16.         String fileUploadTempDir = System.getProperty("java.io.tmpdir"); // 使用系统的临时目录
17.         long maxFileSize = 5 * 1024 * 1024; // 5MB
18.         long maxRequestSize = 10 * 1024 * 1024; // 10MB
19.         int fileSizeThreshold = 0; // 所有文件都直接写入临时文件，而不是内存
21.         MultipartConfigElement multipartConfigElement = new MultipartConfigElement(
22.                 fileUploadTempDir,
23.                 maxFileSize,
24.                 maxRequestSize,
25.                 fileSizeThreshold);
27.         registration.setMultipartConfig(multipartConfigElement);
28.     }
29. }

复制代码

Controller 处理惩罚文件上传：

1. package com.yourcompany.bookmanagement.controller;
3. import org.springframework.stereotype.Controller;
4. import org.springframework.web.bind.annotation.GetMapping;
5. import org.springframework.web.bind.annotation.PostMapping;
6. import org.springframework.web.bind.annotation.RequestMapping;
7. import org.springframework.web.bind.annotation.RequestParam;
8. import org.springframework.web.multipart.MultipartFile;
9. import org.springframework.web.servlet.mvc.support.RedirectAttributes;
11. import java.io.IOException;
12. import java.nio.file.Files; // 使用 NIO.2 进行文件操作
13. import java.nio.file.Path;
14. import java.nio.file.Paths;
16. @Controller
17. @RequestMapping("/files")
18. public class FileUploadController {
20.     // 文件保存的根目录 (请根据实际环境修改！)
21.     // 生产环境不应该硬编码在此处，应从配置读取
22.     private static final String UPLOADED_FOLDER = "/path/to/your/uploaded/files/"; // !!! 修改为你的实际路径 !!!
24.     @GetMapping("/upload")
25.     public String showUploadForm() {
26.         return "uploadForm"; // 返回上传表单视图 (如 uploadForm.html)
27.     }
29.     @PostMapping("/upload")
30.     public String handleFileUpload(@RequestParam("file") MultipartFile file,
31.                                    RedirectAttributes redirectAttributes) {
33.         // 简单校验：文件是否为空
34.         if (file.isEmpty()) {
35.             redirectAttributes.addFlashAttribute("message", "Please select a file to upload");
36.             return "redirect:/files/uploadStatus"; // 重定向到状态页面
37.         }
39.         try {
40.             // 获取文件名
41.             String fileName = file.getOriginalFilename();
42.             // 防止路径穿越等安全问题，实际应用中应更严格处理文件名
43.             Path path = Paths.get(UPLOADED_FOLDER + fileName);
45.             // 创建目标目录 (如果不存在)
46.             Files.createDirectories(path.getParent());
48.             // 将文件保存到目标路径
49.             Files.copy(file.getInputStream(), path); // 使用 NIO.2 Copy Stream
51.             redirectAttributes.addFlashAttribute("message", "You successfully uploaded '" + fileName + "'");
53.         } catch (IOException e) {
54.             e.printStackTrace();
55.             redirectAttributes.addFlashAttribute("message", "Failed to upload file: " + e.getMessage());
56.         }
58.         return "redirect:/files/uploadStatus"; // 重定向到状态页面显示结果
59.     }
61.     @GetMapping("/uploadStatus")
62.     public String uploadStatus() {
63.         return "uploadStatus"; // 返回上传状态视图 (如 uploadStatus.html)
64.     }
65. }

复制代码

上传表单视图 (uploadForm.html - Thymeleaf 示例):

1. <!DOCTYPE html>
2. <html xmlns:th="http://www.thymeleaf.org">
3. <head>
4.     <meta charset="UTF-8">
5.     <title>File Upload</title>
6. </head>
7. <body>
8.     <h1>Upload File</h1>
10.     <!-- 注意：method 必须是 POST，enctype 必须是 multipart/form-data -->
11.     <form method="POST" action="/files/upload" enctype="multipart/form-data">
12.         <div>
13.             <label for="file">Select File:</label>
14.             <input type="file" name="file" id="file" required/>
15.         </div>
16.         <div>
17.             <button type="submit">Upload</button>
18.         </div>
19.     </form>
20. </body>
21. </html>

复制代码

上传状态视图 (uploadStatus.html - Thymeleaf 示例):

1. <!DOCTYPE html>
2. <html xmlns:th="http://www.thymeleaf.org">
3. <head>
4.     <meta charset="UTF-8">
5.     <title>Upload Status</title>
6. </head>
7. <body>
8.     <h1>Upload Status</h1>
9.     <!-- 使用 th:text 获取 RedirectAttributes 中的 Flash 属性 -->
10.     <div th:if="${message}">
11.         <p th:text="${message}"></p>
12.     </div>
13.     <p><a th:href="@{/files/upload}">Upload Another File</a></p>
14. </body>
15. </html>

复制代码

文件下载

文件下载通常是通过设置HTTP响应头，让浏览器以下载方式处理惩罚响应内容。

• Controller 方法: 可以返回ResponseEntity<Resource>，或直接操纵HttpServletResponse。
  
• 设置响应头: 关键在于设置正确的Content-Disposition头，指定文件名并告知浏览器以下载方式处理惩罚；Content-Type头指定文件类型；Content-Length头指定文件大小。
  
• 写入响应体: 将文件内容通过流写入HttpServletResponse的输出流。
  

代码示例 (文件下载)

1. package com.yourcompany.bookmanagement.controller;
3. import org.springframework.core.io.InputStreamResource; // 引入资源类型
4. import org.springframework.core.io.Resource; // 引入资源接口
5. import org.springframework.http.HttpHeaders; // 引入 HTTP 头部
6. import org.springframework.http.MediaType; // 引入媒体类型
7. import org.springframework.http.ResponseEntity; // 引入 ResponseEntity
8. import org.springframework.stereotype.Controller;
9. import org.springframework.web.bind.annotation.GetMapping;
10. import org.springframework.web.bind.annotation.PathVariable;
11. import org.springframework.web.bind.annotation.RequestMapping;
13. import javax.servlet.http.HttpServletRequest; // 可能需要
14. import java.io.File;
15. import java.io.FileInputStream;
16. import java.io.IOException;
17. import java.nio.file.Files;
18. import java.nio.file.Path;
19. import java.nio.file.Paths;
21. @Controller
22. @RequestMapping("/files")
23. public class FileDownloadController {
25.     // 文件存放的根目录 (同上传示例)
26.     private static final String UPLOADED_FOLDER = "/path/to/your/uploaded/files/"; // !!! 修改为你的实际路径 !!!
28.     // 文件下载方法，返回 ResponseEntity<Resource>
29.     @GetMapping("/download/{fileName:.+}") // :.+ 匹配文件名，包括点号
30.     public ResponseEntity<Resource> downloadFile(@PathVariable String fileName, HttpServletRequest request) {
31.         Path filePath = Paths.get(UPLOADED_FOLDER).resolve(fileName).normalize(); // 构造文件路径
32.         File file = filePath.toFile();
34.         // 检查文件是否存在且可读
35.         if (!file.exists() || !file.canRead()) {
36.             // 抛出异常或返回 404 响应
37.             // return new ResponseEntity<>(HttpStatus.NOT_FOUND);
38.              throw new RuntimeException("File not found or cannot be read: " + fileName); // 示例抛出异常
39.         }
41.         try {
42.             // 确定文件的 Content-Type
43.             String contentType = request.getServletContext().getMimeType(file.getAbsolutePath());
44.             if (contentType == null) {
45.                 contentType = "application/octet-stream"; // 默认类型
46.             }
48.             // 创建 InputStreamResource
49.             InputStreamResource resource = new InputStreamResource(new FileInputStream(file));
51.             // 构建响应
52.             return ResponseEntity.ok()
53.                     .contentType(MediaType.parseMediaType(contentType)) // 设置 Content-Type
54.                     // 设置 Content-Disposition，inline 表示在线打开，attachment 表示下载
55.                     .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename="" + file.getName() + """)
56.                     .contentLength(file.length()) // 设置 Content-Length
57.                     .body(resource); // 设置响应体
58.         } catch (IOException ex) {
59.             // 记录错误日志并返回 500 响应或抛出异常
60.             ex.printStackTrace();
61.             // return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
62.             throw new RuntimeException("Error reading file: " + fileName, ex); // 示例抛出异常
63.         }
64.     }
65.     /*
66.     // 另一种使用 HttpServletResponse 的方式 (不推荐，因为它绕过了 Spring 的 HttpMessageConverter 等)
67.     @GetMapping("/download2/{fileName:.+}")
68.     public void downloadFile2(@PathVariable String fileName, HttpServletResponse response) throws IOException {
69.          Path filePath = Paths.get(UPLOADED_FOLDER).resolve(fileName).normalize();
70.          File file = filePath.toFile();
72.          if (!file.exists() || !file.canRead()) {
73.             response.sendError(HttpServletResponse.SC_NOT_FOUND, "File not found");
74.             return;
75.          }
77.          String contentType = request.getServletContext().getMimeType(file.getAbsolutePath());
78.          if (contentType == null) {
79.              contentType = "application/octet-stream";
80.          }
82.          response.setContentType(contentType);
83.          response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename="" + file.getName() + """);
84.          response.setContentLength((int) file.length());
86.          try (InputStream is = new FileInputStream(file);
87.               OutputStream os = response.getOutputStream()) {
88.              byte[] buffer = new byte[1024];
89.              int len;
90.              while ((len = is.read(buffer)) != -1) {
91.                  os.write(buffer, 0, len);
92.              }
93.              os.flush();
94.          } catch (IOException e) {
95.              // 错误处理
96.              e.printStackTrace();
97.              throw e; // 抛出异常让 Spring 的异常处理器处理
98.          }
99.     }
100.     */
101. }

复制代码

下载链接示例 (HTML):

1. <a th:href="@{/files/download/your_file_name.ext}">Download File</a>

复制代码

5. 国际化 (i18n) 与本地化 (L10n)

国际化 (i18n) 是使应用步伐能够适应差别语言和地区的过程。本地化 (L10n) 是为特定语言和地区定制应用步伐的过程，包括翻译文本、调解日期格式等。Spring MVC为国际化提供了强大的支持。
Spring MVC 对国际化的支持

• LocaleResolver: 用于解析当前用户的地区设置 (Locale)。Spring提供了多种实现：
  
  
  
  • AcceptHeaderLocaleResolver (默认): 根据请求头的Accept-Language确定Locale。
    
  • SessionLocaleResolver: 将Locale存储在HttpSession中。
    
  • CookieLocaleResolver: 将Locale存储在Cookie中。
    
  • FixedLocaleResolver: 固定使用某个Locale。
    
  
  
• MessageSource: 用于根据Locale加载国际化消息。它从资源文件（如.properties文件）中读取键值对。Spring提供了ResourceBundleMessageSource等实现。
  

配置资源文件和 Spring Bean

• 创建资源文件: 在src/main/resources目次下创建消息源文件，遵照basename_locale.properties的命名约定。
  
  
  
  • messages.properties (默认语言)
    
  • messages_en.properties (英语)
    
  • messages_zh_CN.properties (简体中文)
    
  • 文件内容为键值对，如：app.title=Book Management System
    
  
  
• 配置 MessageSource Bean: 在Spring配置中界说MessageSource Bean。
  
• 配置 LocaleResolver Bean: 在Spring MVC配置 (WebMvcConfigurer) 中界说LocaleResolver Bean。
  
• 配置 LocaleChangeInterceptor (可选): 假如想通过请求参数切换语言，配置LocaleChangeInterceptor。
  

代码示例 (国际化)

资源文件示例 (src/main/resources/messages_zh_CN.properties, messages_en.properties):
messages_zh_CN.properties:

1. app.title=图书管理系统
2. book.list.title=图书列表
3. book.detail.title=图书详情
4. book.form.add=新增图书
5. book.form.edit=编辑图书
6. book.title=标题
7. book.author=作者
8. book.isbn=ISBN
9. book.publicationDate=出版日期
10. button.save=保存
11. button.cancel=取消
12. action.details=详情
13. action.edit=编辑
14. action.delete=删除
15. message.save.success=图书信息保存成功！
16. message.delete.success=图书删除成功！
17. error.book.notFound=找不到ID为 {0} 的图书。
18. validation.NotBlank=字段不能为空
19. validation.Size=字段长度不符合要求
20. validation.Pattern=字段格式不正确
21. validation.PastOrPresent=日期不能晚于今天
22. login.title=用户登录
23. login.username=用户名
24. login.password=密码
25. login.button=登录
26. login.error=用户名或密码不正确。
27. logout.success=您已成功注销。

复制代码

messages_en.properties:

1. app.title=Book Management System
2. book.list.title=Book List
3. book.detail.title=Book Detail
4. book.form.add=Add Book
5. book.form.edit=Edit Book
6. book.title=Title
7. book.author=Author
8. book.isbn=ISBN
9. book.publicationDate=Publication Date
10. button.save=Save
11. button.cancel=Cancel
12. action.details=Details
13. action.edit=Edit
14. action.delete=Delete
15. message.save.success=Book information saved successfully!
16. message.delete.success=Book deleted successfully!
17. error.book.notFound=Book not found with ID: {0}.
18. validation.NotBlank=Field must not be blank
19. validation.Size=Field size constraints violated
20. validation.Pattern=Field format is incorrect
21. validation.PastOrPresent=Date cannot be in the future
22. login.title=User Login
23. login.username=Username
24. login.password=Password
25. login.button=Login
26. login.error=Invalid username or password.
27. logout.success=You have been logged out successfully.

复制代码

WebMvcConfig.java 配置 MessageSource 和 LocaleResolver:

1. package com.yourcompany.bookmanagement.config;
3. import org.springframework.context.MessageSource; // 引入 MessageSource
4. import org.springframework.context.annotation.Bean;
5. import org.springframework.context.annotation.Configuration;
6. import org.springframework.context.support.ResourceBundleMessageSource; // 引入实现类
7. import org.springframework.web.servlet.LocaleResolver; // 引入 LocaleResolver
8. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
9. import org.springframework.web.servlet.config.annotation.InterceptorRegistry; // 引入 InterceptorRegistry
10. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
11. import org.springframework.web.servlet.i18n.CookieLocaleResolver; // 引入 CookieLocaleResolver
12. import org.springframework.web.servlet.i18n.LocaleChangeInterceptor; // 引入 LocaleChangeInterceptor
14. import java.util.Locale; // 引入 Locale
16. @Configuration
17. @EnableWebMvc
18. // @ComponentScan...
19. public class WebMvcConfig implements WebMvcConfigurer {
21.     // ... MultipartResolver, AuthInterceptor 等其他 Bean
23.     // 配置 MessageSource Bean
24.     @Bean
25.     public MessageSource messageSource() {
26.         ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
27.         // 设置资源文件的 basename (不带语言和后缀)
28.         messageSource.setBasename("messages"); // 对应 src/main/resources/messages.properties, messages_en.properties 等
29.         messageSource.setDefaultEncoding("UTF-8"); // 设置编码
30.         messageSource.setUseCodeAsDefaultMessage(true); // 如果找不到对应的 code，使用 code 本身作为消息
31.         return messageSource;
32.     }
34.     // 配置 LocaleResolver Bean
35.     // 使用 CookieLocaleResolver 将用户选择的语言存储在 Cookie 中
36.     @Bean
37.     public LocaleResolver localeResolver() {
38.         CookieLocaleResolver localeResolver = new CookieLocaleResolver();
39.         localeResolver.setDefaultLocale(Locale.CHINA); // 设置默认区域为中国
40.         localeResolver.setCookieName("mylocale"); // 设置存储 Locale 的 Cookie 名称
41.         localeResolver.setCookieMaxAge(3600); // Cookie 有效期 (秒)
42.         return localeResolver;
43.     }
45.     // 配置 LocaleChangeInterceptor，用于通过参数切换语言
46.     @Bean
47.     public LocaleChangeInterceptor localeChangeInterceptor() {
48.         LocaleChangeInterceptor interceptor = new LocaleChangeInterceptor();
49.         // 设置参数名，例如通过访问 /books?lang=en 或 /books?lang=zh_CN 切换语言
50.         interceptor.setParamName("lang");
51.         return interceptor;
52.     }
54.     // 将 LocaleChangeInterceptor 注册到拦截器链中
55.     @Override
56.     public void addInterceptors(InterceptorRegistry registry) {
57.         // ... 注册 AuthInterceptor
58.         registry.addInterceptor(localeChangeInterceptor()); // 注册语言切换拦截器
59.     }
61.     // ... 其他 WebMvcConfigurer 方法
62. }

复制代码

在视图和后端使用本地化消息

• 在视图中 (Thymeleaf): 使用#messages内置对象和#{...}语法获取消息。
  1. <h1 th:text="#{book.list.title}">图书列表</h1>
  2. <p th:text="#{message.save.success}"></p>
  3. <!-- 获取带参数的消息，例如 error.book.notFound=找不到ID为 {0} 的图书。 -->
  4. <p th:text="#{error.book.notFound(${bookId})}"></p>
  5. <!-- 生成带语言切换参数的 URL -->
  6. <a th:href="@{/books(lang='en')}">English</a> | <a th:href="@{/books(lang='zh_CN')}">中文</a>

  复制代码
• 在视图中 (JSP): 必要配置Spring标签库，并使用<spring:message>标签。
  1. <%@ taglib uri="http://www.springframework.org/tags" prefix="spring" %>
  2. <spring:message code="book.list.title"/>
  3. <spring:message code="error.book.notFound" arguments="${bookId}"/>
  4. <a href="<spring:url value='/books'><spring:param name='lang' value='en'/></spring:url>">English</a>

  复制代码
• 在后端代码 (Controller/Service) 中: 通过注入MessageSource，使用getMessage()方法获取消息。
  

1. package com.yourcompany.bookmanagement.service.impl;
3. import org.springframework.beans.factory.annotation.Autowired;
4. import org.springframework.context.MessageSource; // 引入 MessageSource
5. import org.springframework.context.i18n.LocaleContextHolder; // 引入 LocaleContextHolder
6. import org.springframework.stereotype.Service;
8. import java.util.Locale; // 引入 Locale
10. @Service
11. public class MyService {
13.     private final MessageSource messageSource;
15.     @Autowired
16.     public MyService(MessageSource messageSource) {
17.         this.messageSource = messageSource;
18.     }
20.     public String getLocalizedGreeting(String name) {
21.         // 获取当前线程绑定的 Locale (由 LocaleResolver 决定)
22.         Locale currentLocale = LocaleContextHolder.getLocale();
23.         // 从 MessageSource 获取消息
24.         String greeting = messageSource.getMessage("greeting", new Object[]{name}, currentLocale);
25.         return greeting;
26.     }
28.     // 在异常处理中获取本地化消息
29.     // GlobalExceptionHandler.java (示例)
30.     // @ExceptionHandler(BookNotFoundException.class)
31.     // public ResponseEntity<ErrorResponse> handleBookNotFoundForRest(BookNotFoundException ex) {
32.     //     Locale currentLocale = LocaleContextHolder.getLocale();
33.     //     String errorMessage = messageSource.getMessage("error.book.notFound", new Object[]{ex.getBookId()}, currentLocale);
34.     //     return new ResponseEntity<>(new ErrorResponse(HttpStatus.NOT_FOUND.value(), errorMessage, System.currentTimeMillis()), HttpStatus.NOT_FOUND);
35.     // }
36. }

复制代码

6. 与前端框架集成考量

当Spring MVC作为纯后端API服务（使用@RestController），与前端框架（Vue.js, React, Angular等）集成时，主要必要考虑数据交互格式、接口设计和跨域问题。
集成模式

• 前后端分离: 后端Spring MVC提供RESTful API，前端框架负责整个UI渲染和用户交互。两者通过HTTP请求进行通信。这是如今主流的企业级Web应用开辟模式。
  
• 后端渲染+前端增强: 后端Spring MVC使用Thymeleaf等模板引擎渲染基础HTML页面，前端框架用于局部增强页面交互（如通过Ajax请求更新部分内容）。图书管理体系案例属于此模式。
  

CORS (跨域资源共享)

跨域请求指浏览器发起的，目标URL与当前页面URL的协议、域名、端口中任意一个差别的请求。出于安全考虑，浏览器会制止非同源的HTTP请求，除非服务器明白答应。RESTful API通常部署在与前端差别的域名或端口上，因此必要处理惩罚CORS问题。
Spring MVC提供了多种方式处理惩罚CORS：

• @CrossOrigin 注解: 应用在Controller类或方法上，答应来自指定来源的跨域请求。
  1. package com.yourcompany.bookmanagement.controller;
  3. import org.springframework.web.bind.annotation.CrossOrigin;
  4. import org.springframework.web.bind.annotation.GetMapping;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  8. @RestController
  9. @RequestMapping("/api/data")
  10. // 允许来自 http://localhost:8080 和 http://example.com 的跨域请求
  11. @CrossOrigin(origins = {"http://localhost:8080", "http://example.com"})
  12. public class DataController {
  14.     @GetMapping("/public")
  15.     public String getPublicData() {
  16.         return "This is public data.";
  17.     }
  19.     @GetMapping("/private")
  20.     @CrossOrigin("http://localhost:3000") // 方法级别的 @CrossOrigin 会覆盖类级别的设置
  21.     public String getPrivateData() {
  22.         return "This is private data.";
  23.     }
  24. }

  复制代码
• 全局 CORS 配置: 在WebMvcConfigurer中集中配置，实用于更复杂的场景或希望同一管理CORS规则。
  

1. package com.yourcompany.bookmanagement.config;
3. import org.springframework.context.annotation.Configuration;
4. import org.springframework.web.servlet.config.annotation.CorsRegistry; // 引入 CorsRegistry
5. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
6. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
8. @Configuration
9. @EnableWebMvc
10. // @ComponentScan...
11. public class WebMvcConfig implements WebMvcConfigurer {
13.     // ... 其他 WebMvcConfigurer 方法
15.     @Override
16.     public void addCorsMappings(CorsRegistry registry) {
17.         registry.addMapping("/api/**") // 配置需要允许跨域的路径模式，例如所有 /api 下的请求
18.                 .allowedOrigins("http://localhost:3000", "http://your-frontend-domain.com") // 允许的来源域名
19.                 .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") // 允许的 HTTP 方法
20.                 .allowedHeaders("*") // 允许的请求头
21.                 .allowCredentials(true) // 是否发送 Cookie 或认证信息
22.                 .maxAge(3600); // 预检请求 (Preflight Request) 的缓存时间 (秒)
23.     }
24. }

复制代码

API 接口设计对前端友爱的考量

• 一致的数据格式: 前端更容易处理惩罚一致的JSON结构。保持字段命名、日期格式等规范。
  
• 清晰的错误处理惩罚: RESTful API应返回明白的状态码，并在响应体中包罗同一结构的错误信息，便于前端解析和展示错误。
  
• 公道的数据结构: 根据前端页面或组件必要的数据结构来设计API响应，避免过度嵌套或返回冗余字段。
  
• 分页与过滤: 对于列表数据，提供分页、排序、过滤等查询参数，让前端能够机动地获取所需数据。
  
• 文档: 提供清晰的API文档（如Swagger/OpenAPI），方便前端开辟者明白和使用接口。
  

7. Spring Security 入门

Spring Security是一个强大且高度可定制的认证和授权框架。它可以轻松地为Spring应用步伐提供安全性。
Spring Security 焦点概念

• Authentication (认证): 验证用户身份，证实“你是谁”。通常通过用户名/暗码、证书等方式。
  
• Authorization (授权): 在身份认证后，确定用户是否有权访问某个资源或执行某个操纵。
  
• Principal: 当前认证用户的代表，通常包罗用户名、暗码、权限等信息。
  
• GrantedAuthority: 授予Principal的权限或角色（如ROLE_USER, read_permission）。
  
• AuthenticationManager: 负责处理惩罚认证请求。
  
• AccessDecisionManager: 负责处理惩罚授权决策。
  
• SecurityContextHolder: 存储当前应用步伐中Principal详细信息的容器。默认使用ThreadLocal策略，确保每个线程独立。
  
• Filter Chain (过滤器链): Spring Security通过一系列Servlet Filter来实现各种安全功能（如认证、授权、CSRF防护）。这些Filter被组织成一个链。DelegatingFilterProxy是Spring Security的焦点Filter，它将Servlet容器的请求委托给Spring Bean中的Security Filter Chain。
  

基础配置 (JavaConfig)

Spring Security通常通过JavaConfig进行配置。焦点是创建一个继承自WebSecurityConfigurerAdapter的配置类（大概使用新的SecurityFilterChain Bean方式，取决于Spring Security版本）。

1. package com.yourcompany.bookmanagement.config;
3. import org.springframework.context.annotation.Bean;
4. import org.springframework.context.annotation.Configuration;
5. import org.springframework.security.config.annotation.web.builders.HttpSecurity; // 引入 HttpSecurity
6. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; // 启用 Spring Security
7. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; // 引入适配器类
8. import org.springframework.security.core.userdetails.User; // 引入 UserDetails
9. import org.springframework.security.core.userdetails.UserDetails;
10. import org.springframework.security.core.userdetails.UserDetailsService; // 引入 UserDetailsService
11. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; // 引入密码编码器
12. import org.springframework.security.crypto.password.PasswordEncoder; // 引入接口
13. import org.springframework.security.provisioning.InMemoryUserDetailsManager; // 引入内存用户存储
15. // 启用 Spring Security 的 Web 安全功能
16. @EnableWebSecurity
17. @Configuration // 标记为配置类
18. public class SecurityConfig extends WebSecurityConfigurerAdapter { // 继承 WebSecurityConfigurerAdapter (Spring Security 5.7+ 推荐使用 SecurityFilterChain Bean)
20.     // 配置密码编码器 Bean
21.     @Bean
22.     public PasswordEncoder passwordEncoder() {
23.         return new BCryptPasswordEncoder(); // 使用 BCrypt 强哈希算法
24.     }
26.     // 配置用户详情服务 (AuthenticationManager 的一部分)
27.     // 这里使用内存存储用户，实际应用中通常从数据库加载 (实现 UserDetailsService 接口)
28.     @Bean
29.     @Override
30.     public UserDetailsService userDetailsService() {
31.         // 创建一个内存用户
32.         UserDetails user = User.builder()
33.                 .username("admin")
34.                 .password(passwordEncoder().encode("password")) // 密码必须编码
35.                 .roles("USER", "ADMIN") // 设置角色
36.                 .build();
37.         return new InMemoryUserDetailsManager(user);
38.     }
40.     // 配置 HTTP 请求的安全性规则
41.     @Override
42.     protected void configure(HttpSecurity http) throws Exception {
43.         http
44.             // 授权配置
45.             .authorizeRequests()
46.                 // /login, /resources/**, /webjars/** 路径无需认证即可访问
47.                 .antMatchers("/login", "/logout", "/resources/**", "/webjars/**").permitAll()
48.                 // /books/** 路径需要认证且具有 USER 或 ADMIN 角色才能访问
49.                 .antMatchers("/books/**").hasAnyRole("USER", "ADMIN")
50.                 // /admin/** 路径需要认证且具有 ADMIN 角色才能访问
51.                 .antMatchers("/admin/**").hasRole("ADMIN")
52.                 // 所有其他路径需要认证才能访问
53.                 .anyRequest().authenticated()
54.             .and()
55.             // 表单登录配置
56.             .formLogin()
57.                 .loginPage("/login") // 指定自定义的登录页面 URL
58.                 .permitAll() // 登录页面允许所有用户访问
59.             .and()
60.             // 注销配置
61.             .logout()
62.                 .logoutUrl("/logout") // 指定注销 URL (POST 请求)
63.                 .logoutSuccessUrl("/login?logout") // 注销成功后重定向的 URL
64.                 .permitAll(); // 注销 URL 允许所有用户访问
66.         // 禁用 CSRF 防护 (仅为简化示例，生产环境应启用并处理)
67.         // http.csrf().disable();
68.     }
70.     // Spring Security 5.7+ 推荐的配置方式 (使用 SecurityFilterChain Bean 替代 WebSecurityConfigurerAdapter)
71.     /*
72.     @Bean
73.     public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
74.          http
75.             // 授权配置
76.             .authorizeRequests()
77.                 .antMatchers("/login", "/logout", "/resources/**", "/webjars/**").permitAll()
78.                 .antMatchers("/books/**").hasAnyRole("USER", "ADMIN")
79.                 .antMatchers("/admin/**").hasRole("ADMIN")
80.                 .anyRequest().authenticated()
81.             .and()
82.             // 表单登录配置
83.             .formLogin()
84.                 .loginPage("/login")
85.                 .permitAll()
86.             .and()
87.             // 注销配置
88.             .logout()
89.                 .logoutUrl("/logout")
90.                 .logoutSuccessUrl("/login?logout")
91.                 .permitAll();
92.         return http.build();
93.     }
94.      */
95. }

复制代码

分析：

• @EnableWebSecurity注解会加载Spring Security的焦点配置类。
  
• WebSecurityConfigurerAdapter提供了一个方便的基类来定制安全性配置。
  
• configure(HttpSecurity http)方法是配置URL授权规则、表单登录、注销等的焦点。
  
• userDetailsService()方法配置如何加载用户信息。InMemoryUserDetailsManager用于测试，实际应用必要实现UserDetailsService从数据库等加载。
  
• passwordEncoder()配置暗码加密器，Spring Security强制要求使用加密后的暗码。BCryptPasswordEncoder是推荐的选择。
  

暗码加密

使用PasswordEncoder接口对用户暗码进行加密存储和比对。BCryptPasswordEncoder使用BCrypt算法，该算法包罗了随机盐值和多次哈希迭代，安全性较高。

• 存储暗码时：String encodedPassword = passwordEncoder.encode(rawPassword);
  
• 校验暗码时：boolean isMatch = passwordEncoder.matches(rawPassword, encodedPassword);
  

方法级别安全注解

除了掩护URL路径，Spring Security还支持通过注解掩护Controller或Service方法。

• 启用方法安全: 在任何一个@Configuration类上添加@EnableGlobalMethodSecurity注解。
  
  
  
  • prePostEnabled = true: 启用@PreAuthorize和@PostAuthorize注解。
    
  • securedEnabled = true: 启用@Secured注解。
    
  1. package com.yourcompany.bookmanagement.config;
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity; // 引入
  6. @Configuration
  7. @EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true) // 启用方法安全注解
  8. public class MethodSecurityConfig {
  9.     // 此类通常是独立的，或者合并到 SecurityConfig 中
  10. }

  复制代码
  
  
• 使用注解:
  
  
  
  • @PreAuthorize: 在方法执行之前进行权限查抄。可以使用Spring EL表达式。
    
    
    
    • @PreAuthorize("hasRole('ADMIN')"): 只有ADMIN角色才气访问。
      
    • @PreAuthorize("hasAnyRole('USER', 'ADMIN')"): USER或ADMIN角色都能访问。
      
    • @PreAuthorize("hasPermission(#bookId, 'book', 'read')"): 自界说权限表达式。
      
    • @PreAuthorize("#username == authentication.principal.username"): 参数username必须是当前登录用户的username。
      
    
    
  • @PostAuthorize: 在方法执行之后进行权限查抄。可以访问返回值。
    
    
    
    • @PostAuthorize("returnObject.username == authentication.principal.username"): 返回值的username必须是当前登录用户的username。
      
    
    
  • @Secured: 基于角色的简朴权限查抄，不支持Spring EL。
    
    
    
    • @Secured("ROLE_ADMIN"): 只有ROLE_ADMIN角色才气访问。
      
    • @Secured({"ROLE_USER", "ROLE_ADMIN"}): ROLE_USER或ROLE_ADMIN角色都能访问。
      
    
    
  
  

代码示例 (方法安全)

1. package com.yourcompany.bookmanagement.controller;
3. import org.springframework.security.access.annotation.Secured; // 引入 @Secured
4. import org.springframework.security.access.prepost.PreAuthorize; // 引入 @PreAuthorize
5. import org.springframework.web.bind.annotation.*;
7. @RestController
8. @RequestMapping("/secure")
9. public class SecureController {
11.     // 需要 ADMIN 角色才能访问
12.     @GetMapping("/admin")
13.     @Secured("ROLE_ADMIN") // 或 @PreAuthorize("hasRole('ADMIN')")
14.     public String adminOnly() {
15.         return "This content is for ADMINs only!";
16.     }
18.     // 需要 USER 或 ADMIN 角色才能访问
19.     @GetMapping("/user")
20.     @PreAuthorize("hasAnyRole('USER', 'ADMIN')")
21.     public String userOrAdmin() {
22.         return "This content is for logged-in users (USER or ADMIN)!";
23.     }
25.     // 示例：基于输入参数的权限检查
26.     // 只有当请求的 username 与当前认证用户的 username 相同时才能访问
27.     @GetMapping("/profile/{username}")
28.     @PreAuthorize("#username == authentication.principal.username")
29.     public String getUserProfile(@PathVariable String username) {
30.         return "Viewing profile for user: " + username;
31.     }
32. }

复制代码

掩护URL路径访问

通过在HttpSecurity配置中使用antMatchers(), regexMatchers(), anyRequest()等匹配器联合permitAll(), authenticated(), hasRole(), hasAuthority()等方法来界说哪些URL必要哪些权限。这是最常用的掩护方式。示例已包罗在基础配置代码中。
运行与部署

参考图书管理体系案例中的Maven构建WAR包和部署到Servlet容器步骤。Spring Security作为Filter Chain会自动集成到请求处理惩罚流程中。
总结

通过学习这些高级主题，你将能够构建更加健壮、安全、易于维护和集成的企业级Spring MVC应用步伐。RESTful API是前后端分离的基石；同一异常处理惩罚提拔用户体验和开辟服从；拦截器提供机动的请求处理惩罚增强；文件处理惩罚是常见功能；国际化使应用适应全球用户；Spring Security提供全面的安全保障。
持续学习发起：

• Spring Security 深入： 用户详情服务 (UserDetailsService)、自界说认证提供者、OAuth2、JWT等。
  
• RESTful API 进阶： API文档（Swagger/OpenAPI）、API网关、更复杂的HATEOAS实现。
  
• 缓存： 使用Spring Cache提拔数据访问性能。
  
• 消息队列： 集成RabbitMQ, Kafka等处理惩罚异步任务和解耦。
  
• 分布式体系： 相识Spring Cloud体系。
  
• 最紧张：转向 Spring Boot！ 将这些学到的原生Spring MVC知识应用到Spring Boot情况中，你会发现开辟服从的巨大提拔。Spring Boot基于约定大于配置的理念，自动集成了大量常用功能（包括上述大部分高级特性），让你更专注于业务逻辑。
  

希望这篇文章能资助你更好地迈向Spring MVC高级开辟！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告