起源

1. 三层架构：一个 Servlet 只能处理一个请求，耦合度高，复用性差，整页刷新用户体验差

2. MVC 模式：部分解耦但后端仍负责 View层，高并发有限

3. 前后端分离：异步调用，复用性强，支持复杂交互，用户体验性强

概念

• SpringMVC 是 Spring 框架中的一个模块，用于构建 Web 的 MVC 架构，提供了简洁、优雅的方式来开发 Web 程序，尤其是 HTTP 请求和响应。
• MVC：Model-View-Contorller，是一种软件设计模式，用于实现应用程序的分层和职责分离，达到解耦的目的。

1. Model（模型 )

• 包含程序的业务逻辑和数据。
• 通常由 Service 层和 Dao 层支持。
• 在 SpringMVC 中，Model 的数据可以通过 Model或 ModelAndView对象传递到 View 层。

2. View（视图）

• 用户界面部分，负责展示页面和数据给用户。
• SpringMVC 支持多种视图技术（之前的 JSP，Thymeleaf 等）

3. Controller（控制器）

• 负责接受用户请求，调用业务逻辑（Model），并将结果返回给 View。
• SpringMVC 使用注解方式来定义控制器，如@Controller，@RestController等。

执行流程

组件

1. DispatchServlet

• 职责：核心调度器，负责整个请求处理流程的控制。
• 功能：将请求分发到具体的处理器。

2. HandlerMapping

• 职责：根据 URL 映射到对应的 Handler
• 功能：通过注解（@RequestMapping、@GetMapping等）或 XML 配置定义 URL 和 Handler 的映射关系。

3. HandlerAdapter

• 职责：调用处理器的方法，完成请求的核心业务处理。
• 功能：提供灵活性，支持多种类型的处理器（注解、接口等）

4. Handler（Controller）

• 职责：接受请求，执行具体的业务逻辑。
• 功能：使用@Controller注解定义，Handler 方法负责调用业务逻辑层并返回结果。

5. ViewResolver

• 职责：将逻辑视图解析为具体的 View。
• 功能：支持 JSP、Thymeleaf 等多种视图技术。

6. View

• 职责：负责将数据展示给用户。
• 功能：渲染 Model 并返回给客户端。

包含的注解

SpringMVC 中常用的注解可以分为以下几类，分别对应不同的功能和场景：

1. 核心控制器注解

@Controller

• 作用：标记一个类为控制器，用于处理 HTTP 请求。
• 示例：

@Controller
public class MyController {
    @RequestMapping("/hello")
    public String hello() {
        return "hello"; // 视图名
    }
}

@RestController

• 作用：组合注解，相当于 @Controller + @ResponseBody，用于返回 JSON 或 XML 数据，而不是视图。
• 示例：

@RestController
public class ApiController {
    @GetMapping("/api/data")
    public String getData() {
        return "This is JSON response.";
    }
}

2. 请求映射相关注解

@RequestMapping

• 作用：映射请求路径，可以用于类或方法级别。
• 示例：

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/profile")
    public String userProfile() {
        return "profile";
    }
}

@GetMapping / @PostMapping / @PutMapping / @DeleteMapping / @PatchMapping

• 作用：对应 HTTP 请求方法的快捷注解，等价于 @RequestMapping(method = RequestMethod.GET/POST/PUT/DELETE/PATCH)。
• 示例：

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

3. 请求参数相关注解

在 SpringMVC 中，HTTP 请求中的参数通常是简单类型（如 String、int 等），使用其他类型时，最好加上 @RequestParam，日期格式使用@DateTimeFormat

@RequestParam

• 作用：获取请求参数（常见于查询参数）。
• 示例：

@GetMapping("/search")
public String search(@RequestParam("keyword") String keyword) {
    return "Search for: " + keyword;
}

@PathVariable

• 作用：获取路径中的动态参数。
• 示例：

@GetMapping("/user/{id}")
public String getUserById(@PathVariable("id") String id) {
    return "User ID: " + id;
}

@RequestBody

• 作用：解析请求体中的 JSON 或 XML 数据，并将其绑定到对象。
• 示例：

@PostMapping("/addUser")
public String addUser(@RequestBody User user) {
    return "User Name: " + user.getName();
}

@RequestHeader

• 作用：获取 HTTP 请求头的值。
• 示例：

@GetMapping("/header")
public String getHeader(@RequestHeader("Authorization") String auth) {
    return "Auth: " + auth;
}

@CookieValue

• 作用：获取 Cookie 值。
• 示例：

@GetMapping("/cookie")
public String getCookie(@CookieValue("sessionId") String sessionId) {
    return "Session ID: " + sessionId;
}

4. 返回结果相关注解

@ResponseBody

• 作用：将返回结果直接写入 HTTP 响应体（通常用于返回 JSON 或 XML 数据）。
• 示例：

@ResponseBody
@GetMapping("/json")
public String jsonResponse() {
    return "{"key":"value"}";
}

@ModelAttribute

• 作用：将方法返回值或请求参数绑定到模型中，在视图渲染时可用。
• 示例：

@ModelAttribute
public void addAttributes(Model model) {
    model.addAttribute("message", "Hello World");
}

5. 数据验证相关注解

@Valid

• 作用：对方法参数进行校验（需要配合 Java Bean Validation API）。
• 示例：

@PostMapping("/save")
public String saveUser(@Valid @RequestBody User user, BindingResult result) {
    if (result.hasErrors()) {
        return "Validation failed";
    }
    return "Success";
}

6. 其他注解

@SessionAttributes

• 作用：将某些模型属性存储到会话中，便于后续访问。
• 示例：

@SessionAttributes("user")
@Controller
public class SessionController {
    @GetMapping("/setSession")
    public String setSession(Model model) {
        model.addAttribute("user", "John");
        return "session";
    }
}

@RequestPart

• 作用：处理 multipart/form-data 请求，常用于文件上传。
• 示例：

@PostMapping("/upload")
public String handleFileUpload(@RequestPart("file") MultipartFile file) {
    return "Uploaded: " + file.getOriginalFilename();
}

总结

异常处理器

在 SpringMVC 中，异常处理器用于集中处理控制器方法中发生的异常，避免将异常直接暴露给用户，同时可以返回友好的提示信息或进行日志记录。以下是常见的异常处理方式：

1. 使用 @ExceptionHandler 注解

可以在控制器类中定义一个方法，通过 @ExceptionHandler 注解指定要捕获的异常类型。

示例：

@Controller
public class MyController {

    @RequestMapping("/test")
    public String test() {
        throw new RuntimeException("测试异常");
    }

    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public String handleRuntimeException(RuntimeException e) {
        return "捕获到异常: " + e.getMessage();
    }
}

• 特点：

• • 方法参数中可以获取异常对象。
  • 返回值支持视图名称或数据（配合 @ResponseBody 返回 JSON 数据）。

2. 使用 @ControllerAdvice

@ControllerAdvice 是一个全局异常处理器，适用于所有控制器。

示例：

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public String handleGlobalRuntimeException(RuntimeException e) {
        return "全局异常处理器捕获: " + e.getMessage();
    }
}

• 特点：

• • 集中管理异常处理逻辑。
  • 提高代码的可维护性。

3. 实现 HandlerExceptionResolver 接口

可以自定义异常处理器，通过实现 HandlerExceptionResolver 接口来捕获和处理异常。

示例：

@Component
public class MyExceptionResolver implements HandlerExceptionResolver {

    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("error", ex.getMessage());
        modelAndView.setViewName("error"); // 指向 error.jsp
        return modelAndView;
    }
}

• 特点：

• • 灵活性高，可以处理不同类型的异常并返回不同的视图。
  • 适合需要自定义复杂逻辑的场景。

4. 使用 ResponseStatusExceptionResolver

通过在异常类上添加 @ResponseStatus 注解，指定 HTTP 状态码和原因。

示例：

@ResponseStatus(value = HttpStatus.NOT_FOUND, reason = "资源未找到")
public class ResourceNotFoundException extends RuntimeException {
}

在控制器中抛出该异常时，会返回对应的 HTTP 状态码和原因。

5. 基于 @RestControllerAdvice

@RestControllerAdvice 是 @ControllerAdvice 的变体，返回值默认是 JSON 格式（结合 @ResponseBody 的功能）。

示例：

@RestControllerAdvice
public class RestGlobalExceptionHandler {

    @ExceptionHandler(RuntimeException.class)
    public Map handleRuntimeException(RuntimeException e) {
        Map response = new HashMap();
        response.put("code", 500);
        response.put("message", e.getMessage());
        return response;
    }
}

• 特点：

• • 专门用于 RESTful 风格的异常处理。
  • 返回 JSON 数据而非视图。

常见的异常类型处理

1. 404 Not Found：

• • 可以通过 @ResponseStatus 或自定义异常处理器返回。

2. 参数校验异常（如 @Valid 或 @Validated）：

• • 使用 MethodArgumentNotValidException 或 BindException 捕获。

@ExceptionHandler(MethodArgumentNotValidException.class)
public Map handleValidationException(MethodArgumentNotValidException e) {
    Map errors = new HashMap();
    e.getBindingResult().getFieldErrors().forEach(error -> 
        errors.put(error.getField(), error.getDefaultMessage())
    );
    return errors;
}

选择适合的方式

• 简单项目：使用 @ExceptionHandler。
• 全局异常管理：使用 @ControllerAdvice 或 @RestControllerAdvice。
• 复杂需求：实现 HandlerExceptionResolver 接口。
• REST 风格接口：推荐使用 @RestControllerAdvice。

通过合理设计异常处理器，可以提高系统的健壮性和用户体验。

Rest 风格

Rest 风格简介

REST（Representational State Transfer，表述性状态转移）是一种基于资源的网络架构风格，由 Roy Fielding 在他的博士论文中提出。它是一种设计 API 的方法，使客户端和服务端之间的交互更加简单、灵活和高效。

Rest 风格的核心原则

1. 资源（Resource）

• • 一切皆资源，资源是 Web 系统中的核心概念。
  • 资源通常以 URL 表示。
  • 每个资源都有唯一的标识符（URI）。
    例如：
  • /users 表示用户资源集合。
  • /users/123 表示具体用户资源。

2. 无状态（Stateless）

• • 服务端不会存储客户端状态。
  • 每个请求都包含所有必要的信息（如认证信息、上下文）。
  • 提高系统的可伸缩性，但需要客户端提供更多信息。

3. 统一接口（Uniform Interface）

• • 使用标准的 HTTP 方法和状态码。
  • REST 定义了操作资源的四种主要方法：

• • • GET：读取资源。
    • POST：创建资源。
    • PUT：更新资源（通常是全量更新）。
    • DELETE：删除资源。

4. 表现层（Representation）

• • 资源的表现形式可以是 JSON、XML、HTML 等。
  • 不同的表现形式不会改变资源本身。
  • 通过 Content-Type 和 Accept 标头实现内容协商。

5. 客户端-服务器分离（Client-Server）

• • 客户端负责用户界面，服务端负责业务逻辑。
  • 松耦合的架构设计提高了可维护性和扩展性。

6. 可缓存性（Cacheable）

• • 服务端可以通过标头（如 Cache-Control）指示客户端是否可以缓存响应数据。
  • 减少网络传输，提高响应速度。

Rest 风格的 HTTP 请求方法

RESTful 状态码

示例：Rest 风格的 API

1. 获取所有用户（GET 请求）

GET /users HTTP/1.1
Host: example.com
Accept: application/json

响应：

[
    {
        "id": 1,
        "name": "Alice",
        "email": "alice@example.com"
    },
    {
        "id": 2,
        "name": "Bob",
        "email": "bob@example.com"
    }
]

2. 创建新用户（POST 请求）

POST /users HTTP/1.1
Host: example.com
Content-Type: application/json

{
    "name": "Charlie",
    "email": "charlie@example.com"
}

响应：

HTTP/1.1 201 Created
Location: /users/3

3. 更新用户信息（PUT 请求）

PUT /users/3 HTTP/1.1
Host: example.com
Content-Type: application/json

{
    "name": "Charlie",
    "email": "charlie.new@example.com"
}

响应：

HTTP/1.1 200 OK

4. 删除用户（DELETE 请求）

DELETE /users/3 HTTP/1.1
Host: example.com

响应：

HTTP/1.1 204 No Content

Rest 风格的优点

1. 简单：基于 HTTP 标准协议，易于实现和理解。
2. 灵活：支持多种数据格式（JSON、XML 等）。
3. 高扩展性：客户端和服务端解耦，便于扩展和维护。
4. 适合微服务：常用于构建微服务架构的 API。

Rest 风格的局限性

1. 无状态限制：需要客户端重复传递上下文信息，可能增加负担。
2. 复杂事务支持不足：分布式系统中，需要通过补偿机制实现复杂事务。
3. 对实时性支持较弱：不适用于需要双向通信的场景（如 WebSocket 更适合）。

总结

Rest 风格是一种通用的、灵活的 API 设计模式，广泛应用于 Web 服务和微服务架构。通过严格遵守其原则，开发者可以构建出高效、易维护的系统。

拦截器

在 SpringMVC 中，拦截器（Interceptor）是一种动态拦截请求并对其进行预处理和后处理的机制，类似于 Servlet 的过滤器（Filter），但功能更强大且更精细化。拦截器的核心是实现 HandlerInterceptor 接口或继承其实现类，并通过配置注册到应用程序中。

1. 拦截器的用途

• 日志记录：记录请求的处理时间或访问记录。
• 权限校验：检查用户是否有权限访问某些资源。
• 参数预处理：对请求参数进行统一校验或修改。
• 响应后处理：在响应数据返回之前进行修改或处理。
• 全局异常处理：捕获和处理控制器未捕获的异常。

2. 拦截器的核心接口

HandlerInterceptor 接口定义了拦截器的三个核心方法，分别在不同的生命周期阶段调用。

接口方法：

public interface HandlerInterceptor {

    // 在处理请求之前调用
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    // 在处理请求之后，渲染视图之前调用
    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    }

    // 在整个请求完成之后调用
    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    }
}

• preHandle：

1. 1. 权限校验或认证：

• • • 验证用户是否已登录或是否有权限访问某个资源。
    • 如果权限校验失败，可以直接返回 false，阻止请求继续进入控制器。

1. 2. 日志记录：

• • • 记录请求的基本信息，如 URL、参数、Headers 等。

1. 3. 参数验证或处理：

• • • 检查请求中是否携带必需的参数。
    • 对某些参数进行预处理或转换。

1. 4. 短路机制：

• • • 如果 preHandle 返回 false，表示请求被拦截，Spring MVC 不会继续调用后续拦截器、控制器方法和视图渲染逻辑。

• postHandle：

• • 修改返回数据：

• • • 可以通过操作 ModelAndView 对返回的数据或视图名称进行修改。
    • 例如，在 ModelAndView 中添加全局变量（如用户信息、系统时间等）。

• • 日志记录：

• • • 记录控制器方法的执行结果。
    • 分析控制器方法的处理时间。

• • 动态调整视图：

• • • 根据业务需求动态修改视图名称或数据（例如国际化处理）。

• • 扩展功能：

• • • 在控制器返回数据后，进行某些业务逻辑处理（如数据格式化、敏感信息脱敏等）。

• afterCompletion：

• • 资源清理：

• • • 释放在 preHandle 或 postHandle 中分配的资源（如数据库连接、线程资源等）。
    • 清除 ThreadLocal 中绑定的变量，防止内存泄漏。

• • 日志记录：

• • • 记录整个请求的执行情况，包括耗时、返回结果、是否发生异常等信息。
    • 如果 Exception ex 不为 null，可以记录错误日志或报警。

• • 性能监控：

• • • 在 preHandle 中记录请求开始时间，在 afterCompletion 中记录请求结束时间，计算整个请求的耗时。

• • 异常处理或补偿：

• • • 检查异常 ex 是否存在，根据异常类型执行补偿逻辑。
    • 例如，在某些情况下发送告警通知或回滚某些已完成的操作。
    • 全局清理：
    • 无论请求是否成功处理，都确保执行某些全局清理操作，如关闭流、删除临时文件等。

3. 拦截器的实现

实现 HandlerInterceptor 接口或继承其默认实现类 HandlerInterceptorAdapter。

示例：简单的日志拦截器

@Component
public class LoggingInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle: 请求路径是 " + request.getRequestURI());
        return true; // 返回 true 表示继续执行
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle: 处理完成，但视图还未渲染");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion: 请求已完成，视图已渲染");
    }
}

4. 拦截器的注册

拦截器需要注册到 SpringMVC 的拦截器链中，通过实现 WebMvcConfigurer 来完成。

注册示例：

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoggingInterceptor())
                .addPathPatterns("/**") // 拦截所有路径
                .excludePathPatterns("/login", "/error"); // 排除路径
    }
}

• addPathPatterns：指定拦截的路径模式。
• excludePathPatterns：指定不拦截的路径模式。

5. 多拦截器的执行顺序

多个拦截器按注册顺序执行：

• preHandle：按注册顺序执行。
• postHandle 和 afterCompletion：按注册顺序的逆序执行。

示例 1：

示例 2：

@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(new FirstInterceptor());
    registry.addInterceptor(new SecondInterceptor());
}

执行顺序：

1. FirstInterceptor.preHandle
2. SecondInterceptor.preHandle
3. 控制器方法执行
4. SecondInterceptor.postHandle
5. FirstInterceptor.postHandle
6. SecondInterceptor.afterCompletion
7. FirstInterceptor.afterCompletion

小结：

• 只要拦截器 X 的 preHandle 返回 true ，Spring MVC 会确保在请求生命周期结束时调用拦截器 X 的 afterCompletion() ，无论后续的处理是正常结束还是发生异常。
• preHandler执行顺序类似队列，postHandler与 afterCompletion类似栈。

6. 与过滤器的区别

7. 常见场景

1. 登录校验拦截器：

@Component
public class AuthInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession();
        if (session.getAttribute("user") == null) {
            response.sendRedirect("/login");
            return false; // 阻止后续处理
        }
        return true;
    }
}

2. 跨域拦截器： 动态设置跨域响应头。
3. 日志拦截器： 记录请求和响应的详细信息。

通过合理设计和注册拦截器，可以显著提升应用的扩展性和灵活性。